"{ Package: 'exept:regression' }"

"{ NameSpace: RegressionTests }"

TestCase subclass:#CollectionTests

	instanceVariableNames:'empty nonEmpty'

	classVariableNames:''

	poolDictionaries:''

	category:'tests-Regression'

!

Object subclass:#SortTestData

	instanceVariableNames:'value order'

	classVariableNames:''

	poolDictionaries:''

	privateIn:CollectionTests

!

!CollectionTests class methodsFor:'documentation'!

coveredClasses

    ^ Collection withAllSubclasses

!

documentation

"

    documentation to be added.

    [author:]

        Claus Gittinger (cg@alan)

    [see also:]

    [instance variables:]

    [class variables:]

"

!

history

    "Created: / 8.11.2001 / 08:17:09 / cg"

! !

!CollectionTests methodsFor:'helpers'!

checkSorted:aSortedCollection with:sortBlock against:anOriginalCollection

    |first|

    self assert:aSortedCollection size = anOriginalCollection size.

    "is it sorted?"

    first := true.

    aSortedCollection inject:nil into:[:last :each|

            first ifTrue:[first := false] 

                  ifFalse:[self assert:(sortBlock value:last value:each)]. each].

    "same elements as in original?"

    self assert:(aSortedCollection asBag = anOriginalCollection asBag).

!

collectedDoArgsOf:aCollection

    |collectedDoArgs|

    collectedDoArgs := OrderedCollection new.

    aCollection do:[:each | collectedDoArgs add:each].

    ^ collectedDoArgs

! !

!CollectionTests methodsFor:'initialize-release'!

setUp

        empty := Set new.

        nonEmpty := OrderedCollection with: #x.

! !

!CollectionTests methodsFor:'tests-dictionary'!

testDictionary01

    |d v1 v2 v3 ret|

    d := Dictionary new.

    d at:1 put:(v1 := 'one').

    d at:2 put:(v2 := 'two').

    d at:3 put:(v3 := 'three').

    self assert: ( d size == 3 ).

    self assert:(ret := self collectedDoArgsOf:d) asSet = #('one' 'two' 'three') asSet.

    self assert:(ret := d collect:[:each | each]) = #('one' 'two' 'three') asBag.

    self assert:(ret := d select:[:each | true]) = (Dictionary withAssociations:(Array with:(1->'one') with:(2->'two') with:(3->'three'))).

    self assert: ( (d at:1) == v1 ).

    self assert: ( (d at:2) == v2 ).

    self assert: ( (d at:3) == v3 ).

    d at:3 put:(v3 := 'drei').

    self assert: ( d size == 3 ).

    self assert: ( (d at:1) == v1 ).

    self assert: ( (d at:2) == v2 ).

    self assert: ( (d at:3) == v3 ).

    self assert: ( (d keyAtValue:v1) = 1 ).

    "

     self basicNew testDictionary01

    "

    "Modified: / 04-07-2011 / 19:28:39 / cg"

! !

!CollectionTests methodsFor:'tests-general'!

doTestDictionaryLikeAddRemoveOperationsIn:aClass

    |coll|

    coll := aClass new.

    self assert: ( coll size == 0 ).

    self assert: ( coll isEmpty ).

    self assert: ( coll notEmpty not ).

    self assert: ( coll isEmptyOrNil ).

    self assert: ( coll notEmptyOrNil not ).

    coll at:1 put:'one'.

    self assert: ( coll size == 1 ).

    self assert: ( coll isEmpty not).

    self assert: ( coll notEmpty ).

    self assert: ( coll isEmptyOrNil not ).

    self assert: ( coll notEmptyOrNil ).

    coll at:2 put:'two'.

    self assert: ( coll size == 2 ).

    self assert: ( coll isEmpty not).

    self assert: ( coll notEmpty ).

    self assert: ( coll isEmptyOrNil not ).

    self assert: ( coll notEmptyOrNil ).

    coll removeKey:2.

    self assert: ( coll size == 1 ).

    self assert: ( coll isEmpty not).

    self assert: ( coll notEmpty ).

    self assert: ( coll isEmptyOrNil not ).

    self assert: ( coll notEmptyOrNil ).

    coll removeKey:1.

    self assert: ( coll size == 0 ).

    self assert: ( coll isEmpty ).

    self assert: ( coll notEmpty not ).

    self assert: ( coll isEmptyOrNil ).

    self assert: ( coll notEmptyOrNil not ).

    "

     self basicNew doTestDictionaryLikeAddRemoveOperations

    "

    "Created: / 08-08-2011 / 16:01:14 / cg"

!

doTestGeneralAddRemoveOperationsIn:aClass

    |coll|

    coll := aClass new.

    self assert: ( coll size == 0 ).

    self assert: ( coll isEmpty ).

    self assert: ( coll notEmpty not ).

    self assert: ( coll isEmptyOrNil ).

    self assert: ( coll notEmptyOrNil not ).

    coll add:1.

    self assert: ( coll size == 1 ).

    self assert: ( coll isEmpty not).

    self assert: ( coll notEmpty ).

    self assert: ( coll isEmptyOrNil not ).

    self assert: ( coll notEmptyOrNil ).

    coll add:2.

    self assert: ( coll size == 2 ).

    self assert: ( coll isEmpty not).

    self assert: ( coll notEmpty ).

    self assert: ( coll isEmptyOrNil not ).

    self assert: ( coll notEmptyOrNil ).

    coll remove:2.

    self assert: ( coll size == 1 ).

    self assert: ( coll isEmpty not).

    self assert: ( coll notEmpty ).

    self assert: ( coll isEmptyOrNil not ).

    self assert: ( coll notEmptyOrNil ).

    coll remove:1.

    self assert: ( coll size == 0 ).

    self assert: ( coll isEmpty ).

    self assert: ( coll notEmpty not ).

    self assert: ( coll isEmptyOrNil ).

    self assert: ( coll notEmptyOrNil not ).

    "

     self basicNew testGeneralOperations

    "

    "Created: / 08-08-2011 / 16:00:06 / cg"

!

doTestGeneralCollectionOperationsIn:aClass

    |coll|

    coll := aClass new.

    self assert: ( coll size == 0 ).

    self assert: ( coll isEmpty ).

    self assert: ( coll notEmpty not ).

    self assert: ( coll isEmptyOrNil ).

    self assert: ( coll notEmptyOrNil not ).

    self should: [ coll first ] raise:Error.

    self should: [ coll last ] raise:Error.

    self should: [ (coll at:1) ] raise:Error.

    self assert: ( (coll includes:0) not ).

    "

     self basicNew testGeneralOperations

    "

!

doTestSequentialCollectionOperationsIn:aClass

    |coll1 coll2|

    coll1 := self protoCollectionFor: aClass.

    self assert: ( coll1 size > 0 ).

    self assert: ( coll1 isEmpty not ).

    self assert: ( coll1 notEmpty ).

    self assert: ( coll1 isEmptyOrNil not ).

    self assert: ( coll1 notEmptyOrNil ).

    self assert: ( coll1 first = (coll1 at:1) ).

    self assert: ( coll1 last = (coll1 at:(coll1 size)) ).

    self assert: ( coll1 = coll1 ).

    self assert: ( coll1 ~= coll1 ) not.

    coll2 := coll1 copy.

    self assert: ( coll2 = coll1 ).

    coll2 replaceFrom:1 to:coll2 size with:coll1 startingAt:1.

    self assert: ( coll2 = coll1 ).

    "overlapping copy"

    coll2 replaceFrom:2 to:coll2 size with:coll2 startingAt:1.

    coll2 replaceFrom:1 to:coll2 size-1 with:coll2 startingAt:2.

    coll2 at:(coll2 size) put:(coll1 at:coll1 size).

    self assert: ( coll2 = coll1 ).

    "

     self basicNew testSequentialCollectionOperations

    "

    "Created: / 08-05-2012 / 10:50:08 / cg"

!

protoCollectionFor: aClass

    aClass == BooleanArray ifTrue: [

        ^ BooleanArray withAll:#(true false true true false false true false false true)

    ].

    aClass == BitArray ifTrue: [

        ^ BitArray withAll:#(1 0 1 1 0 0 1 0 0 1)

    ].

    aClass == ByteArray ifTrue: [

        ^ ByteArray withAll:#(1 2 3 4 16rFC 16rFD 16rFE 16rFF)

    ].

    aClass == String ifTrue: [

        ^ 'abcdefghijklmnopqrstuvwxyz'

    ].

    (aClass includesBehavior:CharacterArray) ifTrue:[

        ^ 'abcdefghijklmnopqrstuvwxyz' as: aClass         

    ].

    (aClass includesBehavior:AbstractNumberVector) ifTrue:[   

        (aClass includesBehavior:UnboxedIntegerArray) ifTrue:[   

            ^ #(1 2 3 4 5 6 7 8 9 10) as: aClass         

        ].

        ^ #(1.0 2 3.0 4 5.0 6 7.0 8 9.0 10) as: aClass         

    ].

    ^ #(1 true 2.0 false 3 nil 4.0 5 6.0 7 8.0 9 10.0) as: aClass         

    "

     self basicNew testSequentialCollectionOperations

    "

    "Created: / 08-05-2012 / 10:50:50 / cg"

!

testDictionaryLikeAddRemoveOperations

    |classes|

    classes := OrderedCollection new.

    classes 

        add:Dictionary;

        add:IdentityDictionary;

        add:OrderedDictionary;

        add:BTree.

    classes do:[:eachClass |

        self doTestDictionaryLikeAddRemoveOperationsIn:eachClass

    ].

    "

     self basicNew testDictionaryLikeAddRemoveOperations

    "

    "Created: / 08-08-2011 / 15:59:52 / cg"

!

testGeneralAddRemoveOperations

    |classes|

    classes := OrderedCollection new.

    classes 

        "/ add:RunArray;

        add:Bag;

        add:Set;

        add:IdentitySet;

        "/add:Dictionary;

        "/add:IdentityDictionary;

        add:OrderedCollection;

        add:SortedCollection;

        "/add:Queue;

        "/add:Stack;

        add:SortedCollection;

        "/add:OrderedDictionary;

        add:OrderedSet.

        "/add:BTree.

    classes do:[:eachClass |

        self doTestGeneralAddRemoveOperationsIn:eachClass

    ].

    "

     self basicNew testGeneralAddRemoveOperations

    "

    "Created: / 08-08-2011 / 15:59:02 / cg"

!

testGeneralOperations

    |classes|

    classes := OrderedCollection new.

    classes 

        add:RunArray;

        add:Bag;

        add:Set;

        add:IdentitySet;

        add:Dictionary;

        add:IdentityDictionary;

        add:OrderedCollection;

        add:SortedCollection;

        add:Queue;

        add:Stack;

        add:SortedCollection;

        add:OrderedDictionary;

        add:OrderedSet;

        add:BTree.

    classes do:[:eachClass |

        self doTestGeneralCollectionOperationsIn:eachClass

    ].

    "

     self basicNew testGeneralOperations

    "

    "Modified: / 08-08-2011 / 15:53:16 / cg"

!

testSequentialCollectionOperations

    |classes|

    classes := OrderedCollection new.

    classes 

        add:OrderedCollection;

        add:Array;

        add:String;

        add:ByteArray;

        add:WordArray;

        add:IntegerArray;

        add:LongIntegerArray;

        add:SignedWordArray;

        add:SignedIntegerArray;

        add:SignedLongIntegerArray;

        add:FloatArray;

        add:DoubleArray;

        add:HalfFloatArray;

        add:TwoByteString;

        add:Unicode16String;

        add:Unicode32String;

        add:BooleanArray;

        add:BitArray.

    classes do:[:eachClass |

        self doTestSequentialCollectionOperationsIn:eachClass

    ].

    "

     self basicNew testSequentialCollectionOperations

    "

    "Created: / 08-05-2012 / 10:48:40 / cg"

!

testSpecialArrayClasses

    |a|

    a := #(1 2 3 4 5) asWordArray.

    self assert:(a at:1) == 1.

    self assert:(a at:a size) == 5.

    self assert:(a first) == 1.

    self assert:(a last) == 5.

    a := #(1 2 3 4 5) asIntegerArray.

    self assert:(a at:1) == 1.

    self assert:(a at:a size) == 5.

    self assert:(a first) == 1.

    self assert:(a last) == 5.

    a := #(1 2 3 4 5) asLongIntegerArray.

    self assert:(a at:1) == 1.

    self assert:(a at:a size) == 5.

    self assert:(a first) == 1.

    self assert:(a last) == 5.

    "

     self basicNew testSpecialArrayClasses

    "

    "Created: / 08-05-2012 / 10:48:40 / cg"

! !

!CollectionTests methodsFor:'tests-interval'!

testInterval01

    |i1 i2 enumeratedValues|

    i1 := 1 to:10.

    self assert: ( i1 size == 10 ).

    self assert: ( i1 includes:1 ).

    self assert: ( i1 includes:10 ).

    self assert: ( i1 min == 1 ).

    self assert: ( i1 max == 10 ).

    "cannot add/remove"

    self should:[i1 add:99] raise:Error.

    self should:[i1 remove:10] raise:Error.

    i2 := 2 to:20 by:2.

    self assert: ( i2 size == 10 ).

    self assert: ( i2 includes:0 ) not.