"

 COPYRIGHT (c) Claus Gittinger / eXept Software AG

 COPYRIGHT (c) 2016-2017 Jan Vrany

              All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

"{ Package: 'stx:goodies/regression' }"

"{ NameSpace: RegressionTests }"

TestCase subclass:#CollectionTests

	instanceVariableNames:'empty nonEmpty'

	classVariableNames:''

	poolDictionaries:''

	category:'tests-Regression-Collections'

!

Object subclass:#SortTestData

	instanceVariableNames:'value order'

	classVariableNames:''

	poolDictionaries:''

	privateIn:CollectionTests

!

!CollectionTests class methodsFor:'documentation'!

copyright

"

 COPYRIGHT (c) Claus Gittinger / eXept Software AG

 COPYRIGHT (c) 2016-2017 Jan Vrany

              All Rights Reserved

 This software is furnished under a license and may be used

 only in accordance with the terms of that license and with the

 inclusion of the above copyright notice.   This software may not

 be provided or otherwise made available to, or used by, any

 other person.  No title to or ownership of the software is

 hereby transferred.

"

!

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-byteArray'!

testByteArrayReverse

     1 to:1024 do:[:i|

	|bytes test rBytes|

	bytes := ((1 to:i) asArray collect:[:i | i bitAnd:255]) asByteArray.

	test := ((i to:1 by:-1) asArray collect:[:i | i bitAnd:255]) asByteArray.

	rBytes := bytes copy.

	self assert:(rBytes reverse = test).

	rBytes := bytes copy.

	self assert:(rBytes reverse reverse = bytes).

     ].

!

testByteArrayReversed

     1 to:1024 do:[:i|

	|bytes test rBytes|

	bytes := ((1 to:i) asArray collect:[:i | i bitAnd:255]) asByteArray.

	test := ((i to:1 by:-1) asArray collect:[:i | i bitAnd:255]) asByteArray.

	self assert:(bytes reversed = test).

	self assert:(bytes reversed reversed = bytes).

     ].

! !

!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: (coll1 size == coll2 size).

    1 to:coll1 size do:[:i |

	"/ coll1 at:10

	"/ coll2 at:10

	self assert:(coll1 at:i) = (coll2 at:i).

    ].

    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.