KernelTests.ns

Newspeak3
'Root'
class KernelTests usingPlatform: p testFramework: m = (|
private TestContext = m TestContext.
private MessageNotUnderstood = p kernel MessageNotUnderstood.
private Exception = p kernel Exception.
private Stopwatch = p kernel Stopwatch.
private StringBuilder = p kernel StringBuilder.
private List = p collections List.
|) (
public class ArrayTests = TestContext () (
public testArrayAsArray = (
	| array = Array new: 3. |
	assert: array asArray equals: array.
)
public testArrayAt = (
	| array = Array new: 2. empty = Array new: 0. |
	array at: 1 put: 'apple'.
	array at: 2 put: 'banana'.

	assert: (array at: 1) equals: 'apple'.
	assert: (array at: 2) equals: 'banana'.
	should: [array at: 0] signal: Error.
	should: [array at: 3] signal: Error.
	should: [array at: -3] signal: Error.
	should: [array at: nil] signal: Error.

	should: [empty at: 1] signal: Error.
)
public testArrayAtPut = (
	| array = Array new: 2. empty = Array new: 0. |
	assert: (array at: 1 put: 'apple') equals: 'apple'.
	assert: (array at: 2 put: 'banana') equals: 'banana'.
	should: [array at: 0 put: 'orange'] signal: Error.
	should: [array at: 3 put: 'orange'] signal: Error.
	should: [array at: -3 put: 'orange'] signal: Error.
	should: [array at: nil put: 'orange'] signal: Error.

	should: [empty at: 1 put: 'orange'] signal: Error.
)
public testArrayConcatenation = (
	|
	a = Array new: 1.
	b = Array new: 3.
	c
	|
	a at: 1 put: 'apple'.
	b at: 1 put: 'banana'.
	b at: 2 put: 'orange'.
	b at: 3 put: 'strawberry'.
	c:: a, b.

	assert: c isKindOfArray.
	assert: c size equals: 4.
	assert: (c at: 1) equals: 'apple'.
	assert: (c at: 2) equals: 'banana'.
	assert: (c at: 3) equals: 'orange'.
	assert: (c at: 4) equals: 'strawberry'.
)
public testArrayEqualityIsIdentity = (
	|
	empty1 = Array new: 0.
	empty2 = Array new: 0.
	simple1 = Array new: 1.
	simple2 = Array new: 1.
	cycle1 = Array new: 1.
	cycle2 = Array new: 1.
	|
	simple1 at: 1 put: 42.
	simple2 at: 1 put: 42.
	cycle1 at: 1 put: cycle1.
	cycle2 at: 1 put: cycle2.

	assert: empty1 equals: empty1.
	assert: empty2 equals: empty2.
	deny: empty1 equals: empty2.
	deny: empty2 equals: empty1.

	assert: simple1 equals: simple1.
	assert: simple2 equals: simple2.
	deny: simple1 equals: simple2.
	deny: simple2 equals: simple1.

	assert: cycle1 equals: cycle1.
	assert: cycle2 equals: cycle2.
	deny: cycle1 equals: cycle2.
	deny: cycle2 equals: cycle1.
)
public testArrayFirstLast = (
	| array = Array new: 2. empty = Array new: 0. |
	array at: 1 put: 'apple'.
	array at: 2 put: 'banana'.

	assert: (array first) equals: 'apple'.
	assert: (array last) equals: 'banana'.

	should: [empty first] signal: Error.
	should: [empty last] signal: Error.
)
public testArrayFloatIndex = (
	| array = Array new: 1. |
	should: [array at: 1 asFloat] signal: Error.
	should: [array at: 1 asFloat put: 'apple'] signal: Error.
)
public testArrayIndexOf = (
	| array = Array new: 6. empty = Array new: 0. |
	array at: 1 put: 42.
	array at: 2 put: nil.
	array at: 3 put: 'apple'.
	array at: 4 put: 'banana'.
	array at: 5 put: 'apple'.
	array at: 6 put: 'banana'.

	assert: (array indexOf: 42) equals: 1.
	assert: (array indexOf: nil) equals: 2.
	assert: (array indexOf: 'apple') equals: 3.
	assert: (array indexOf: 'banana') equals: 4.
	assert: (array indexOf: 'noSuchElement') equals: 0.

	assert: (empty indexOf: 'noSuchElement') equals: 0.
)
public testArrayIsEmpty = (
	assert: (Array new: 0) isEmpty.
	deny: (Array new: 1) isEmpty.
)
public testArrayNew = (
	assert: (Array new: 0) size equals: 0.
	assert: (Array new: 500) size equals: 500.

	should: [Array new: -1] signal: Error.
	should: [Array new: '10'] signal: Error.
	should: [Array new: nil] signal: Error.
	should: [Array new] signal: MessageNotUnderstood.
)
public testArrayReplace = (
	| array replacement result |
	array:: Array new: 5.
	array at: 1 put: 10.
	array at: 2 put: 20.
	array at: 3 put: 30.
	array at: 4 put: 40.
	array at: 5 put: 50.

	replacement:: Array new: 3.
	replacement at: 1 put: 110.
	replacement at: 2 put: 120.
	replacement at: 3 put: 130.

	(* Empty. *)
	result:: array replaceFrom: 3 to: 2 with: replacement startingAt: 2.
	assert: result equals: array.
	assert: (array at: 1) equals: 10.
	assert: (array at: 2) equals: 20.
	assert: (array at: 3) equals: 30.
	assert: (array at: 4) equals: 40.
	assert: (array at: 5) equals: 50.

	(* One. *)
	result:: array replaceFrom: 3 to: 3 with: replacement startingAt: 1.
	assert: result equals: array.
	assert: (array at: 1) equals: 10.
	assert: (array at: 2) equals: 20.
	assert: (array at: 3) equals: 110.
	assert: (array at: 4) equals: 40.
	assert: (array at: 5) equals: 50.

	(* Two. *)
	result:: array replaceFrom: 3 to: 4 with: replacement startingAt: 2.
	assert: result equals: array.
	assert: (array at: 1) equals: 10.
	assert: (array at: 2) equals: 20.
	assert: (array at: 3) equals: 120.
	assert: (array at: 4) equals: 130.
	assert: (array at: 5) equals: 50.

	(* Three. *)
	result:: array replaceFrom: 1 to: 3 with: replacement startingAt: 1.
	assert: result equals: array.
	assert: (array at: 1) equals: 110.
	assert: (array at: 2) equals: 120.
	assert: (array at: 3) equals: 130.
	assert: (array at: 4) equals: 130.
	assert: (array at: 5) equals: 50.

	(* After end source *)
	should: [array replaceFrom: 1 to: 3 with: replacement startingAt: 6] signal: Error.
	(* Crossing end source *)
	should: [array replaceFrom: 1 to: 3 with: replacement startingAt: 3] signal: Error.
	(* Before beginning source *)
	should: [array replaceFrom: 1 to: 3 with: replacement startingAt: -3] signal: Error.
	(* Crossing begining source *)
	should: [array replaceFrom: 1 to: 3 with: replacement startingAt: 0] signal: Error.

	(* After end destination *)
	should: [array replaceFrom: 6 to: 6 with: replacement startingAt: 1] signal: Error.
	(* Crossing end destination *)
	should: [array replaceFrom: 5 to: 6 with: replacement startingAt: 1] signal: Error.
	(* Before beginning destination *)
	should: [array replaceFrom: 0 to: 0 with: replacement startingAt: 1] signal: Error.
	(* Crossing begining destination *)
	should: [array replaceFrom: 0 to: 2 with: replacement startingAt: 1] signal: Error.

	should: [array replaceFrom: nil to: 3 with: replacement startingAt: 1] signal: Error.
	should: [array replaceFrom: 3 to: nil with: replacement startingAt: 1] signal: Error.
	should: [array replaceFrom: 3 to: 3 with: nil startingAt: 1] signal: Error.
	should: [array replaceFrom: 3 to: 3 with: replacement startingAt: nil] signal: Error.
)
public testArrayReplaceSlideDown = (
	| array result |
	array:: Array new: 7.
	array at: 1 put: 10.
	array at: 2 put: 20.
	array at: 3 put: 30.
	array at: 4 put: 40.
	array at: 5 put: 50.
	array at: 6 put: 60.
	array at: 7 put: 70.

	result:: array replaceFrom: 3 to: 7 with: array startingAt: 1.
	assert: result equals: array.
	assert: (array at: 1) equals: 10.
	assert: (array at: 2) equals: 20.
	assert: (array at: 3) equals: 10.
	assert: (array at: 4) equals: 20.
	assert: (array at: 5) equals: 30.
	assert: (array at: 6) equals: 40.
	assert: (array at: 7) equals: 50.
)
public testArrayReplaceSlideUp = (
	| array result |
	array:: Array new: 7.
	array at: 1 put: 10.
	array at: 2 put: 20.
	array at: 3 put: 30.
	array at: 4 put: 40.
	array at: 5 put: 50.
	array at: 6 put: 60.
	array at: 7 put: 70.

	result:: array replaceFrom: 1 to: 5 with: array startingAt: 3.
	assert: result equals: array.
	assert: (array at: 1) equals: 30.
	assert: (array at: 2) equals: 40.
	assert: (array at: 3) equals: 50.
	assert: (array at: 4) equals: 60.
	assert: (array at: 5) equals: 70.
	assert: (array at: 6) equals: 60.
	assert: (array at: 7) equals: 70.
)
public testArraySort = (
	| array |
	array:: {12. 15. 3. 5. 10. 6. 8. 1. 13. 11. 16. 4. 14. 9. 2. 7}.
	assert: array size equals: 16.
	array sort: [:a :b | a < b].
	1 to: 16 do: [:index | assert: (array at: index) equals: index].

	array:: {12. 8. 9. 7. 2. 10. 4. 6. 5. 3. 13. 15. 14. 1. 11}.
	assert: array size equals: 15.
	array sort: [:a :b | a < b].
	1 to: 15 do: [:index | assert: (array at: index) equals: index].

	array:: {10. 12. 2. 11. 14. 4. 13. 3. 9. 8. 7. 5. 6. 1}.
	assert: array size equals: 14.
	array sort: [:a :b | a < b].
	1 to: 14 do: [:index | assert: (array at: index) equals: index].

	array:: {12. 6. 10. 5. 7. 9. 2. 4. 1. 11. 3. 8. 13}.
	assert: array size equals: 13.
	array sort: [:a :b | a < b].
	1 to: 13 do: [:index | assert: (array at: index) equals: index].
)
public testArrayWithAll = (
	| array bytearray list result |
	array:: Array new: 2.
	array at: 1 put: 'A'.
	array at: 2 put: 'B'.
	result:: Array withAll: array.
	assert: result size equals: 2.
	assert: (result at: 1) equals: 'A'.
	assert: (result at: 2) equals: 'B'.

	bytearray:: ByteArray new: 2.
	bytearray at: 1 put: 67.
	bytearray at: 2 put: 68.
	result:: Array withAll: bytearray.
	assert: result size equals: 2.
	assert: (result at: 1) equals: 67.
	assert: (result at: 2) equals: 68.

	result:: Array withAll: 'EF'.
	assert: result size equals: 2.
	assert: (result at: 1) equals: 69.
	assert: (result at: 2) equals: 70.

	list:: List new.
	list add: 'G'.
	list add: 'H'.
	result:: Array withAll: list.
	assert: result size equals: 2.
	assert: (result at: 1) equals: 'G'.
	assert: (result at: 2) equals: 'H'.

	should: [Array withAll: -1] signal: Error.
	should: [Array withAll: 16r110000] signal: Error.
	should: [Array withAll: nil] signal: Error.
	should: [Array withAll: 122 asFloat] signal: Error.
)
public testIsKindOfArray = (
	assert: (Array new: 0) isKindOfArray.
	deny: (ByteArray new: 0) isKindOfArray.
	deny: 0 isKindOfArray.
	deny: 1.5 isKindOfArray.
	deny: 'Array new' isKindOfArray.
	deny: nil isKindOfArray.
)
public testArrayCopyFromTo = (
	| array copy1 copy2  copy3|
	array:: Array new: 7.
	array at: 1 put: 10.
	array at: 2 put: 20.
	array at: 3 put: 30.
	array at: 4 put: 40.
	array at: 5 put: 50.
	array at: 6 put: 60.
	array at: 7 put: 70.
    copy1:: array copyFrom: 2 to: 5.
    assert: copy1 size equals: 4.
	assert: (copy1 at: 1) equals: 20.
	assert: (copy1 at: 2) equals: 30.
	assert: (copy1 at: 3) equals: 40.
	assert: (copy1 at: 4) equals: 50.
    copy2:: array copyFrom: 7 to: 6.
    assert: [copy2 isEmpty].
    copy3:: array copyFrom: 7 to: 7. 
    assert: copy3 size equals: 1.
	assert: (copy3 at: 1) equals: 70.    
	should: [array copyFrom: 0 to: 5] signal: Error.
    should: [array copyFrom: 2 to: 8] signal: Error.
    should: [array copyFrom: 0 to: 8] signal: Error.
    should: [array copyFrom: 8 to: 5] signal: Error.
    should: [array copyFrom: 7 to: 0] signal: Error.
)
) : (
TEST_CONTEXT = ()
)
public class BehaviorTests = TestContext () (
class Module superclass: s = (
|
	Superclass = s.
|
) (
public class Subclass = Superclass (
) (
) : (
)
) : (
)
public testBehaviorBasicNew = (
	should: [Object basicNew] signal: MessageNotUnderstood.

	(* :todo: basicNew should also fail from a class-side method. *)
)
public testBehaviorInternalsAreHidden = (
	(* Squeak, JS *)
	should: [Object superclass] signal: MessageNotUnderstood.
	should: [Object methodDictionary] signal: MessageNotUnderstood.
	should: [Object mixin] signal: MessageNotUnderstood.
	should: [Object enclosingObject] signal: MessageNotUnderstood.
	should: [Object format] signal: MessageNotUnderstood.

	(* PrimordialSoup *)
	should: [Object _superclass] signal: MessageNotUnderstood.
	should: [Object _methods] signal: MessageNotUnderstood.
	should: [Object _enclosingObject] signal: MessageNotUnderstood.
	should: [Object _mixin] signal: MessageNotUnderstood.
	should: [Object _classIndex] signal: MessageNotUnderstood.
	should: [Object _format] signal: MessageNotUnderstood.
)
public testBehaviorName = (
	(* :todo: Which to we want? *)
	(* should: [Object name] signal: MessageNotUnderstood.
	assert: Object name equals: 'Object'.
	assert: Object name equals: 'KernelForImplementation`Object'. *)
)
public testClassCannotSubclassArray = (
	| module |
	module:: Module superclass: Array.
	should: [module Subclass] signal: Exception.
)
public testClassCannotSubclassByteArray = (
	| module |
	module:: Module superclass: ByteArray.
	should: [module Subclass] signal: Exception.
)
public testClassCannotSubclassMetaclass = (
	| module |
	module:: Module superclass: self class class.
	should: [module Subclass] signal: Exception.
)
public testClassCannotSubclassNil = (
	| module |
	module:: Module superclass: nil.
	should: [module Subclass] signal: Exception.
)
public testClassCannotSubclassString = (
	| module |
	module:: Module superclass: String.
	should: [module Subclass] signal: Exception.
)
public testIsKindOfBehavior = (
	assert: Object isKindOfBehavior.
	deny: nil isKindOfBehavior.
	deny: false isKindOfBehavior.
	deny: true isKindOfBehavior.
	deny: 0 isKindOfBehavior.
)
) : (
TEST_CONTEXT = ()
public class = (
	^super class
)
)
public class BooleanTests = TestContext () (
public testBooleanAsString = (
	assert: true asString equals: 'true'.
	assert: false asString equals: 'false'.
)
public testBooleanEvaluatingConjuction = (
	assert: true & true.
	deny: true & false.
	deny: false & true.
	deny: false & false.
)
public testBooleanEvaluatingDisjuction = (
	assert: true | true.
	assert: true | false.
	assert: false | true.
	deny: false | false.
)
public testBooleanNonEvaluatingConjuction = (
	assert: (true and: [true]).
	deny: (true and: [false]).
	deny: (false and: [doesNotExecute]).
)
public testBooleanNonEvaluatingDisjuction = (
	assert: (true or: [doesNotExecute]).
	assert: (false or: [true]).
	deny: (false or: [false]).
)
public testBooleanNot = (
	deny: true not.
	assert: false not.
)
public testBooleanPrintString = (
	assert: true printString equals: 'true'.
	assert: false printString equals: 'false'.
)
) : (
TEST_CONTEXT = ()
)
public class ByteArrayTests = TestContext () (
b: string = (
	^ByteArray withAll: string
)
public testByteArrayAt = (
	| array = ByteArray new: 2. empty = ByteArray new: 0. |
	array at: 1 put: 3.
	array at: 2 put: 4.

	assert: (array at: 1) equals: 3.
	assert: (array at: 2) equals: 4.
	should: [array at: 0] signal: Error.
	should: [array at: 3] signal: Error.
	should: [array at: -3] signal: Error.
	should: [array at: nil] signal: Error.

	should: [empty at: 1] signal: Error.
)
public testByteArrayAtPut = (
	| array = ByteArray new: 2. empty = ByteArray new: 0. |
	assert: (array at: 1 put: 3) equals: 3.
	assert: (array at: 2 put: 4) equals: 4.
	should: [array at: 0 put: 5] signal: Error.
	should: [array at: 3 put: 6] signal: Error.
	should: [array at: -3 put: 7] signal: Error.
	should: [array at: nil put: 8] signal: Error.

	assert: (array at: 1 put: 0) equals: 0.
	assert: (array at: 2 put: 255) equals: 255.
	should: [array at: 1 put: -1] signal: Error.
	should: [array at: 1 put: 256] signal: Error.

	should: [empty at: 1 put: 9] signal: Error.
)
public testByteArrayCopyByteArrayFromTo = (
	| array = ByteArray new: 4. empty = ByteArray new: 0. copy |
	array at: 1 put: 16rA.
	array at: 2 put: 16rB.
	array at: 3 put: 16rC.
	array at: 4 put: 16rD.

	copy:: array copyByteArrayFrom: 1 to: 4.
	assert: copy size equals: 4.
	assert: (copy at: 1) equals: 16rA.
	assert: (copy at: 4) equals: 16rD.

	copy:: array copyByteArrayFrom: 2 to: 3.
	assert: copy size equals: 2.
	assert: (copy at: 1) equals: 16rB.
	assert: (copy at: 2) equals: 16rC.

	1 to: 4 do:
		[:start |
		 copy:: array copyByteArrayFrom: start to: start - 1.
		 assert: copy size equals: 0].

	copy:: empty copyByteArrayFrom: 1 to: 0.
	assert: copy size equals: 0.

	should: [empty copyByteArrayFrom: 0 to: 0] signal: Error.
	should: [empty copyByteArrayFrom: 2 to: 0] signal: Error.
	should: [empty copyByteArrayFrom: 1 to: 1] signal: Error.

	should: [array copyByteArrayFrom: 4 to: 5] signal: Error.
	should: [array copyByteArrayFrom: nil to: 2] signal: Error.
	should: [array copyByteArrayFrom: 2 to: nil] signal: Error.
	should: [array copyByteArrayFrom: 2 to: 50] signal: Error.
	should: [array copyByteArrayFrom: 0 to: 2] signal: Error.
	should: [array copyByteArrayFrom: 2 asFloat to: 3] signal: Error.
	should: [array copyByteArrayFrom: 2 to: 3 asFloat] signal: Error.
)
public testByteArrayCopyFromTo = (
	| array = ByteArray new: 4. empty = ByteArray new: 0. copy |
	array at: 1 put: 16rA.
	array at: 2 put: 16rB.
	array at: 3 put: 16rC.
	array at: 4 put: 16rD.

	copy:: array copyFrom: 1 to: 4.
	assert: copy size equals: 4.
	assert: (copy at: 1) equals: 16rA.
	assert: (copy at: 4) equals: 16rD.

	copy:: array copyFrom: 2 to: 3.
	assert: copy size equals: 2.
	assert: (copy at: 1) equals: 16rB.
	assert: (copy at: 2) equals: 16rC.

	1 to: 4 do:
		[:start |
		 copy:: array copyFrom: start to: start - 1.
		 assert: copy size equals: 0].

	copy:: empty copyFrom: 1 to: 0.
	assert: copy size equals: 0.

	should: [empty copyFrom: 0 to: 0] signal: Error.
	should: [empty copyFrom: 2 to: 0] signal: Error.
	should: [empty copyFrom: 1 to: 1] signal: Error.

	should: [array copyFrom: 4 to: 5] signal: Error.
	should: [array copyFrom: nil to: 2] signal: Error.
	should: [array copyFrom: 2 to: nil] signal: Error.
	should: [array copyFrom: 2 to: 50] signal: Error.
	should: [array copyFrom: 0 to: 2] signal: Error.
	should: [array copyFrom: 2 asFloat to: 3] signal: Error.
	should: [array copyFrom: 2 to: 3 asFloat] signal: Error.
)
public testByteArrayCopyStringFromTo = (
	| array = ByteArray new: 4. empty = ByteArray new: 0. copy |
	array at: 1 put: 65.
	array at: 2 put: 66.
	array at: 3 put: 67.
	array at: 4 put: 68.

	copy:: array copyStringFrom: 1 to: 4.
	assert: copy equals: 'ABCD'.

	copy:: array copyStringFrom: 2 to: 3.
	assert: copy equals: 'BC'.

	1 to: 4 do:
		[:start |
		 copy:: array copyStringFrom: start to: start - 1.
		 assert: copy equals: ''].

	copy:: empty copyStringFrom: 1 to: 0.
	assert: copy equals: ''.

	should: [empty copyStringFrom: 0 to: 0] signal: Error.
	should: [empty copyStringFrom: 2 to: 0] signal: Error.
	should: [empty copyStringFrom: 1 to: 1] signal: Error.

	should: [array copyStringFrom: 4 to: 5] signal: Error.
	should: [array copyStringFrom: nil to: 2] signal: Error.
	should: [array copyStringFrom: 2 to: nil] signal: Error.
	should: [array copyStringFrom: 2 to: 50] signal: Error.
	should: [array copyStringFrom: 0 to: 2] signal: Error.
	should: [array copyStringFrom: 2 asFloat to: 3] signal: Error.
	should: [array copyStringFrom: 2 to: 3 asFloat] signal: Error.
)
public testByteArrayEndsWith = (
	| foo zero empty |
	foo:: ByteArray new: 3.
	foo at: 1 put: 102.
	foo at: 2 put: 111.
	foo at: 3 put: 111.
	zero:: ByteArray new: 1.
	zero at: 1 put: 48.
	empty:: ByteArray new: 0.

	assert: (foo endsWith: 'o').
	assert: (foo endsWith: 'foo').
	assert: (foo endsWith: foo).
	assert: (foo endsWith: '').
	assert: (foo endsWith: empty).
	assert: (empty endsWith: '').
	assert: (foo endsWith: empty).
	deny: (foo endsWith: 'toolongfoo').
	deny: (foo endsWith: 'boo').
	deny: (foo endsWith: 'bar').
	deny: (empty endsWith: 'foo').
	deny: (empty endsWith: foo).

	should: [zero endsWith: 0] signal: Error.
	should: [foo endsWith: true] signal: Error.
	should: [foo endsWith: nil] signal: Error.
)
public testByteArrayFloatIndex = (
	| array = ByteArray new: 1. |
	should: [array at: 1 asFloat] signal: Error.
	should: [array at: 1 asFloat put: 0] signal: Error.
)
public testByteArrayIndexOf = (
	assert: ((b: 'fofofobar') indexOf: (b: 'fofo')) equals: 1.
	assert: ((b: 'fofofobar') indexOf: (b: 'bar')) equals: 7.
	assert: ((b: 'fofofobar') indexOf: (b: 'barr')) equals: 0.
	assert: ((b: 'fofofobar') indexOf: (b: 'fob')) equals: 5.
	assert: ((b: 'fofofobar') indexOf: (b: 'baz')) equals: 0.
	assert: ((b: 'fofofobar') indexOf: (b: 'f')) equals: 1.
	assert: ((b: 'fofofobar') indexOf: (b: 'r')) equals: 9.
	assert: ((b: 'fofofobar') indexOf: (b: '')) equals: 1.

	assert: ((b: 'tiny') indexOf: (b: 'toolong')) equals: 0.

	assert: ((b: '') indexOf: (b: '')) equals: 1.
	assert: ((b: '') indexOf: (b: 'baz')) equals: 0.

	should: [(b: 'fofofobar') indexOf: 0] signal: Error.
	should: [(b: '') indexOf: Object new] signal: Error.
)
public testByteArrayIndexOfStartingAt = (
	assert: ((b: 'fofofobar') indexOf: (b: 'fofo') startingAt: 1) equals: 1.
	assert: ((b: 'fofofobar') indexOf: (b: 'fofo') startingAt: 2) equals: 3.
	assert: ((b: 'fofofobar') indexOf: (b: 'fofo') startingAt: 3) equals: 3.
	assert: ((b: 'fofofobar') indexOf: (b: 'fofo') startingAt: 4) equals: 0.
	assert: ((b: 'fofofobar') indexOf: (b: 'bar') startingAt: 1) equals: 7.
	assert: ((b: 'fofofobar') indexOf: (b: 'bar') startingAt: 7) equals: 7.
	assert: ((b: 'fofofobar') indexOf: (b: 'bar') startingAt: 8) equals: 0.
	assert: ((b: 'fofofobar') indexOf: (b: 'barr') startingAt: 6) equals: 0.
	assert: ((b: 'fofofobar') indexOf: (b: 'fob') startingAt: 5) equals: 5.
	assert: ((b: 'fofofobar') indexOf: (b: 'fob') startingAt: 6) equals: 0.
	assert: ((b: 'fofofobar') indexOf: (b: 'baz') startingAt: 1) equals: 0.
	assert: ((b: 'fofofobar') indexOf: (b: 'f') startingAt: 1) equals: 1.
	assert: ((b: 'fofofobar') indexOf: (b: 'f') startingAt: 2) equals: 3.
	assert: ((b: 'fofofobar') indexOf: (b: 'r') startingAt: 1) equals: 9.
	assert: ((b: 'fofofobar') indexOf: (b: 'r') startingAt: 9) equals: 9.
	assert: ((b: 'fofofobar') indexOf: (b: '') startingAt: 1) equals: 1.
	assert: ((b: 'fofofobar') indexOf: (b: '') startingAt: 5) equals: 5.
	assert: ((b: 'fofofobar') indexOf: (b: '') startingAt: 9) equals: 9.

	assert: ((b: 'tiny') indexOf: (b: 'toolong') startingAt: 1) equals: 0.
	assert: ((b: 'tiny') indexOf: (b: 'toolong') startingAt: 3) equals: 0.

	assert: ((b: '') indexOf: (b: '') startingAt: 1) equals: 1.
	assert: ((b: '') indexOf: (b: 'baz') startingAt: 1) equals: 0.

	should: [(b: 'fofofobar') indexOf: 0 startingAt: 1] signal: Error.
	should: [(b: 'fofobobar') indexOf: Object new startingAt: 1] signal: Error.

	should: [(b: 'fofofobar') indexOf: (b: 'foo') startingAt: 0] signal: Error.
	should: [(b: 'fofofobar') indexOf: (b: 'foo') startingAt: 11] signal: Error.
	should: [(b: '') indexOf: (b: '') startingAt: 0] signal: Error.
	should: [(b: '') indexOf: (b: '') startingAt: 2] signal: Error.
)
public testByteArrayIsEmpty = (
	assert: (ByteArray new: 0) isEmpty.
	deny: (ByteArray new: 1) isEmpty.
)
public testByteArrayLargeAllocation = (
	| size = 8 * 1024 * 1024. |
	assert: (ByteArray new: size) size equals: size.
	assert: (ByteArray new: size) size equals: size.
	assert: (ByteArray new: size) size equals: size.
)
public testByteArrayLastIndexOf = (
	assert: ((b: 'fofofobar') lastIndexOf: (b: 'fofo')) equals: 3.
	assert: ((b: 'fofofobar') lastIndexOf: (b: 'bar')) equals: 7.
	assert: ((b: 'fofofobar') lastIndexOf: (b: 'barr')) equals: 0.
	assert: ((b: 'fofofobar') lastIndexOf: (b: 'fob')) equals: 5.
	assert: ((b: 'fofofobar') lastIndexOf: (b: 'baz')) equals: 0.
	assert: ((b: 'fofofobar') lastIndexOf: (b: 'f')) equals: 5.
	assert: ((b: 'fofofobar') lastIndexOf: (b: 'r')) equals: 9.
	assert: ((b: 'fofofobar') lastIndexOf: (b: '')) equals: 10.

	assert: ((b: 'tiny') lastIndexOf: (b: 'toolong')) equals: 0.

	assert: ((b: '') lastIndexOf: (b: '')) equals: 1.
	assert: ((b: '') lastIndexOf: (b: 'baz')) equals: 0.

	should: [(b: 'fofofobar') lastIndexOf: 0] signal: Error.
	should: [(b: '') lastIndexOf: Object new] signal: Error.
)
public testByteArrayLastIndexOfStartingAt = (
	assert: ((b: 'fofofobar') lastIndexOf: (b: 'fofo') startingAt: 10) equals: 3.
	assert: ((b: 'fofofobar') lastIndexOf: (b: 'fofo') startingAt: 4) equals: 3.
	assert: ((b: 'fofofobar') lastIndexOf: (b: 'fofo') startingAt: 3) equals: 3.
	assert: ((b: 'fofofobar') lastIndexOf: (b: 'fofo') startingAt: 1) equals: 1.
	assert: ((b: 'fofofobar') lastIndexOf: (b: 'bar') startingAt: 10) equals: 7.
	assert: ((b: 'fofofobar') lastIndexOf: (b: 'bar') startingAt: 7) equals: 7.
	assert: ((b: 'fofofobar') lastIndexOf: (b: 'bar') startingAt: 6) equals: 0.
	assert: ((b: 'fofofobar') lastIndexOf: (b: 'barr') startingAt: 10) equals: 0.
	assert: ((b: 'fofofobar') lastIndexOf: (b: 'fob') startingAt: 10) equals: 5.
	assert: ((b: 'fofofobar') lastIndexOf: (b: 'fob') startingAt: 4) equals: 0.
	assert: ((b: 'fofofobar') lastIndexOf: (b: 'baz') startingAt: 10) equals: 0.
	assert: ((b: 'fofofobar') lastIndexOf: (b: 'f') startingAt: 10) equals: 5.
	assert: ((b: 'fofofobar') lastIndexOf: (b: 'f') startingAt: 4) equals: 3.
	assert: ((b: 'fofofobar') lastIndexOf: (b: 'f') startingAt: 2) equals: 1.
	assert: ((b: 'fofofobar') lastIndexOf: (b: 'r') startingAt: 10) equals: 9.
	assert: ((b: 'fofofobar') lastIndexOf: (b: 'r') startingAt: 9) equals: 9.
	assert: ((b: 'fofofobar') lastIndexOf: (b: 'r') startingAt: 8) equals: 0.
	assert: ((b: 'fofofobar') lastIndexOf: (b: '') startingAt: 10) equals: 10.
	assert: ((b: 'fofofobar') lastIndexOf: (b: '') startingAt: 5) equals: 5.
	assert: ((b: 'fofofobar') lastIndexOf: (b: '') startingAt: 1) equals: 1.

	assert: ((b: 'tiny') lastIndexOf: (b: 'toolong') startingAt: 4) equals: 0.
	assert: ((b: 'tiny') lastIndexOf: (b: 'toolong') startingAt: 2) equals: 0.

	assert: ((b: '') lastIndexOf: (b: '') startingAt: 1) equals: 1.
	assert: ((b: '') lastIndexOf: (b: 'baz') startingAt: 1) equals: 0.

	should: [(b: 'fofofobar') lastIndexOf: 0 startingAt: 1] signal: Error.
	should: [(b: '') lastIndexOf: Object new startingAt: 1] signal: Error.

	should: [(b: 'fofofobar') lastIndexOf: (b: 'foo') startingAt: 0] signal: Error.
	should: [(b: 'fofofobar') lastIndexOf: (b: 'foo') startingAt: 11] signal: Error.
	should: [(b: '') lastIndexOf: (b: '') startingAt: 0] signal: Error.
	should: [(b: '') lastIndexOf: (b: '') startingAt: 2] signal: Error.
)
public testByteArrayNew = (
	assert: (ByteArray new: 0) size equals: 0.
	assert: (ByteArray new: 500) size equals: 500.

	should: [ByteArray new: -1] signal: Error.
	should: [ByteArray new: '10'] signal: Error.
	should: [ByteArray new: nil] signal: Error.
	should: [ByteArray new] signal: MessageNotUnderstood.
)
public testByteArrayReplace = (
	| array replacement result |
	array:: ByteArray new: 5.
	array at: 1 put: 10.
	array at: 2 put: 20.
	array at: 3 put: 30.
	array at: 4 put: 40.
	array at: 5 put: 50.

	replacement:: ByteArray new: 3.
	replacement at: 1 put: 110.
	replacement at: 2 put: 120.
	replacement at: 3 put: 130.

	(* Empty. *)
	result:: array replaceFrom: 3 to: 2 with: replacement startingAt: 2.
	assert: result equals: array.
	assert: (array at: 1) equals: 10.
	assert: (array at: 2) equals: 20.
	assert: (array at: 3) equals: 30.
	assert: (array at: 4) equals: 40.
	assert: (array at: 5) equals: 50.

	(* One. *)
	result:: array replaceFrom: 3 to: 3 with: replacement startingAt: 1.
	assert: result equals: array.
	assert: (array at: 1) equals: 10.
	assert: (array at: 2) equals: 20.
	assert: (array at: 3) equals: 110.
	assert: (array at: 4) equals: 40.
	assert: (array at: 5) equals: 50.

	(* Two. *)
	result:: array replaceFrom: 3 to: 4 with: replacement startingAt: 2.
	assert: result equals: array.
	assert: (array at: 1) equals: 10.
	assert: (array at: 2) equals: 20.
	assert: (array at: 3) equals: 120.
	assert: (array at: 4) equals: 130.
	assert: (array at: 5) equals: 50.

	(* Three. *)
	result:: array replaceFrom: 1 to: 3 with: replacement startingAt: 1.
	assert: result equals: array.
	assert: (array at: 1) equals: 110.
	assert: (array at: 2) equals: 120.
	assert: (array at: 3) equals: 130.
	assert: (array at: 4) equals: 130.
	assert: (array at: 5) equals: 50.

	(* After end source *)
	should: [array replaceFrom: 1 to: 3 with: replacement startingAt: 6] signal: Error.
	(* Crossing end source *)
	should: [array replaceFrom: 1 to: 3 with: replacement startingAt: 3] signal: Error.
	(* Before beginning source *)
	should: [array replaceFrom: 1 to: 3 with: replacement startingAt: -3] signal: Error.
	(* Crossing begining source *)
	should: [array replaceFrom: 1 to: 3 with: replacement startingAt: 0] signal: Error.

	(* After end destination *)
	should: [array replaceFrom: 6 to: 6 with: replacement startingAt: 1] signal: Error.
	(* Crossing end destination *)
	should: [array replaceFrom: 5 to: 6 with: replacement startingAt: 1] signal: Error.
	(* Before beginning destination *)
	should: [array replaceFrom: 0 to: 0 with: replacement startingAt: 1] signal: Error.
	(* Crossing begining destination *)
	should: [array replaceFrom: 0 to: 2 with: replacement startingAt: 1] signal: Error.

	should: [array replaceFrom: nil to: 3 with: replacement startingAt: 1] signal: Error.
	should: [array replaceFrom: 3 to: nil with: replacement startingAt: 1] signal: Error.
	should: [array replaceFrom: 3 to: 3 with: nil startingAt: 1] signal: Error.
	should: [array replaceFrom: 3 to: 3 with: replacement startingAt: nil] signal: Error.
)
public testByteArrayReplaceSlideDown = (
	| array result |
	array:: ByteArray new: 7.
	array at: 1 put: 10.
	array at: 2 put: 20.
	array at: 3 put: 30.
	array at: 4 put: 40.
	array at: 5 put: 50.
	array at: 6 put: 60.
	array at: 7 put: 70.

	result:: array replaceFrom: 3 to: 7 with: array startingAt: 1.
	assert: result equals: array.
	assert: (array at: 1) equals: 10.
	assert: (array at: 2) equals: 20.
	assert: (array at: 3) equals: 10.
	assert: (array at: 4) equals: 20.
	assert: (array at: 5) equals: 30.
	assert: (array at: 6) equals: 40.
	assert: (array at: 7) equals: 50.
)
public testByteArrayReplaceSlideUp = (
	| array result |
	array:: ByteArray new: 7.
	array at: 1 put: 10.
	array at: 2 put: 20.
	array at: 3 put: 30.
	array at: 4 put: 40.
	array at: 5 put: 50.
	array at: 6 put: 60.
	array at: 7 put: 70.

	result:: array replaceFrom: 1 to: 5 with: array startingAt: 3.
	assert: result equals: array.
	assert: (array at: 1) equals: 30.
	assert: (array at: 2) equals: 40.
	assert: (array at: 3) equals: 50.
	assert: (array at: 4) equals: 60.
	assert: (array at: 5) equals: 70.
	assert: (array at: 6) equals: 60.
	assert: (array at: 7) equals: 70.
)
public testByteArrayStartsWith = (
	| foo zero empty |
	foo:: ByteArray new: 3.
	foo at: 1 put: 102.
	foo at: 2 put: 111.
	foo at: 3 put: 111.
	zero:: ByteArray new: 1.
	zero at: 1 put: 48.
	empty:: ByteArray new: 0.

	assert: (foo startsWith: 'f').
	assert: (foo startsWith: 'foo').
	assert: (foo startsWith: foo).
	assert: (foo startsWith: '').
	assert: (foo startsWith: empty).
	assert: (empty startsWith: '').
	assert: (empty startsWith: empty).
	deny: (foo startsWith: 'toolong').
	deny: (foo startsWith: 'fob').
	deny: (foo startsWith: 'bar').
	deny: (empty startsWith: 'foo').
	deny: (empty startsWith: foo).

	should: [zero startsWith: 0] signal: Error.
	should: [foo startsWith: true] signal: Error.
	should: [foo startsWith: nil] signal: Error.
)
public testByteArrayWithAll = (
	| array bytearray list result |
	array:: Array new: 0.
	result:: ByteArray withAll: array.
	assert: result size equals: 0.

	array:: Array new: 3.
	array at: 1 put: 10.
	array at: 2 put: 20.
	array at: 3 put: 30.
	result:: ByteArray withAll: array.
	assert: result size equals: 3.
	assert: (result at: 1) equals: 10.
	assert: (result at: 2) equals: 20.
	assert: (result at: 3) equals: 30.

	bytearray:: ByteArray new: 0.
	result:: ByteArray withAll: bytearray.
	assert: result size equals: 0.

	bytearray:: ByteArray new: 3.
	bytearray at: 1 put: 110.
	bytearray at: 2 put: 120.
	bytearray at: 3 put: 130.
	result:: ByteArray withAll: bytearray.
	assert: result size equals: 3.
	assert: (result at: 1) equals: 110.
	assert: (result at: 2) equals: 120.
	assert: (result at: 3) equals: 130.

	result:: ByteArray withAll: ''.
	assert: result size equals: 0.

	result:: ByteArray withAll: 'soup'.
	assert: result size equals: 4.
	assert: (result at: 1) equals: 115.
	assert: (result at: 2) equals: 111.
	assert: (result at: 3) equals: 117.
	assert: (result at: 4) equals: 112.

	list:: List new.
	list add: 102.
	list add: 111.
	list add: 120.
	result:: ByteArray withAll: list.
	assert: result size equals: 3.
	assert: (result at: 1) equals: 102.
	assert: (result at: 2) equals: 111.
	assert: (result at: 3) equals: 120.

	should: [ByteArray withAll: -1] signal: Error.
	should: [ByteArray withAll: 16r110000] signal: Error.
	should: [ByteArray withAll: nil] signal: Error.
	should: [ByteArray withAll: 122 asFloat] signal: Error.

	should: [ByteArray withAll: {nil}] signal: Error.
	should: [ByteArray withAll: {-1}] signal: Error.
	should: [ByteArray withAll: {16r256}] signal: Error.
	should: [ByteArray withAll: {nil}] signal: Error.
	should: [ByteArray withAll: {122 asFloat}] signal: Error.
	should: [ByteArray withAll: {'z'}] signal: Error.

	list:: List new.
	list add: 256.
	should: [String withAll: list] signal: Error.
)
public testIsKindOfByteArray = (
	assert: (ByteArray new: 0) isKindOfByteArray.
	deny: (Array new: 0) isKindOfByteArray.
	deny: 0 isKindOfByteArray.
	deny: 1.5 isKindOfByteArray.
	deny: 'Array new' isKindOfByteArray.
	deny: nil isKindOfByteArray.
)
) : (
TEST_CONTEXT = ()
)
public class ClosureTests = TestContext () (
cannotReturn = (
	^[^42]
)
ensure1 = (
	[^'try-block'] ensure: [^'ensure-block'].
	^'afterward'
)
ensure2 = (
	^['try-block'] ensure: ['ensure-block'].
)
ensure3 = (
	[^'try-block'] ensure: ['ensure-block'].
	^'afterward'
)
public testCannotReturn = (
	should: [cannotReturn value] signal: Error.
)
public testCull = (
	assert: ([42] cull: 7) equals: 42.
	assert: ([42] cull: 7 cull: 9) equals: 42.
	assert: ([42] cull: 7 cull: 9 cull: 11) equals: 42.

	assert: ([:a | a] cull: 7) equals: 7.
	assert: ([:a | a] cull: 7 cull: 9) equals: 7.
	assert: ([:a | a] cull: 7 cull: 9 cull: 11) equals: 7.

	should: [[:a :b | a + b] cull: 7] signal: Error.
	assert: ([:a :b | a + b] cull: 7 cull: 9) equals: 16.
	assert: ([:a :b | a + b] cull: 7 cull: 9 cull: 11) equals: 16.

	should: [[:a :b :c | a + b + c] cull: 7] signal: Error.
	should: [[:a :b :c | a + b + c] cull: 7 cull: 9] signal: Error.
	assert: ([:a :b :c | a + b + c] cull: 7 cull: 9 cull: 11) equals: 27.
)
public testEnsure = (
	assert: ensure1 equals: 'ensure-block'.
	assert: ensure2 equals: 'try-block'.
	assert: ensure3 equals: 'try-block'.
)
public testIsKindOfClosure = (
	assert: [3 + 4] isKindOfClosure.
	deny: (3 + 4) isKindOfClosure.
	deny: {3 + 4} isKindOfClosure.
)
public testNumArgs = (
	assert: [3 + 4] numArgs equals: 0.
	assert: [:x | x + 4] numArgs equals: 1.
	assert: [:x :y | x + y] numArgs equals: 2.
)
public testValue = (
	assert: [3 - 4] value equals: -1.
	assert: ([:x | x - 4] value: 14) equals: 10.
	assert: ([:x :y | x - y] value: 42 value: 24) equals: 18.
	assert: ([:x :y :z | x - y + z] value: 13 value: 3 value: 1) equals: 11.
)
public testValueTooFew = (
	should: [[:x | x - 4] value] signal: Error.
	should: [[:x :y | x - y] value: 1] signal: Error.
	should: [[:x :y :z | 3 - 4] value: 1 value: 2] signal: Error.
)
public testValueTooMany = (
	should: [[3 - 4] value: 1] signal: Error.
	should: [[:x | x - 4] value: 1 value: 2] signal: Error.
	should: [[:x :y | x - y] value: 1 value: 2 value: 3] signal: Error.
)
public testValueWithArguments = (
	(* Should this be called apply: ? *)

	assert: ([3 - 4] valueWithArguments: {}) equals: -1.
	assert: ([:x | x - 4] valueWithArguments: {14}) equals: 10.
	assert: ([:x :y | x - y] valueWithArguments: {42. 24}) equals: 18.
	assert: ([:x :y :z | x - y + z] valueWithArguments: {13. 3. 1}) equals: 11.
)
public testValueWithArgumentsList = (
	assert: ([3 - 4] valueWithArguments: (List withAll: {})) equals: -1.
	assert: ([:x | x - 4] valueWithArguments: (List withAll: {14})) equals: 10.
	assert: ([:x :y | x - y] valueWithArguments: (List withAll: {42. 24})) equals: 18.
	assert: ([:x :y :z | x - y + z] valueWithArguments: (List withAll: {13. 3. 1})) equals: 11.
)
public testValueWithArgumentsNonArray = (
	should: [[1] valueWithArguments: nil] signal: Error.
	should: [[1] valueWithArguments: false] signal: Error.
	should: [[1] valueWithArguments: true] signal: Error.
	should: [[1] valueWithArguments: 'string'] signal: Error.
	should: [[1] valueWithArguments: 0] signal: Error.
	should: [[1] valueWithArguments: []] signal: Error.
)
public testValueWithArgumentsTooFew = (
	should: [[:x | x - 4] valueWithArguments: {}] signal: Error.
	should: [[:x :y | x - y] valueWithArguments: {1}] signal: Error.
	should: [[:x :y :z | x - y + z] valueWithArguments: {1. 2}] signal: Error.
)
public testValueWithArgumentsTooMany = (
	should: [[3 - 4] valueWithArguments: {1}] signal: Error.
	should: [[:x | x - 4] valueWithArguments: {1. 2}] signal: Error.
	should: [[:x :y | x - y] valueWithArguments: {1. 2. 3}] signal: Error.
	should: [[:x :y :z | x - y + z] valueWithArguments: {1. 2. 3. 4}] signal: Error.
)
) : (
TEST_CONTEXT = ()
)
class DnuAnswerMessage = () (
protected doesNotUnderstand: message = (
	^message
)
) : (
)
public class ExceptionTests = TestContext () (
nonLocalReturnCrossingExceptionHandler = (
	[^'correct']
		on: Error
		do: [:ex | ^'wrong1'].
	^'wrong2'
)
public testExceptionHandled = (
	|
	beforeSignal ::= false.
	afterSignal ::= false.
	handler ::= false.
	exceptionSignaled
	exceptionHandled
	result
	|

	result::
		[beforeSignal:: true.
		 exceptionSignaled:: Exception new.
		 exceptionSignaled signal.
		 afterSignal:: true.
		 42]
			on: Exception
			do: [:ex | handler:: true. exceptionHandled:: ex. 84].

	assert: beforeSignal.
	deny: afterSignal.
	assert: handler.
	assert: exceptionSignaled equals: exceptionHandled.
	assert: result equals: 84.
)
public testExceptionInvalidPass = (
	| ex |

	(* Already handled. *)
	ex:: Exception new.
	[ex signal] on: Exception do: [:e | ].
	should: [ex pass] signal: Error.

	(* Already resumed. *)
	ex:: Exception new.
	[ex signal] on: Exception do: [:e | e resume: 42].
	should: [ex pass] signal: Error.

	(* Already returned. *)
	ex:: Exception new.
	[ex signal] on: Exception do: [:e | e return: 42].
	should: [ex pass] signal: Error.

	(* Never signaled. *)
	ex:: Exception new.
	should: [ex pass] signal: Error.
)
public testExceptionInvalidResume = (
	| ex |

	(* Already handled. *)
	ex:: Exception new.
	[ex signal] on: Exception do: [:e | ].
	should: [ex resume: 84] signal: Error.

	(* Already resumed. *)
	ex:: Exception new.
	[ex signal] on: Exception do: [:e | e resume: 42].
	should: [ex resume: 84] signal: Error.

	(* Already returned. *)
	ex:: Exception new.
	[ex signal] on: Exception do: [:e | e return: 42].
	should: [ex resume: 84] signal: Error.

	(* Never signaled. *)
	ex:: Exception new.
	should: [ex resume: 84] signal: Error.
)
public testExceptionInvalidReturn = (
	| ex |

	(* Already handled. *)
	ex:: Exception new.
	[ex signal] on: Exception do: [:e | ].
	should: [ex return: 84] signal: Error.

	(* Already resumed. *)
	ex:: Exception new.
	[ex signal] on: Exception do: [:e | e resume: 42].
	should: [ex return: 84] signal: Error.

	(* Already returned. *)
	ex:: Exception new.
	[ex signal] on: Exception do: [:e | e return: 42].
	should: [ex return: 84] signal: Error.

	(* Never signaled. *)
	ex:: Exception new.
	should: [ex return: 84] signal: Error.
)
public testExceptionPass = (
	|
	beforeSignal ::= false.
	afterSignal ::= false.
	afterInnerTry ::= false.
	outerHandler ::= false.
	innerHandler ::= false.
	afterPass ::= false.
	|


	[
		[
			beforeSignal:: true.
			Exception new signal.
			afterSignal:: true.
		] on: Exception do:
			[:ex |
			innerHandler:: true.
			ex pass.
			afterPass:: true].
		afterInnerTry:: true.
	] on: Exception do: [:ex | outerHandler:: true].

	assert: beforeSignal.
	deny: afterSignal.
	assert: innerHandler.
	deny: afterPass.
	deny: afterInnerTry.
	assert: outerHandler.
)
public testExceptionResume = (
	|
	beforeSignal ::= false.
	afterSignal ::= false.
	handler ::= false.
	afterResume ::= false.
	exceptionSignaled
	exceptionHandled
	signalResult
	result
	|

	result::
		[beforeSignal:: true.
		 exceptionSignaled:: Exception new.
		 signalResult:: exceptionSignaled signal.
		 afterSignal:: true.
		 42]
			on: Exception
			do:
				[:ex |
				handler:: true.
				exceptionHandled:: ex.
				ex resume: 63.
				afterResume:: true.
				84].

	assert: beforeSignal.
	assert: afterSignal.
	assert: handler.
	deny: afterResume.
	assert: exceptionSignaled equals: exceptionHandled.
	assert: signalResult equals: 63.
	assert: result equals: 42.
)
public testExceptionReturn = (
	|
	beforeSignal ::= false.
	afterSignal ::= false.
	handler ::= false.
	afterReturn ::= false.
	exceptionSignaled
	exceptionHandled
	signalResult
	result
	|

	result::
		[beforeSignal:: true.
		 exceptionSignaled:: Exception new.
		 signalResult:: exceptionSignaled signal.
		 afterSignal:: true.
		 42]
			on: Exception
			do:
				[:ex |
				handler:: true.
				exceptionHandled:: ex.
				ex return: 63.
				afterReturn:: true.
				84].

	assert: beforeSignal.
	deny: afterSignal.
	assert: handler.
	deny: afterReturn.
	assert: exceptionSignaled equals: exceptionHandled.
	assert: signalResult equals: nil.
	assert: result equals: 63.
)
public testExceptionSignalInHandler = (
	|
	outerBefore ::= false.
	outerAfter ::= false.
	innerBefore ::= false.
	innerAfter ::= false.
	innerExceptionSignaled
	innerExceptionCaught
	handlerExceptionSignaled
	outerExceptionCaught
	|

	[outerBefore:: true.
		[innerBefore:: true.
		 innerExceptionSignaled:: Exception new.
		 innerExceptionSignaled signal.
		 innerAfter:: true]
			on: Exception
			do:
				[:ex |
				handlerExceptionSignaled:: Exception new.
				handlerExceptionSignaled signal].
	 outerAfter:: true]
		on: Exception
		do: [:ex | outerExceptionCaught:: ex].

	assert: outerBefore.
	assert: innerBefore.
	deny: innerAfter.
	deny: outerAfter.
	assert: outerExceptionCaught equals: handlerExceptionSignaled.
)
public testExceptionTypeMatch1 = (
	|
	beforeSignal ::= false.
	afterSignal ::= false.
	afterInnerTry ::= false.
	outerHandler ::= false.
	innerHandler ::= false.
	|


	[
		[
			beforeSignal:: true.
			Exception new signal.
			afterSignal:: true.
		] on: TestException do: [:ex | innerHandler:: true].
		afterInnerTry:: true.
	] on: Exception do: [:ex | outerHandler:: true].

	assert: beforeSignal.
	deny: afterSignal.
	deny: innerHandler.
	deny: afterInnerTry.
	assert: outerHandler.
)
public testExceptionTypeMatch2 = (
	|
	beforeSignal ::= false.
	afterSignal ::= false.
	afterInnerTry ::= false.
	outerHandler ::= false.
	innerHandler ::= false.
	|


	[
		[
			beforeSignal:: true.
			TestException new signal.
			afterSignal:: true.
		] on: TestException do: [:ex | innerHandler:: true].
		afterInnerTry:: true.
	] on: Exception do: [:ex | outerHandler:: true].

	assert: beforeSignal.
	deny: afterSignal.
	assert: innerHandler.
	assert: afterInnerTry.
	deny: outerHandler.
)
public testExceptionTypeMatch3 = (
	|
	beforeSignal ::= false.
	afterSignal ::= false.
	afterInnerTry ::= false.
	outerHandler ::= false.
	innerHandler ::= false.
	|


	[
		[
			beforeSignal:: true.
			TestException new signal.
			afterSignal:: true.
		] on: Exception do: [:ex | innerHandler:: true].
		afterInnerTry:: true.
	] on: TestException do: [:ex | outerHandler:: true].

	assert: beforeSignal.
	deny: afterSignal.
	assert: innerHandler.
	assert: afterInnerTry.
	deny: outerHandler.
)
public testNonLocalReturnCrossingExceptionHandler = (
	assert: nonLocalReturnCrossingExceptionHandler equals: 'correct'
)
) : (
TEST_CONTEXT = ()
)
public class FloatTests = TestContext () (
assert: observedValue approximatelyEquals: expectedValue = (
	| delta |
	delta:: observedValue - expectedValue.
	delta < 0 ifTrue: [delta:: 0 - delta].
	delta < 0.00000001 ifFalse:
		[failWithMessage: 'Expected ', expectedValue printString, ', actual ', observedValue printString].
)
e = (
	^Float parse: '2.718281828459045'
)
infinity = (
	^Float parse: 'Infinity'
)
ln2 = (
	^Float parse: '0.6931471805599453'
)
nan = (
	^Float parse: 'NaN'
)
negativeInfinity = (
	^Float parse: '-Infinity'
)
pi = (
	^Float parse: '3.1415926535897932'
)
sqrt2 = (
	^Float parse: '1.4142135623730951'
)
public testFloatAdd = (
	assert: 3 asFloat + 4 asFloat equals: 7 asFloat.
	assert: 3.5 asFloat + 4.5 asFloat equals: 8 asFloat.
)
public testFloatAsInteger = (
	| nan posInfinity negInfinity |

	(* truncation *)
	assert: 3.0 asFloat asInteger equals: 3.
	assert: -3.0 asFloat asInteger equals: -3.
	assert: 3.4 asFloat asInteger equals: 3.
	assert: 3.5 asFloat asInteger equals: 3.
	assert: -3.4 asFloat asInteger equals: -3.
	assert: -3.5 asFloat asInteger equals: -3.

	assert: minDoubleInt asFloat asInteger equals: minDoubleInt.
	deny: (minDoubleInt - 1) asFloat asInteger equals: minDoubleInt + 1.
	assert: maxDoubleInt asFloat asInteger equals: maxDoubleInt.
	deny: (maxDoubleInt + 1) asFloat asInteger equals: maxDoubleInt + 1.

	nan:: Float parse: 'NaN'.
	posInfinity:: Float parse: 'Infinity'.
	negInfinity:: Float parse: '-Infinity'.
	should: [nan asInteger] signal: Error.
	should: [posInfinity asInteger] signal: Error.
	should: [negInfinity asInteger] signal: Error.
)
public testFloatAsLargeInteger = (
	assert: (Float parse: '-9223372036854775809.0') asInteger equals: -9223372036854775808.
	assert: (Float parse: '9223372036854775808.0') asInteger equals: smallestPositiveLargeInteger.

	assert: (Float parse: '4503599627370496.0') asInteger equals: 4503599627370496.
	assert: (Float parse: '9007199254740992.0') asInteger equals: 9007199254740992.
	assert: (Float parse: '13510798882111488.0') asInteger equals: 13510798882111488.
	assert: (Float parse: '9007199254740992.0') asInteger equals: 9007199254740992.
	assert: (Float parse: '18014398509481984.0') asInteger equals: 18014398509481984.
	assert: (Float parse: '27021597764222976.0') asInteger equals: 27021597764222976.
	assert: (Float parse: '18014398509481984.0') asInteger equals: 18014398509481984.
	assert: (Float parse: '36028797018963970.0') asInteger equals: 36028797018963968.
	assert: (Float parse: '54043195528445950.0') asInteger equals: 54043195528445952.

	assert: (Float parse: '24740339110622220000.0') asInteger equals: 24740339110622220288.
	assert: (Float parse: '5.312947368603608e+28') asInteger equals: 53129473686036081173933850624.
	assert: (Float parse: '2.2818935193521754e+38') asInteger equals: 228189351935217540518047176097429192704.
	assert: (Float parse: '1.658568574584348e+173') asInteger equals: 165856857458434792594590690796997344645011320494961564483172792646347034888659021126627038240664816862208980330541286657468273292758481943260235328058958538937625559982669824.

	assert: (Float parse: '19342813113834066795298816') asInteger equals: 1 << (32 + 52).
	assert: (Float parse: '83076749736557242056487941267521536') asInteger equals: 1 << (64 + 52).
	assert: (Float parse: '356811923176489970264571492362373784095686656') asInteger equals: 1 << (96 + 52).

	assert: (((1 << 53) - 1) << (1023 - 52)) asFloat asInteger equals: (((1 << 53) - 1) << (1023 - 52)).
)
public testFloatAsMediumInteger = (
	assert: (Float parse: '2147483647.0') asInteger equals: maxInt32.
	assert: (Float parse: '-2147483648.0') asInteger equals: minInt32.

	assert: (Float parse: '461168601842738750.0') asInteger equals: 461168601842738752.
	assert: (Float parse: '-4611686018427387904.0') asInteger equals: minInt63.

	assert: (Float parse: '9223372036854774784.0') asInteger equals: 9223372036854774784.
	assert: (Float parse: '-9223372036854775808.0') asInteger equals: minInt64.

	assert: (Float parse: '14627351835422149374.0') asInteger equals: 14627351835422148608.
)
public testFloatAsSmallInteger = (
	assert: (Float parse: '7.0') asInteger equals: 7.

	assert: (Float parse: '1073741823.0') asInteger equals: maxInt31.
	assert: (Float parse: '-1073741824.0') asInteger equals: minInt31.

	assert: (Float parse: '3405695742.0') asInteger equals: 16rCAFECAFE.
)
public testFloatAsString = (
	| fmax fmin |
	assert: 3 asFloat asString equals: '3.0'.
	assert: (3 asFloat / 2 asFloat) asString equals: '1.5'.
	assert: (1 asFloat / 3 asFloat) asString equals: '0.3333333333333333'.
	assert: (-22 asFloat / 7 asFloat) asString equals: '-3.142857142857143'.

	assert: (Float parse: 'NaN') asString equals: 'NaN'.
	assert: (Float parse: 'Infinity') asString equals: 'Infinity'.
	assert: (Float parse: '-Infinity') asString equals: '-Infinity'.

	fmax:: '1.7976931348623157e+308'.
	assert: (Float parse: fmax) asString equals: '1.7976931348623157e+308'.
	fmin:: '-1.7976931348623157e+308'.
	assert: (Float parse: fmin) asString equals: '-1.7976931348623157e+308'.
)
public testFloatAsStringExponential = (
	| fmax fmin |
	assert: (3 asFloat asStringExponential: 0) equals: '3e+0'.
	assert: (3 asFloat asStringExponential: 1) equals: '3.0e+0'.
	assert: (3 asFloat asStringExponential: 2) equals: '3.00e+0'.
	assert: ((3 asFloat / 2 asFloat) asStringExponential: 0) equals: '2e+0'.
	assert: ((3 asFloat / 2 asFloat) asStringExponential: 1) equals: '1.5e+0'.
	assert: ((3 asFloat / 2 asFloat) asStringExponential: 2) equals: '1.50e+0'.
	assert: ((1 asFloat / 3 asFloat) asStringExponential: 0) equals: '3e-1'.
	assert: ((1 asFloat / 3 asFloat) asStringExponential: 1) equals: '3.3e-1'.
	assert: ((1 asFloat / 3 asFloat) asStringExponential: 2) equals: '3.33e-1'.
	assert: ((200 asFloat / 3 asFloat) asStringExponential: 0) equals: '7e+1'.
	assert: ((200 asFloat / 3 asFloat) asStringExponential: 1) equals: '6.7e+1'.
	assert: ((200 asFloat / 3 asFloat) asStringExponential: 2) equals: '6.67e+1'.
	assert: ((200 asFloat / 3 asFloat) asStringExponential: 3) equals: '6.667e+1'.
	assert: ((200 asFloat / 3 asFloat) asStringExponential: 4) equals: '6.6667e+1'.
	assert: ((-22 asFloat / 7 asFloat) asStringExponential: 0) equals: '-3e+0'.
	assert: ((-22 asFloat / 7 asFloat) asStringExponential: 1) equals: '-3.1e+0'.
	assert: ((-22 asFloat / 7 asFloat) asStringExponential: 2) equals: '-3.14e+0'.

	assert: ((Float parse: '0.0') asStringExponential: 0) equals: '0e+0'.
	assert: ((Float parse: '0.0') asStringExponential: 1) equals: '0.0e+0'.
	assert: ((Float parse: '0.0') asStringExponential: 2) equals: '0.00e+0'.
	assert: ((Float parse: '-0.0') asStringExponential: 0) equals: '-0e+0'.
	assert: ((Float parse: '-0.0') asStringExponential: 1) equals: '-0.0e+0'.
	assert: ((Float parse: '-0.0') asStringExponential: 2) equals: '-0.00e+0'.
	assert: ((Float parse: 'NaN') asStringExponential: 0) equals: 'NaN'.
	assert: ((Float parse: 'NaN') asStringExponential: 1) equals: 'NaN'.
	assert: ((Float parse: 'NaN') asStringExponential: 2) equals: 'NaN'.
	assert: ((Float parse: 'Infinity') asStringExponential: 0) equals: 'Infinity'.
	assert: ((Float parse: 'Infinity') asStringExponential: 1) equals: 'Infinity'.
	assert: ((Float parse: 'Infinity') asStringExponential: 2) equals: 'Infinity'.
	assert: ((Float parse: '-Infinity') asStringExponential: 0) equals: '-Infinity'.
	assert: ((Float parse: '-Infinity') asStringExponential: 1) equals: '-Infinity'.
	assert: ((Float parse: '-Infinity') asStringExponential: 2) equals: '-Infinity'.

	fmax:: '1.7976931348623157e+308'.
	assert: ((Float parse: fmax) asStringExponential: 0) equals: '2e+308'.
	assert: ((Float parse: fmax) asStringExponential: 1) equals: '1.8e+308'.
	assert: ((Float parse: fmax) asStringExponential: 2) equals: '1.80e+308'.
	assert: ((Float parse: fmax) asStringExponential: 10) equals: '1.7976931349e+308'.
	assert: ((Float parse: fmax) asStringExponential: 20) equals: '1.79769313486231570815e+308'.
	fmin:: '-1.7976931348623157e+308'.
	assert: ((Float parse: fmin) asStringExponential: 0) equals: '-2e+308'.
	assert: ((Float parse: fmin) asStringExponential: 1) equals: '-1.8e+308'.
	assert: ((Float parse: fmin) asStringExponential: 2) equals: '-1.80e+308'.
	assert: ((Float parse: fmin) asStringExponential: 10) equals: '-1.7976931349e+308'.
	assert: ((Float parse: fmin) asStringExponential: 20) equals: '-1.79769313486231570815e+308'.
)
public testFloatAsStringExponentialErrors = (
	should: [0 asFloat asStringExponential: -1] signal: Error.
	should: [0 asFloat asStringExponential: 21] signal: Error.
	should: [0 asFloat asStringExponential: nil] signal: Error.
	should: [0 asFloat asStringExponential: '1'] signal: Error.
)
public testFloatAsStringFixed = (
	| fmax fmin |
	assert: (3 asFloat asStringFixed: 0) equals: '3'.
	assert: (3 asFloat asStringFixed: 1) equals: '3.0'.
	assert: (3 asFloat asStringFixed: 2) equals: '3.00'.
	assert: ((3 asFloat / 2 asFloat) asStringFixed: 0) equals: '2'.
	assert: ((3 asFloat / 2 asFloat) asStringFixed: 1) equals: '1.5'.
	assert: ((3 asFloat / 2 asFloat) asStringFixed: 2) equals: '1.50'.
	assert: ((1 asFloat / 3 asFloat) asStringFixed: 0) equals: '0'.
	assert: ((1 asFloat / 3 asFloat) asStringFixed: 1) equals: '0.3'.
	assert: ((1 asFloat / 3 asFloat) asStringFixed: 2) equals: '0.33'.
	assert: ((200 asFloat / 3 asFloat) asStringFixed: 0) equals: '67'.
	assert: ((200 asFloat / 3 asFloat) asStringFixed: 1) equals: '66.7'.
	assert: ((200 asFloat / 3 asFloat) asStringFixed: 2) equals: '66.67'.
	assert: ((200 asFloat / 3 asFloat) asStringFixed: 3) equals: '66.667'.
	assert: ((200 asFloat / 3 asFloat) asStringFixed: 4) equals: '66.6667'.
	assert: ((-22 asFloat / 7 asFloat) asStringFixed: 0) equals: '-3'.
	assert: ((-22 asFloat / 7 asFloat) asStringFixed: 1) equals: '-3.1'.
	assert: ((-22 asFloat / 7 asFloat) asStringFixed: 2) equals: '-3.14'.

	assert: ((Float parse: '0.0') asStringFixed: 0) equals: '0'.
	assert: ((Float parse: '0.0') asStringFixed: 1) equals: '0.0'.
	assert: ((Float parse: '0.0') asStringFixed: 2) equals: '0.00'.
	assert: ((Float parse: '-0.0') asStringFixed: 0) equals: '-0'.
	assert: ((Float parse: '-0.0') asStringFixed: 1) equals: '-0.0'.
	assert: ((Float parse: '-0.0') asStringFixed: 2) equals: '-0.00'.
	assert: ((Float parse: 'NaN') asStringFixed: 0) equals: 'NaN'.
	assert: ((Float parse: 'NaN') asStringFixed: 1) equals: 'NaN'.
	assert: ((Float parse: 'NaN') asStringFixed: 2) equals: 'NaN'.
	assert: ((Float parse: 'Infinity') asStringFixed: 0) equals: 'Infinity'.
	assert: ((Float parse: 'Infinity') asStringFixed: 1) equals: 'Infinity'.
	assert: ((Float parse: 'Infinity') asStringFixed: 2) equals: 'Infinity'.
	assert: ((Float parse: '-Infinity') asStringFixed: 0) equals: '-Infinity'.
	assert: ((Float parse: '-Infinity') asStringFixed: 1) equals: '-Infinity'.
	assert: ((Float parse: '-Infinity') asStringFixed: 2) equals: '-Infinity'.

	fmax:: '1.7976931348623157e+308'.
	assert: ((Float parse: fmax) asStringFixed: 0) equals: '1.7976931348623157e+308'.
	assert: ((Float parse: fmax) asStringFixed: 1) equals: '1.7976931348623157e+308'.
	assert: ((Float parse: fmax) asStringFixed: 2) equals: '1.7976931348623157e+308'.
	assert: ((Float parse: fmax) asStringFixed: 10) equals: '1.7976931348623157e+308'.
	assert: ((Float parse: fmax) asStringFixed: 20) equals: '1.7976931348623157e+308'.
	fmin:: '-1.7976931348623157e+308'.
	assert: ((Float parse: fmin) asStringFixed: 0) equals: '-1.7976931348623157e+308'.
	assert: ((Float parse: fmin) asStringFixed: 1) equals: '-1.7976931348623157e+308'.
	assert: ((Float parse: fmin) asStringFixed: 2) equals: '-1.7976931348623157e+308'.
	assert: ((Float parse: fmin) asStringFixed: 10) equals: '-1.7976931348623157e+308'.
	assert: ((Float parse: fmin) asStringFixed: 20) equals: '-1.7976931348623157e+308'.
)
public testFloatAsStringFixedErrors = (
	should: [0 asFloat asStringFixed: -1] signal: Error.
	should: [0 asFloat asStringFixed: 21] signal: Error.
	should: [0 asFloat asStringFixed: nil] signal: Error.
	should: [0 asFloat asStringFixed: '1'] signal: Error.
)
public testFloatAsStringPrecision = (
	| fmax fmin |
	assert: (3 asFloat asStringPrecision: 1) equals: '3'.
	assert: (3 asFloat asStringPrecision: 2) equals: '3.0'.
	assert: (3 asFloat asStringPrecision: 3) equals: '3.00'.
	assert: ((3 asFloat / 2 asFloat) asStringPrecision: 1) equals: '2'.
	assert: ((3 asFloat / 2 asFloat) asStringPrecision: 2) equals: '1.5'.
	assert: ((3 asFloat / 2 asFloat) asStringPrecision: 3) equals: '1.50'.
	assert: ((1 asFloat / 3 asFloat) asStringPrecision: 1) equals: '0.3'.
	assert: ((1 asFloat / 3 asFloat) asStringPrecision: 2) equals: '0.33'.
	assert: ((1 asFloat / 3 asFloat) asStringPrecision: 3) equals: '0.333'.
	assert: ((200 asFloat / 3 asFloat) asStringPrecision: 1) equals: '7e+1'.
	assert: ((200 asFloat / 3 asFloat) asStringPrecision: 2) equals: '67'.
	assert: ((200 asFloat / 3 asFloat) asStringPrecision: 3) equals: '66.7'.
	assert: ((200 asFloat / 3 asFloat) asStringPrecision: 4) equals: '66.67'.
	assert: ((200 asFloat / 3 asFloat) asStringPrecision: 5) equals: '66.667'.
	assert: ((-22 asFloat / 7 asFloat) asStringPrecision: 1) equals: '-3'.
	assert: ((-22 asFloat / 7 asFloat) asStringPrecision: 2) equals: '-3.1'.
	assert: ((-22 asFloat / 7 asFloat) asStringPrecision: 3) equals: '-3.14'.

	assert: ((Float parse: '0.0') asStringPrecision: 1) equals: '0'.
	assert: ((Float parse: '0.0') asStringPrecision: 2) equals: '0.0'.
	assert: ((Float parse: '0.0') asStringPrecision: 3) equals: '0.00'.
	assert: ((Float parse: '-0.0') asStringPrecision: 1) equals: '-0'.
	assert: ((Float parse: '-0.0') asStringPrecision: 2) equals: '-0.0'.
	assert: ((Float parse: '-0.0') asStringPrecision: 3) equals: '-0.00'.
	assert: ((Float parse: 'NaN') asStringPrecision: 1) equals: 'NaN'.
	assert: ((Float parse: 'NaN') asStringPrecision: 2) equals: 'NaN'.
	assert: ((Float parse: 'NaN') asStringPrecision: 3) equals: 'NaN'.
	assert: ((Float parse: 'Infinity') asStringPrecision: 1) equals: 'Infinity'.
	assert: ((Float parse: 'Infinity') asStringPrecision: 2) equals: 'Infinity'.
	assert: ((Float parse: 'Infinity') asStringPrecision: 3) equals: 'Infinity'.
	assert: ((Float parse: '-Infinity') asStringPrecision: 1) equals: '-Infinity'.
	assert: ((Float parse: '-Infinity') asStringPrecision: 2) equals: '-Infinity'.
	assert: ((Float parse: '-Infinity') asStringPrecision: 3) equals: '-Infinity'.

	fmax:: '1.7976931348623157e+308'.
	assert: ((Float parse: fmax) asStringPrecision: 1) equals: '2e+308'.
	assert: ((Float parse: fmax) asStringPrecision: 2) equals: '1.8e+308'.
	assert: ((Float parse: fmax) asStringPrecision: 3) equals: '1.80e+308'.
	assert: ((Float parse: fmax) asStringPrecision: 10) equals: '1.797693135e+308'.
	assert: ((Float parse: fmax) asStringPrecision: 20) equals: '1.7976931348623157081e+308'.
	fmin:: '-1.7976931348623157e+308'.
	assert: ((Float parse: fmin) asStringPrecision: 1) equals: '-2e+308'.
	assert: ((Float parse: fmin) asStringPrecision: 2) equals: '-1.8e+308'.
	assert: ((Float parse: fmin) asStringPrecision: 3) equals: '-1.80e+308'.
	assert: ((Float parse: fmin) asStringPrecision: 10) equals: '-1.797693135e+308'.
	assert: ((Float parse: fmin) asStringPrecision: 20) equals: '-1.7976931348623157081e+308'.
)
public testFloatAsStringPrecisionErrors = (
	should: [0 asFloat asStringPrecision: 0] signal: Error.
	should: [0 asFloat asStringPrecision: 22] signal: Error.
	should: [0 asFloat asStringPrecision: nil] signal: Error.
	should: [0 asFloat asStringPrecision: '1'] signal: Error.
)
public testFloatCeiling = (
	assert: 3.0 asFloat ceiling equals: 3.
	assert: 3.4 asFloat ceiling equals: 4.
	assert: 3.5 asFloat ceiling equals: 4.
	assert: -3.4 asFloat ceiling equals: -3.
	assert: -3.5 asFloat ceiling equals: -3.

	assert: minDoubleInt asFloat ceiling equals: minDoubleInt.
	(* :todo: Should float-integer comparison be precise?
	deny: (minDoubleInt - 1) asFloat ceiling equals: minDoubleInt + 1. *)
	assert: maxDoubleInt asFloat ceiling equals: maxDoubleInt.
	(* :todo: Should float-integer comparison be precise?
	deny: (maxDoubleInt + 1) asFloat ceiling equals: maxDoubleInt + 1. *)

	minInt64 asFloat ceiling.
	maxInt64 asFloat ceiling.
)
public testFloatCommonLogarithm = (
	assert: 100 asFloat log equals: 2.
	assert: 10 asFloat log equals: 1.
	assert: 1 asFloat log equals: 0.
	assert: 0.1 asFloat log approximatelyEquals: -1.
	assert: 0.01 asFloat log approximatelyEquals: -2.

	assert: -1 asFloat log isNaN.

	assert: infinity log equals: infinity.
	assert: negativeInfinity log isNaN.
	assert: nan log isNaN.
)
public testFloatComparisonErrors = (
	deny: 4.25 asFloat = '4.25'.
	should: [4.25 asFloat < '4.25'] signal: Error.
	should: [4.25 asFloat > '4.25'] signal: Error.
	should: [4.25 asFloat <= '4.25'] signal: Error.
	should: [4.25 asFloat >= '4.25'] signal: Error.

	deny: 4.25 asFloat = {4.25 asFloat}.
	should: [4.25 asFloat < {4.25 asFloat}] signal: Error.
	should: [4.25 asFloat > {4.25 asFloat}] signal: Error.
	should: [4.25 asFloat <= {4.25 asFloat}] signal: Error.
	should: [4.25 asFloat >= {4.25 asFloat}] signal: Error.
)
public testFloatComparisons = (
	assert: 1.618 asFloat = 1.618 asFloat.
	deny: 1.618 asFloat < 1.618 asFloat.
	deny: 1.618 asFloat > 1.618 asFloat.
	assert: 1.618 asFloat <= 1.618 asFloat.
	assert: 1.618 asFloat >= 1.618 asFloat.

	deny: 1.2 asFloat = 1.3 asFloat.
	assert: 1.2 asFloat < 1.3 asFloat.
	deny: 1.2 asFloat > 1.3 asFloat.
	assert: 1.2 asFloat <= 1.3 asFloat.
	deny: 1.2 asFloat >= 1.3 asFloat.

	deny: -1.2 asFloat = 1.3 asFloat.
	assert: -1.2 asFloat < 1.3 asFloat.
	deny: -1.2 asFloat > 1.3 asFloat.
	assert: -1.2 asFloat <= 1.3 asFloat.
	deny: -1.2 asFloat >= 1.3 asFloat.

	deny: 1.2 asFloat = -1.3 asFloat.
	deny: 1.2 asFloat < -1.3 asFloat.
	assert: 1.2 asFloat > -1.3 asFloat.
	deny: 1.2 asFloat <= -1.3 asFloat.
	assert: 1.2 asFloat >= -1.3 asFloat.

	deny: -1.2 asFloat = -1.3 asFloat.
	deny: -1.2 asFloat < -1.3 asFloat.
	assert: -1.2 asFloat > -1.3 asFloat.
	deny: -1.2 asFloat <= -1.3 asFloat.
	assert: -1.2 asFloat >= -1.3 asFloat.
)
public testFloatCosine = (
	assert: (-2 * pi) cos approximatelyEquals: 1.
	assert: (-3 * pi / 2) cos approximatelyEquals: 0.
	assert: (0 - pi) cos approximatelyEquals: -1.
	assert: (0 - (pi / 2)) cos approximatelyEquals: 0.
	assert: 0 asFloat cos approximatelyEquals: 1.
	assert: (pi / 2) cos approximatelyEquals: 0.
	assert: pi cos approximatelyEquals: -1.
	assert: (3 * pi / 2) cos approximatelyEquals: 0.
	assert: (2 * pi) cos approximatelyEquals: 1.

	assert: infinity cos isNaN.
	assert: negativeInfinity cos isNaN.
	assert: nan cos isNaN.
)
public testFloatDivide = (
	assert: 3 asFloat / 4 asFloat equals: 0.75 asFloat.
	assert: 3.5 asFloat / 3.5 asFloat equals: 1 asFloat.
	assert: (3.5 asFloat / 0.0 asFloat) equals: (Float parse: 'Infinity').
	assert: (-3.5 asFloat / 0.0 asFloat) equals: (Float parse: '-Infinity').
	assert: (0.0 asFloat / 0.0 asFloat) isNaN.
)
public testFloatExponential = (
	assert: 1 asFloat exp approximatelyEquals: e.
	assert: 0 asFloat exp equals: 1.

	assert: infinity exp equals: infinity.
	assert: negativeInfinity exp equals: 0.
	assert: nan exp isNaN.
)
public testFloatFloor = (
	assert: 3.0 asFloat floor equals: 3.
	assert: 3.4 asFloat floor equals: 3.
	assert: 3.5 asFloat floor equals: 3.
	assert: -3.4 asFloat floor equals: -4.
	assert: -3.5 asFloat floor equals: -4.

	assert: minDoubleInt asFloat floor equals: minDoubleInt.
	(* :todo: Should float-integer comparison be precise?
	deny: (minDoubleInt - 1) asFloat floor equals: minDoubleInt + 1. *)
	assert: maxDoubleInt asFloat floor equals: maxDoubleInt.
	(* :todo: Should float-integer comparison be precise?
	deny: (maxDoubleInt + 1) asFloat floor equals: maxDoubleInt + 1. *)

	minInt64 asFloat floor.
	maxInt64 asFloat floor.
)
public testFloatFunctions = (
	(* :todo: Tests results with some tolerance. *)

	assert: 3 asFloat sin isKindOfFloat.
	assert: 3 asFloat cos isKindOfFloat.
	assert: 3 asFloat tan isKindOfFloat.
	assert: 3 asFloat sqrt isKindOfFloat.
	assert: 3 asFloat log isKindOfFloat.
	assert: 3 asFloat ln isKindOfFloat.
	assert: 3 asFloat exp isKindOfFloat.

	assert: 3 sin isKindOfFloat.
	assert: 3 cos isKindOfFloat.
	assert: 3 tan isKindOfFloat.
	assert: 3 sqrt isKindOfFloat.
	assert: 3 log isKindOfFloat.
	assert: 3 ln isKindOfFloat.
	assert: 3 exp isKindOfFloat.
)
public testFloatHash = (
	assert: -3 asFloat hash equals: -3 hash.
	assert: 0 asFloat hash equals: 0 hash.
	assert: 3 asFloat hash equals: 3 hash.

	assert: minDoubleInt asFloat hash equals: minDoubleInt hash.
	assert: maxDoubleInt asFloat hash equals: maxDoubleInt hash.
)
public testFloatIsNaN = (
	assert: nan isNaN.
	deny: infinity isNaN.
	deny: negativeInfinity isNaN.
)
public testFloatMixedAdd = (
	assert: 3 + 4 asFloat equals: 7.
	assert: 3 asFloat + 4 equals: 7.

	assert: minInt31 + 4 asFloat equals: -1073741820 asFloat.
	assert: 3 asFloat + minInt31 equals: -1073741821 asFloat.
	assert: maxInt31 + 4 asFloat equals: 1073741827 asFloat.
	assert: 3 asFloat + maxInt31 equals: 1073741826 asFloat.

	assert: minInt63 + 4 asFloat equals: -4611686018427387900 asFloat.
	assert: 3 asFloat + minInt63 equals: -4611686018427387901 asFloat.
	assert: maxInt63 + 4 asFloat equals: 4611686018427387907 asFloat.
	assert: 3 asFloat + maxInt63 equals: 4611686018427387906 asFloat.

	assert: minInt64 + 4 asFloat equals: -9223372036854775804 asFloat.
	assert: 3 asFloat + minInt64 equals: -9223372036854775805 asFloat.
	assert: maxInt64 + 4 asFloat equals: (Float parse: '9.223372036854776e18').
	assert: 3 asFloat + maxInt64 equals: (Float parse: '9.223372036854776e18').

	assert: smallestPositiveLargeInteger + 4 asFloat equals: (Float parse: '9.223372036854776e18').
	assert: 3 asFloat + smallestPositiveLargeInteger equals: (Float parse: '9.223372036854776e18').
	assert: largestNegativeLargeInteger + 4 asFloat equals: (Float parse: '-9.223372036854776e18').
	assert: 3 asFloat + largestNegativeLargeInteger equals: (Float parse: '-9.223372036854776e18').
)
public testFloatMixedComparisons = (
	deny: 1.618 asFloat = 42.
	assert: 1.618 asFloat < 42.
	deny: 1.618 asFloat > 42.
	assert: 1.618 asFloat <= 42.
	deny: 1.618 asFloat >= 42.

	deny: 42 = 1.618 asFloat.
	deny: 42 < 1.618 asFloat.
	assert: 42 > 1.618 asFloat.
	deny: 42 <= 1.618 asFloat.
	assert: 42 >= 1.618 asFloat.

	assert: 42 asFloat = 42.
	deny: 42 asFloat < 42.
	deny: 42 asFloat > 42.
	assert: 42 asFloat <= 42.
	assert: 42 asFloat >= 42.

	assert: 42 = 42 asFloat.
	deny: 42 < 42 asFloat.
	deny: 42 > 42 asFloat.
	assert: 42 <= 42 asFloat.
	assert: 42 >= 42 asFloat.

	deny: 42 asFloat = maxInt64.
	assert: 42 asFloat < maxInt64.
	deny: 42 asFloat > maxInt64.
	assert: 42 asFloat <= maxInt64.
	deny: 42 asFloat >= maxInt64.

	deny: maxInt64 = 42 asFloat.
	deny: maxInt64 < 42 asFloat.
	assert: maxInt64 > 42 asFloat.
	deny: maxInt64 <= 42 asFloat.
	assert: maxInt64 >= 42 asFloat.

	deny: 42 asFloat = minInt64.
	deny: 42 asFloat < minInt64.
	assert: 42 asFloat > minInt64.
	deny: 42 asFloat <= minInt64.
	assert: 42 asFloat >= minInt64.

	deny: minInt64 = 42 asFloat.
	assert: minInt64 < 42 asFloat.
	deny: minInt64 > 42 asFloat.
	assert: minInt64 <= 42 asFloat.
	deny: minInt64 >= 42 asFloat.

	deny: 42 asFloat = smallestPositiveLargeInteger.
	assert: 42 asFloat < smallestPositiveLargeInteger.
	deny: 42 asFloat > smallestPositiveLargeInteger.
	assert: 42 asFloat <= smallestPositiveLargeInteger.
	deny: 42 asFloat >= smallestPositiveLargeInteger.

	deny: smallestPositiveLargeInteger = 42 asFloat.
	deny: smallestPositiveLargeInteger < 42 asFloat.
	assert: smallestPositiveLargeInteger > 42 asFloat.
	deny: smallestPositiveLargeInteger <= 42 asFloat.
	assert: smallestPositiveLargeInteger >= 42 asFloat.

	deny: 42 asFloat = largestNegativeLargeInteger.
	deny: 42 asFloat < largestNegativeLargeInteger.
	assert: 42 asFloat > largestNegativeLargeInteger.
	deny: 42 asFloat <= largestNegativeLargeInteger.
	assert: 42 asFloat >= largestNegativeLargeInteger.

	deny: largestNegativeLargeInteger = 42 asFloat.
	assert: largestNegativeLargeInteger < 42 asFloat.
	deny: largestNegativeLargeInteger > 42 asFloat.
	assert: largestNegativeLargeInteger <= 42 asFloat.
	deny: largestNegativeLargeInteger >= 42 asFloat.
)
public testFloatMixedDivide = (
	assert: 3 / 4 asFloat equals: 0.75 asFloat.
	assert: 3 asFloat / 4 equals: 0.75 asFloat.

	assert: minInt31 / 4 asFloat equals: (Float parse: '-2.68435456e8').
	assert: 3 asFloat / minInt31 equals: (Float parse: '-2.7939677238464355e-9').
	assert: maxInt31 / 4 asFloat equals: (Float parse: '2.6843545575e8').
	assert: 3 asFloat / maxInt31 equals: (Float parse: '2.7939677264485208e-9').

	assert: minInt63 / 4 asFloat equals: (Float parse: '-1.152921504606847e18').
	assert: 3 asFloat / minInt63 equals: (Float parse: '-6.505213034913027e-19').
	assert: maxInt63 / 4 asFloat equals: (Float parse: '1.152921504606847e18').
	assert: 3 asFloat / maxInt63 equals: (Float parse: '6.505213034913027e-19').

	assert: minInt64 / 4 asFloat equals: (Float parse: '-2.305843009213694e18').
	assert: 3 asFloat / minInt64 equals: (Float parse: '-3.2526065174565133e-19').
	assert: maxInt64 / 4 asFloat equals: (Float parse: '2.305843009213694e18').
	assert: 3 asFloat / maxInt64 equals: (Float parse: '3.2526065174565133e-19').

	assert: smallestPositiveLargeInteger / 4 asFloat equals: (Float parse: '2.305843009213694e18').
	assert: 3 asFloat / smallestPositiveLargeInteger equals: (Float parse: '3.2526065174565133e-19').
	assert: largestNegativeLargeInteger / 4 asFloat equals: (Float parse: '-2.305843009213694e18').
	assert: 3 asFloat / largestNegativeLargeInteger equals: (Float parse: '-3.2526065174565133e-19').

	assert: 3 asFloat / 0 equals: (Float parse: 'Infinity').
	assert: -3 / 0 asFloat equals: (Float parse: '-Infinity').
	assert: (0 asFloat / 0) isNaN.
	assert: (0 / 0 asFloat) isNaN.
)
public testFloatMixedMultiply = (
	assert: 3 * 4 asFloat equals: 12 asFloat.
	assert: 3 asFloat * 4 equals: 12 asFloat.

	assert: minInt31 * 4 asFloat equals: (Float parse: '-4.294967296e9').
	assert: 3 asFloat * minInt31 equals: -3221225472 asFloat.
	assert: maxInt31 * 4 asFloat equals: 4294967292 asFloat.
	assert: 3 asFloat * maxInt31 equals: 3221225469 asFloat.

	assert: minInt63 * 4 asFloat equals: (Float parse: '-1.8446744073709552e19').
	assert: 3 asFloat * minInt63 equals: (Float parse: '-1.3835058055282164e19').
	assert: maxInt63 * 4 asFloat equals: (Float parse: '1.8446744073709552e19').
	assert: 3 asFloat * maxInt63 equals: (Float parse: '1.3835058055282164e19').

	assert: minInt64 * 4 asFloat equals: (Float parse: '-3.6893488147419103e19').
	assert: 3 asFloat * minInt64 equals: (Float parse: '-2.7670116110564327e19').
	assert: maxInt64 * 4 asFloat equals: (Float parse: '3.6893488147419103e19').
	assert: 3 asFloat * maxInt64 equals: (Float parse: '2.7670116110564327e19').

	assert: smallestPositiveLargeInteger * 4 asFloat equals: (Float parse: '3.6893488147419103e19').
	assert: 3 asFloat * smallestPositiveLargeInteger equals: (Float parse: '2.7670116110564327e19').
	assert: largestNegativeLargeInteger * 4 asFloat equals: (Float parse: '-3.6893488147419103e19').
	assert: 3 asFloat * largestNegativeLargeInteger equals: (Float parse: '-2.7670116110564327e19').

	assert: 3 asFloat * 0 equals: 0 asFloat.
	assert: 0 * 4 asFloat equals: 0 asFloat.
)
public testFloatMixedSubtract = (
	assert: 3 - 4 asFloat equals: -1 asFloat.
	assert: 3 asFloat - 4 equals: -1 asFloat.

	assert: minInt31 - 4 asFloat equals: -1073741828 asFloat.
	assert: 3 asFloat - minInt31 equals: (Float parse: '1.073741827e9').
	assert: maxInt31 - 4 asFloat equals: (Float parse: '1.073741819e9').
	assert: 3 asFloat - maxInt31 equals: (Float parse: '-1.07374182e9').

	assert: minInt63 - 4 asFloat equals: (Float parse: '-4.611686018427388e18').
	assert: 3 asFloat - minInt63 equals: (Float parse: '4.611686018427388e18').
	assert: maxInt63 - 4 asFloat equals: (Float parse: '4.611686018427388e18').
	assert: 3 asFloat - maxInt63 equals: (Float parse: '-4.611686018427388e18').

	assert: minInt64 - 4 asFloat equals: (Float parse: '-9.223372036854776e18').
	assert: 3 asFloat - minInt64 equals: (Float parse: '9.223372036854776e18').
	assert: maxInt64 - 4 asFloat equals: (Float parse: '9.223372036854776e18').
	assert: 3 asFloat - maxInt64 equals: (Float parse: '-9.223372036854776e18').

	assert: smallestPositiveLargeInteger - 4 asFloat equals: (Float parse: '9.223372036854776e18').
	assert: 3 asFloat - smallestPositiveLargeInteger equals: (Float parse: '-9.223372036854776e18').
	assert: largestNegativeLargeInteger - 4 asFloat equals: (Float parse: '-9.223372036854776e18').
	assert: 3 asFloat - largestNegativeLargeInteger equals: (Float parse: '9.223372036854776e18').
)
public testFloatMultiply = (
	assert: 3 asFloat * 4 asFloat equals: 12 asFloat.
	assert: 3.5 asFloat * 4.5 asFloat equals: 15.75 asFloat.
	assert: 3.5 asFloat * 0 asFloat equals: 0 asFloat.
)
public testFloatNaturalLogarithm = (
	assert: 2 asFloat ln equals: ln2.
	assert: e ln equals: 1.

	assert: -1 asFloat ln isNaN.

	assert: infinity ln equals: infinity.
	assert: negativeInfinity ln isNaN.
	assert: nan ln isNaN.
)
public testFloatParse = (
	assert: (Float parse: '3') isKindOfFloat.
	assert: (Float parse: '3') equals: 3 asFloat.

	assert: (Float parse: '3.') isKindOfFloat.
	assert: (Float parse: '3.') equals: 3 asFloat.

	assert: (Float parse: '3.0') isKindOfFloat.
	assert: (Float parse: '3.0') equals: 3 asFloat.

	assert: (Float parse: '0003.0000') isKindOfFloat.
	assert: (Float parse: '0003.0000') equals: 3 asFloat.

	assert: (Float parse: '-3') isKindOfFloat.
	assert: (Float parse: '-3') equals: -3 asFloat.

	assert: (Float parse: '1.5') isKindOfFloat.
	assert: (Float parse: '1.5') equals: 1.5 asFloat.

	assert: (Float parse: 'NaN') isKindOfFloat.
	deny: (Float parse: 'NaN') equals: (Float parse: 'NaN').
	assert: (Float parse: 'NaN') asString equals: 'NaN'.

	assert: (Float parse: 'Infinity') isKindOfFloat.
	assert: (Float parse: 'Infinity') > 0.
	assert: (Float parse: 'Infinity') asString equals: 'Infinity'.
	assert: (Float parse: '-Infinity') isKindOfFloat.
	assert: (Float parse: '-Infinity') < 0.
	assert: (Float parse: '-Infinity') asString equals: '-Infinity'.

	should: [Float parse: 'xyz'] signal: Error.
	should: [Float parse: ''] signal: Error.
	should: [Float parse: '--9'] signal: Error.
	should: [Float parse: 'nan'] signal: Error.
	should: [Float parse: 'NAN'] signal: Error.
	should: [Float parse: 'infinity'] signal: Error.
	should: [Float parse: '-infinity'] signal: Error.
	should: [Float parse: 'inf'] signal: Error.
	should: [Float parse: '-inf'] signal: Error.
)
public testFloatRounded = (
	assert: 3.0 asFloat rounded equals: 3.
	assert: 3.4 asFloat rounded equals: 3.
	assert: 3.5 asFloat rounded equals: 4.
	assert: -3.4 asFloat rounded equals: -3.
	assert: -3.5 asFloat rounded equals: -4.

	minInt64 asFloat rounded.
	maxInt64 asFloat rounded.
)
public testFloatSine = (
	assert: (-2 * pi) sin approximatelyEquals: 0.
	assert: (-3 * pi / 2) sin approximatelyEquals: 1.
	assert: (0 - pi) sin approximatelyEquals: 0.
	assert: (0 - (pi / 2)) sin approximatelyEquals: -1.
	assert: 0 asFloat sin approximatelyEquals: 0.
	assert: (pi / 2) sin approximatelyEquals: 1.
	assert: pi sin approximatelyEquals: 0.
	assert: (3 * pi / 2) sin approximatelyEquals: -1.
	assert: (2 * pi) sin approximatelyEquals: 0.

	assert: infinity sin isNaN.
	assert: negativeInfinity sin isNaN.
	assert: nan sin isNaN.
)
public testFloatSquareRoot = (
	assert: 4 asFloat sqrt equals: 2.
	assert: 2 asFloat sqrt equals: sqrt2.
	assert: 0 asFloat sqrt equals: 0.

	assert: -1 asFloat sqrt isNaN.

	assert: infinity sqrt equals: infinity.
	assert: negativeInfinity sqrt isNaN.
	assert: nan sqrt isNaN.
)
public testFloatSubtract = (
	assert: 3 asFloat - 4 asFloat equals: -1 asFloat.
	assert: 3.5 asFloat - 4.5 asFloat equals: -1 asFloat.
)
public testFloatTangent = (
	assert: (0 - pi) tan approximatelyEquals: 0.
	assert: -1 asFloat tan approximatelyEquals: (Float parse: '-1.5574077246549025').
	assert: 0 asFloat tan approximatelyEquals: 0.
	assert: 1 asFloat tan approximatelyEquals: (Float parse: '1.5574077246549025').
	assert: pi tan approximatelyEquals: 0.

	assert: infinity tan isNaN.
	assert: negativeInfinity tan isNaN.
	assert: nan tan isNaN.
)
public testIsKindOfFloat = (
	deny: 'foo' isKindOfFloat.
	deny: #foo isKindOfFloat.
	deny: ('foo', 'bar') isKindOfFloat.
	deny: 1 isKindOfFloat.
	deny: 1.5 isKindOfFloat.
	assert: 1.5 asFloat isKindOfFloat.
	deny: true isKindOfFloat.
	deny: nil isKindOfFloat.
	deny: {} isKindOfFloat.
	deny: [] isKindOfFloat.
)
public testFloatOperatorsInvalidArgument = (
	should: [0 asFloat + nil] signal: Error.
	should: [0 asFloat - nil] signal: Error.
	should: [0 asFloat / nil] signal: Error.
	should: [0 asFloat * nil] signal: Error.
	should: [0 asFloat // nil] signal: Error.
	should: [0 asFloat \\ nil] signal: Error.
	should: [0 asFloat quo: nil] signal: Error.
	should: [0 asFloat rem: nil] signal: Error.
	should: [0 asFloat << nil] signal: Error.
	should: [0 asFloat >> nil] signal: Error.
	should: [0 asFloat bitAnd: nil] signal: Error.
	should: [0 asFloat bitOr: nil] signal: Error.
	should: [0 asFloat bitXor: nil] signal: Error.
	should: [1 asFloat ** nil] signal: Error.
)
public testFloatRaisedTo = (
	assert: (1 asFloat ** -1) equals: 1 asFloat.
	assert: (1 asFloat ** 0) equals: 1 asFloat.
	assert: (1 asFloat ** 1) equals: 1 asFloat.

	assert: (8 asFloat ** 2) equals: 64 asFloat.
	assert: (8 asFloat ** 1/3) approximatelyEquals: 2 asFloat.
	assert: (8 asFloat ** -1) equals: 1/8 asFloat.
)
) : (
TEST_CONTEXT = ()
)
public class FractionTests = TestContext () (
public testFractionAdd = (
	assert: (1/3) + (1/3) equals: (2/3).
	assert: (1/3) + (2/3) equals: 1.

	assert: (1/3) + (2/5) equals: (11/15).
	assert: (6/9) + (1/12) equals: (3/4).

	assert: (-1/3) + (2/5) equals: (1/15).
	assert: (1/3) + (-2/5) equals: (-1/15).
	assert: (-1/3) + (-2/5) equals: (-11/15).
)
public testFractionAsInteger = (
	(* Truncated *)
	assert: (2 / 5) asInteger equals: 0.
	assert: (3 / 5) asInteger equals: 0.
	assert: (4 / 5) asInteger equals: 0.
	assert: (5 / 5) asInteger equals: 1.
	assert: (7 / 5) asInteger equals: 1.
	assert: (8 / 5) asInteger equals: 1.
	assert: (9 / 5) asInteger equals: 1.

	assert: (-2 / 5) asInteger equals: 0.
	assert: (-3 / 5) asInteger equals: 0.
	assert: (-4 / 5) asInteger equals: 0.
	assert: (-5 / 5) asInteger equals: -1.
	assert: (-7 / 5) asInteger equals: -1.
	assert: (-8 / 5) asInteger equals: -1.
	assert: (-9 / 5) asInteger equals: -1.
)
public testFractionAsString = (
	assert: 1.5 asString equals: '(3/2)'.
	assert: (-3 / 2) asString equals: '(-3/2)'.
	assert: (3 / -2) asString equals: '(-3/2)'.
	assert: (-3 / -2) asString equals: '(3/2)'.
)
public testFractionCeiling = (
	assert: (2 / 5) ceiling equals: 1.
	assert: (3 / 5) ceiling equals: 1.
	assert: (4 / 5) ceiling equals: 1.
	assert: (5 / 5) ceiling equals: 1.
	assert: (7 / 5) ceiling equals: 2.
	assert: (8 / 5) ceiling equals: 2.
	assert: (9 / 5) ceiling equals: 2.

	assert: (-2 / 5) ceiling equals: 0.
	assert: (-3 / 5) ceiling equals: 0.
	assert: (-4 / 5) ceiling equals: 0.
	assert: (-5 / 5) ceiling equals: -1.
	assert: (-7 / 5) ceiling equals: -1.
	assert: (-8 / 5) ceiling equals: -1.
	assert: (-9 / 5) ceiling equals: -1.
)
public testFractionComparisionErrors = (
	deny: (1/9) = '(1/9)'.
	should: [(1/9) < '(1/9)'] signal: Error.
	should: [(1/9) > '(1/9)'] signal: Error.
	should: [(1/9) <= '(1/9)'] signal: Error.
	should: [(1/9) >= '(1/9)'] signal: Error.

	deny: (1/9) = {1/9}.
	should: [(1/9) < {1/9}] signal: Error.
	should: [(1/9) > {1/9}] signal: Error.
	should: [(1/9) <= {1/9}] signal: Error.
	should: [(1/9) >= {1/9}] signal: Error.
)
public testFractionComparisions = (
	assert: (1/9) = (1/9).
	deny: (1/9) < (1/9).
	deny: (1/9) > (1/9).
	assert: (1/9) <= (1/9).
	assert: (1/9) >= (1/9).

	deny: (2/7) = (3/5).
	assert: (2/7) < (3/5).
	deny: (2/7) > (3/5).
	assert: (2/7) <= (3/5).
	deny: (2/7) >= (3/5).

	deny: (-3/5) = (2/7).
	assert: (-3/5) < (2/7).
	deny: (-3/5) > (2/7).
	assert: (-3/5) <= (2/7).
	deny: (-3/5) >= (2/7).

	deny: (3/5) = (-2/7).
	deny: (3/5) < (-2/7).
	assert: (3/5) > (-2/7).
	deny: (3/5) <= (-2/7).
	assert: (3/5) >= (-2/7).

	deny: (-3/5) = (-2/7).
	assert: (-3/5) < (-2/7).
	deny: (-3/5) > (-2/7).
	assert: (-3/5) <= (-2/7).
	deny: (-3/5) >= (-2/7).
)
public testFractionDivide = (
	assert: (1/3) / (1/3) equals: 1.
	assert: (1/3) / (2/3) equals: (1/2).

	assert: (1/3) / (2/5) equals: (5/6).
	assert: (6/9) / (1/12) equals: 8.

	assert: (-1/3) / (2/5) equals: (-5/6).
	assert: (1/3) / (-2/5) equals: (-5/6).
	assert: (-1/3) / (-2/5) equals: (5/6).

	assert: (1/3) / (3/4) equals: (4/9).
	assert: (1/3) / (4/3) equals: (1/4).
)
public testFractionFloor = (
	assert: (2 / 5) floor equals: 0.
	assert: (3 / 5) floor equals: 0.
	assert: (4 / 5) floor equals: 0.
	assert: (5 / 5) floor equals: 1.
	assert: (7 / 5) floor equals: 1.
	assert: (8 / 5) floor equals: 1.
	assert: (9 / 5) floor equals: 1.

	assert: (-2 / 5) floor equals: -1.
	assert: (-3 / 5) floor equals: -1.
	assert: (-4 / 5) floor equals: -1.
	assert: (-5 / 5) floor equals: -1.
	assert: (-7 / 5) floor equals: -2.
	assert: (-8 / 5) floor equals: -2.
	assert: (-9 / 5) floor equals: -2.
)
public testFractionMixedAdd = (
	assert: (22/7) + 3 equals: (43/7).
	assert: (22/7) + maxInt32 equals: (15032385551/7).
	assert: ((5/4) + 3 asFloat) isKindOfFloat.
	assert: (5/4) + 3 asFloat equals: 4.25 asFloat.

	assert: 3 + (22/7) equals: (43/7).
	assert: maxInt32 + (22/7) equals: (15032385551/7).
	assert: (3 asFloat + (5/4)) isKindOfFloat.
	assert: 3 asFloat + (5/4) equals: 4.25 asFloat.
)
public testFractionMixedComparisions = (
	deny: (9/7) = 1.
	deny: (9/7) < 1.
	assert: (9/7) > 1.
	deny: (9/7) <= 1.
	assert: (9/7) >= 1.

	deny: 1 = (9/7).
	assert: 1 < (9/7).
	deny: 1 > (9/7).
	assert: 1 <= (9/7).
	deny: 1 >= (9/7).

	deny: (9/7) = 1 asFloat.
	deny: (9/7) < 1 asFloat.
	assert: (9/7) > 1 asFloat.
	deny: (9/7) <= 1 asFloat.
	assert: (9/7) >= 1 asFloat.

	deny: 1 asFloat = (9/7).
	assert: 1 asFloat < (9/7).
	deny: 1 asFloat > (9/7).
	assert: 1 asFloat <= (9/7).
	deny: 1 asFloat >= (9/7).
)
public testFractionMixedDivide = (
	assert: (22/7) / 3 equals: (22/21).
	assert: (22/7) / 14 equals: (11/49).
	assert: (22/7) / 11 equals: (2/7).
	assert: (22/7) / maxInt32 equals: (22/15032385529).
	assert: ((5/4) / 3 asFloat) isKindOfFloat.
	assert: (5/4) / 3 asFloat equals: 0.4166666666666667 asFloat.

	assert: 3 / (22/7) equals: (21/22).
	assert: 14 / (22/7) equals: (49/11).
	assert: 11 / (22/7) equals: (7/2).
	assert: maxInt32 / (22/7) equals: (15032385529/22).
	assert: (3 asFloat / (5/4)) isKindOfFloat.
	assert: 3 asFloat / (5/4) equals: 2.4 asFloat.
)
public testFractionMixedMultiply = (
	assert: (22/7) * 3 equals: (66/7).
	assert: (22/7) * 14 equals: 44.
	assert: (22/7) * maxInt32 equals: (47244640234/7).
	assert: ((5/4) * 3 asFloat) isKindOfFloat.
	assert: (5/4) * 3 asFloat equals: 3.75 asFloat.

	assert: 3 * (22/7) equals: (66/7).
	assert: 14 * (22/7) equals: 44.
	assert: maxInt32 * (22/7) equals: (47244640234/7).
	assert: (3 asFloat * (5/4)) isKindOfFloat.
	assert: 3 asFloat * (5/4) equals: 3.75 asFloat.
)
public testFractionMixedSubtract = (
	assert: (22/7) - 3 equals: (1/7).
	assert: (22/7) - maxInt32 equals: (-15032385507/7).
	assert: ((5/4) - 3 asFloat) isKindOfFloat.
	assert: (5/4) - 3 asFloat equals: -1.75 asFloat.

	assert: 3 - (22/7) equals: (-1/7).
	assert: maxInt32 - (22/7) equals: (15032385507/7).
	assert: (3 asFloat - (5/4)) isKindOfFloat.
	assert: 3 asFloat - (5/4) equals: 1.75 asFloat.
)
public testFractionMultiply = (
	assert: (1/3) * (1/3) equals: (1/9).
	assert: (1/3) * (2/3) equals: (2/9).

	assert: (1/3) * (2/5) equals: (2/15).
	assert: (6/9) * (1/12) equals: (1/18).

	assert: (-1/3) * (2/5) equals: (-2/15).
	assert: (1/3) * (-2/5) equals: (-2/15).
	assert: (-1/3) * (-2/5) equals: (2/15).

	assert: (1/3) * (3/4) equals: (1/4).
)
public testFractionReduced = (
	assert: (6 / 9) numerator equals: 2.
	assert: (6 / 9) denominator equals: 3.

	assert: (-6 / 9) numerator equals: -2.
	assert: (-6 / 9) denominator equals: 3.

	assert: (6 / -9) numerator equals: -2.
	assert: (6 / -9) denominator equals: 3.

	assert: (-6 / -9) numerator equals: 2.
	assert: (-6 / -9) denominator equals: 3.

	assert: (9 / 3) isKindOfInteger.
	assert: (9 / 3) numerator equals: 3.
	assert: (9 / 3) denominator equals: 1.
)
public testFractionRounded = (
	assert: (2 / 5) rounded equals: 0.
	assert: (3 / 5) rounded equals: 1.
	assert: (4 / 5) rounded equals: 1.
	assert: (5 / 5) rounded equals: 1.
	assert: (7 / 5) rounded equals: 1.
	assert: (8 / 5) rounded equals: 2.
	assert: (9 / 5) rounded equals: 2.

	assert: (-2 / 5) rounded equals: 0.
	assert: (-3 / 5) rounded equals: -1.
	assert: (-4 / 5) rounded equals: -1.
	assert: (-5 / 5) rounded equals: -1.
	assert: (-7 / 5) rounded equals: -1.
	assert: (-8 / 5) rounded equals: -2.
	assert: (-9 / 5) rounded equals: -2.

	assert: (1 / 2) rounded equals: 1.
	assert: (-1 / 2) rounded equals: -1.
)
public testFractionSubtract = (
	assert: (1/3) - (1/3) equals: 0.
	assert: (1/3) - (2/3) equals: (-1/3).

	assert: (1/3) - (2/5) equals: (-1/15).
	assert: (6/9) - (1/12) equals: (7/12).

	assert: (-1/3) - (2/5) equals: (-11/15).
	assert: (1/3) - (-2/5) equals: (11/15).
	assert: (-1/3) - (-2/5) equals: (1/15).
)
public testIsKindOfFraction = (
	deny: 'foo' isKindOfFraction.
	deny: #foo isKindOfFraction.
	deny: ('foo', 'bar') isKindOfFraction.
	assert: 1 isKindOfFraction.
	assert: (1 / 2) isKindOfFraction.
	assert: 1.5 isKindOfFraction.
	deny: 1.5 asFloat isKindOfFraction.
	deny: true isKindOfFraction.
	deny: nil isKindOfFraction.
	deny: {} isKindOfFraction.
	deny: [] isKindOfFraction.
)
) : (
TEST_CONTEXT = ()
)
public class GCTests = TestContext () (
public testFragmentation = (
	| cells new |
	cells:: Array new: 4096.
	1 to: cells size by: 2 do:
		[:index |
		 cells at: index put: Object new.
		 cells at: index + 1 put: (Array new: 64).
		 Array new: 64].

	1 to: cells size by: 2 do:
		[:index |
		 cells at: index + 1 put: nil].

	1 to: cells size by: 2 do:
		[:index |
		 cells at: index + 1 put: (Array new: 64 + 1)].
)
public testLargeAllocation = (
	| size = 1024 * 1024. |
	assert: (ByteArray new: size) size equals: size.
	assert: (ByteArray new: size) size equals: size.
	assert: (ByteArray new: size) size equals: size.
)
public testMarkStackOverflow = (
	| tree prev |
	32 timesRepeat:
		[tree:: Array new: 4096.
		 tree at: tree size put: prev.
		 prev:: tree.
		 1 to: tree size - 1 do:
			[:index |
			 tree at: index put: Object new.
			 (* Mix in garbage to avoid new-space growth. *)
			 6 timesRepeat: [Object new]]].

	prev:: nil.

	32 timesRepeat:
		[tree:: Array new: 4096.
		 tree at: 1 put: prev.
		 prev:: tree.
		 2 to: tree size do:
			[:index |
			 tree at: index put: Object new.
			 (* Mix in garbage to avoid new-space growth. *)
			 6 timesRepeat: [Object new]]].
)
public testRememberedSetOverflow = (
	| cells new |
	cells:: Array new: 4096.
	1 to: cells size do:
		[:index | cells at: index put: (Array new: 1).
		 (* Mix in garbage to avoid new-space growth while tenuring the cells. *)
		 4 timesRepeat: [Object new]].

	(* Create many old->new stores without intermediate allocations. *)
	new:: Object new.
	1 to: cells size do: [:index | (cells at: index) at: 1 put: new].
	1 to: cells size do: [:index | assert: ((cells at: index) at: 1) equals: new].
)
) : (
TEST_CONTEXT = ()
)
public class IntegerTests = TestContext () (
public testIntegerAdd = (
	(* smi + smi, mint + mint, smi + mint, mint + smi *)
	assert: minInt31 + maxInt31 equals: -1.
	assert: minInt32 + maxInt32 equals: -1.
	assert: minInt63 + maxInt63 equals: -1.
	assert: minInt64 + maxInt64 equals: -1.

	assert: maxInt31 + maxInt31 equals: 2147483646.
	assert: maxInt32 + maxInt32 equals: 4294967294.
	assert: maxInt63 + maxInt63 equals: 9223372036854775806.

	assert: minInt31 + minInt32 equals: -3221225472.
	assert: minInt32 + minInt31 equals: -3221225472.
	assert: minInt31 + minInt63 equals: -4611686019501129728.
	assert: minInt63 + minInt31 equals: -4611686019501129728.
	assert: minInt32 + minInt63 equals: -4611686020574871552.
	assert: minInt63 + minInt32 equals: -4611686020574871552.

	assert: maxInt31 + maxInt32 equals: 3221225470.
	assert: maxInt32 + maxInt31 equals: 3221225470.
	assert: maxInt31 + maxInt63 equals: 4611686019501129726.
	assert: maxInt63 + maxInt31 equals: 4611686019501129726.
	assert: maxInt32 + maxInt63 equals: 4611686020574871550.
	assert: maxInt63 + maxInt32 equals: 4611686020574871550.

	assert: minInt31 + maxInt32 equals: 1073741823.
	assert: maxInt32 + minInt31  equals: 1073741823.
	assert: minInt31 + maxInt63 equals: 4611686017353646079.
	assert: maxInt63 + minInt31 equals: 4611686017353646079.
	assert: minInt32 + maxInt63 equals: 4611686016279904255.
	assert: maxInt63 + minInt32 equals: 4611686016279904255.

	assert: maxInt31 + minInt32 equals: -1073741825.
	assert: minInt32 + maxInt31 equals: -1073741825.
	assert: maxInt31 + minInt63 equals: -4611686017353646081.
	assert: minInt63 + maxInt31 equals: -4611686017353646081.
	assert: maxInt32 + minInt63 equals: -4611686016279904257.
	assert: minInt63 + maxInt32 equals: -4611686016279904257.
)
public testIntegerAsInteger = (
	assert: -1 asInteger equals: -1.
	assert: 0 asInteger equals: 0.
	assert: 1 asInteger equals: 1.

	assert: minInt31 asInteger equals: minInt31.
	assert: minInt32 asInteger equals: minInt32.
	assert: minInt63 asInteger equals: minInt63.
	assert: minInt64 asInteger equals: minInt64.
	assert: maxInt31 asInteger equals: maxInt31.
	assert: maxInt32 asInteger equals: maxInt32.
	assert: maxInt63 asInteger equals: maxInt63.
	assert: maxInt64 asInteger equals: maxInt64.
)
public testIntegerAsStringRadix = (
	assert: (2r10010 asStringRadix: 2) equals: '10010'.
	assert: (2r10010 negated asStringRadix: 2) equals: '-10010'.
	assert: (8r765543210 asStringRadix: 8) equals: '765543210'.
	assert: (8r765543210 negated asStringRadix: 8) equals: '-765543210'.
	assert: (1234567890 asStringRadix: 10) equals: '1234567890'.
	assert: (1234567890 negated asStringRadix: 10) equals: '-1234567890'.
	assert: (16rCAFE asStringRadix: 16) equals: 'CAFE'.
	assert: (16rCAFE negated asStringRadix: 16) equals: '-CAFE'.
	assert: (36rABCXYZ asStringRadix: 36) equals: 'ABCXYZ'.
	assert: (36rABCXYZ negated asStringRadix: 36) equals: '-ABCXYZ'.

	(* Bad radix *)
	should: [0 asStringRadix: -1] signal: Error.
	should: [0 asStringRadix: 0] signal: Error.
	should: [0 asStringRadix: 1] signal: Error.
	should: [0 asStringRadix: 37] signal: Error.

	should: [0 asStringRadix: '10'] signal: Error.
	should: [0 asStringRadix: nil] signal: Error.
	should: [0 asStringRadix: false] signal: Error.
	should: [0 asStringRadix: true] signal: Error.
)
public testIntegerCeiling = (
	assert: -1 ceiling equals: -1.
	assert: 0 ceiling equals: 0.
	assert: 1 ceiling equals: 1.

	assert: minInt31 ceiling equals: minInt31.
	assert: minInt32 ceiling equals: minInt32.
	assert: minInt63 ceiling equals: minInt63.
	assert: minInt64 ceiling equals: minInt64.
	assert: maxInt31 ceiling equals: maxInt31.
	assert: maxInt32 ceiling equals: maxInt32.
	assert: maxInt63 ceiling equals: maxInt63.
	assert: maxInt64 ceiling equals: maxInt64.
)
public testIntegerComparisons = (
	deny: maxInt31 = maxInt64.
	assert: maxInt31 < maxInt64.
	deny: maxInt31 > maxInt64.
	assert: maxInt31 <= maxInt64.
	deny: maxInt31 >= maxInt64.

	deny: maxInt64 = maxInt31.
	deny: maxInt64 < maxInt31.
	assert: maxInt64 > maxInt31.
	deny: maxInt64 <= maxInt31.
	assert: maxInt64 >= maxInt31.

	deny: minInt31 = minInt64.
	deny: minInt31 < minInt64.
	assert: minInt31 > minInt64.
	deny: minInt31 <= minInt64.
	assert: minInt31 >= minInt64.

	deny: minInt64 = minInt31.
	assert: minInt64 < minInt31.
	deny: minInt64 > minInt31.
	assert: minInt64 <= minInt31.
	deny: minInt64 >= minInt31.
)
public testIntegerFloor = (
	assert: -1 floor equals: -1.
	assert: 0 floor equals: 0.
	assert: 1 floor equals: 1.

	assert: minInt31 floor equals: minInt31.
	assert: minInt32 floor equals: minInt32.
	assert: minInt63 floor equals: minInt63.
	assert: minInt64 floor equals: minInt64.
	assert: maxInt31 floor equals: maxInt31.
	assert: maxInt32 floor equals: maxInt32.
	assert: maxInt63 floor equals: maxInt63.
	assert: maxInt64 floor equals: maxInt64.
)
public testIntegerMultiply = (
	(* smi + smi, mint + mint, smi + mint, mint + smi *)
	assert: minInt31 * 1 equals: minInt31.
	assert: minInt32 * 1 equals: minInt32.
	assert: minInt63 * 1 equals: minInt63.
	assert: minInt64 * 1 equals: minInt64.
	assert: maxInt31 * 1 equals: maxInt31.
	assert: maxInt32 * 1 equals: maxInt32.
	assert: maxInt63 * 1 equals: maxInt63.
	assert: maxInt64 * 1 equals: maxInt64.

	assert: minInt31 * -1 equals: 1073741824.
	assert: minInt32 * -1 equals: 2147483648.
	assert: minInt63 * -1 equals: 4611686018427387904.
	(* big int: assert: minInt64 * -1 equals: 9223372036854775808. *)

	assert: minInt31 * maxInt31 equals: -1152921503533105152.
	assert: minInt31 * minInt31 equals: 1152921504606846976.
	assert: maxInt31 * maxInt31 equals: 1152921502459363329.

	assert: minInt32 * maxInt32 equals: -4611686016279904256.
	assert: minInt32 * minInt32 equals: 4611686018427387904.
	assert: maxInt32 * maxInt32 equals: 4611686014132420609.
)
public testIntegerParse = (
	assert: (Integer parse: '3') equals: 3.
	assert: (Integer parse: '-3') equals: -3.
	assert: (Integer parse: '0123456789') equals: 0123456789.
	assert: (Integer parse: '-0123456789') equals: -0123456789.
	assert: (Integer parse: 'CAFE' radix: 16) equals: 16rCAFE.
	assert: (Integer parse: 'cafe' radix: 16) equals: 16rCAFE.
	assert: (Integer parse: 'Z' radix: 36) equals: 35.
	assert: (Integer parse: 'z' radix: 36) equals: 35.

	2 to: 36 do: [:radix | assert: (Integer parse: '10' radix: radix) equals: radix].
	2 to: 36 do: [:radix | assert: (Integer parse: '100' radix: radix) equals: radix * radix].

	(* Last valid digit. *)
	2 to: 36 do:
		[:radix |
		assert: (Integer parse: ('123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ' copyFrom: radix - 1 to: radix - 1) radix: radix) equals: radix - 1.
		assert: (Integer parse: ('123456789abcdefghijklmnopqrstuvwxyz' copyFrom: radix - 1 to: radix - 1) radix: radix) equals: radix - 1].

	(* Digit out of range. *)
	2 to: 36 do:
		[:radix |
		should: [Integer parse: ('123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ' copyFrom: radix to: radix) radix: radix] signal: Error.
		should: [Integer parse: ('123456789abcdefghijklmnopqrstuvwxyz' copyFrom: radix to: radix) radix: radix] signal: Error].

	(* Bad radix *)
	should: [Integer parse: '0' radix: -1] signal: Error.
	should: [Integer parse: '0' radix: 0] signal: Error.
	should: [Integer parse: '0' radix: 1] signal: Error.
	should: [Integer parse: '0' radix: 37] signal: Error.

	should: [Integer parse: 'xyz'] signal: Error.
	should: [Integer parse: ''] signal: Error.
	should: [Integer parse: '--9'] signal: Error.
	should: [Integer parse: 'nan'] signal: Error.
	should: [Integer parse: 'NAN'] signal: Error.
	should: [Integer parse: 'infinity'] signal: Error.
	should: [Integer parse: '-infinity'] signal: Error.
	should: [Integer parse: 'inf'] signal: Error.
	should: [Integer parse: '-inf'] signal: Error.
	should: [Integer parse: '3.0'] signal: Error.

	should: [Integer parse: ' 3'] signal: Error.
	should: [Integer parse: '3 '] signal: Error.
)
public testIntegerRounded = (
	assert: -1 rounded equals: -1.
	assert: 0 rounded equals: 0.
	assert: 1 rounded equals: 1.

	assert: minInt31 rounded equals: minInt31.
	assert: minInt32 rounded equals: minInt32.
	assert: minInt63 rounded equals: minInt63.
	assert: minInt64 rounded equals: minInt64.
	assert: maxInt31 rounded equals: maxInt31.
	assert: maxInt32 rounded equals: maxInt32.
	assert: maxInt63 rounded equals: maxInt63.
	assert: maxInt64 rounded equals: maxInt64.
)
public testIntegerSubtract = (
	(* smi + smi, mint + mint, smi + mint, mint + smi *)
	assert: maxInt31 - minInt31 equals: 2147483647.
	assert: maxInt32 - minInt32 equals: 4294967295.
	assert: maxInt63 - minInt63 equals: 9223372036854775807.
	(* big int assert: maxInt64 - minInt64 equals: 18446744073709551615. *)

	assert: maxInt31 - maxInt31 equals: 0.
	assert: maxInt32 - maxInt32 equals: 0.
	assert: maxInt63 - maxInt63 equals: 0.

	assert: minInt31 - minInt32 equals: 1073741824.
	assert: minInt32 - minInt31 equals: -1073741824.
	assert: minInt31 - minInt63 equals: 4611686017353646080.
	assert: minInt63 - minInt31 equals: -4611686017353646080.
	assert: minInt32 - minInt63 equals: 4611686016279904256.
	assert: minInt63 - minInt32 equals: -4611686016279904256.

	assert: maxInt31 - maxInt32 equals: -1073741824.
	assert: maxInt32 - maxInt31 equals: 1073741824.
	assert: maxInt31 - maxInt63 equals: -4611686017353646080.
	assert: maxInt63 - maxInt31 equals: 4611686017353646080.
	assert: maxInt32 - maxInt63 equals: -4611686016279904256.
	assert: maxInt63 - maxInt32 equals: 4611686016279904256.

	assert: minInt31 - maxInt32 equals: -3221225471.
	assert: maxInt32 - minInt31 equals: 3221225471.
	assert: minInt31 - maxInt63 equals: -4611686019501129727.
	assert: maxInt63 - minInt31 equals: 4611686019501129727.
	assert: minInt32 - maxInt63 equals: -4611686020574871551.
	assert: maxInt63 - minInt32 equals: 4611686020574871551.

	assert: maxInt31 - minInt32 equals: 3221225471.
	assert: minInt32 - maxInt31 equals: -3221225471.
	assert: maxInt31 - minInt63 equals: 4611686019501129727.
	assert: minInt63 - maxInt31 equals: -4611686019501129727.
	assert: maxInt32 - minInt63 equals: 4611686020574871551.
	assert: minInt63 - maxInt32 equals: -4611686020574871551.
)
public testIsKindOfInteger = (
	deny: 'foo' isKindOfInteger.
	deny: #foo isKindOfInteger.
	deny: ('foo', 'bar') isKindOfInteger.
	assert: 1 isKindOfInteger.
	deny: 1.5 isKindOfInteger.
	deny: 1.5 asFloat isKindOfInteger.
	deny: true isKindOfInteger.
	deny: nil isKindOfInteger.
	deny: {} isKindOfInteger.
	deny: [] isKindOfInteger.
)
public testLargeIntegerAdd = (
	|
	a = 16rC425942592C7528C08D25976E.
	b = 16r9087475AA2733891DCA2F72AF2B.
	c = 16r1BC2B572BD48EF6C8EE227273D781.
	d = 0 - a.
	e = 0 - b.
	f = 0 - c.
	|

	assert: minInt64 + minInt64 equals: -18446744073709551616.
	assert: maxInt64 + maxInt64 equals: 18446744073709551614.
	assert: largestNegativeLargeInteger + 1 equals: -9223372036854775808.
	assert: largestNegativeLargeInteger + -1 equals: -9223372036854775810.
	assert: smallestPositiveLargeInteger + 1 equals: 9223372036854775809.
	assert: smallestPositiveLargeInteger + -1 equals: 9223372036854775807.
	assert: smallestPositiveLargeInteger + largestNegativeLargeInteger equals: -1.

	assert: a + a equals: 1942543737076956262258113720028.
	assert: b + a equals: 184182826110503236225824504432281.
	assert: c + a equals: 9009794925061437128082056516562671.
	assert: d + a equals: 0.
	assert: e + a equals: -182240282373426279963566390712253.
	assert: f + a equals: -9007852381324360171819798402842643.

	assert: a + b equals: 184182826110503236225824504432281.
	assert: b + b equals: 366423108483929516189390895144534.
	assert: c + b equals: 9192035207434863408045622907274924.
	assert: d + b equals: 182240282373426279963566390712253.
	assert: e + b equals: 0.
	assert: f + b equals: -8825612098950933891856232012130390.

	assert: a + c equals: 9009794925061437128082056516562671.
	assert: b + c equals: 9192035207434863408045622907274924.
	assert: c + c equals: 18017647306385797299901854919405314.
	assert: d + c equals: 9007852381324360171819798402842643.
	assert: e + c equals: 8825612098950933891856232012130390.
	assert: f + c equals: 0.

	assert: a + d equals: 0.
	assert: b + d equals: 182240282373426279963566390712253.
	assert: c + d equals: 9007852381324360171819798402842643.
	assert: d + d equals: -1942543737076956262258113720028.
	assert: e + d equals: -184182826110503236225824504432281.
	assert: f + d equals: -9009794925061437128082056516562671.

	assert: a + e equals: -182240282373426279963566390712253.
	assert: b + e equals: 0.
	assert: c + e equals: 8825612098950933891856232012130390.
	assert: d + e equals: -184182826110503236225824504432281.
	assert: e + e equals: -366423108483929516189390895144534.
	assert: f + e equals: -9192035207434863408045622907274924.

	assert: a + f equals: -9007852381324360171819798402842643.
	assert: b + f equals: -8825612098950933891856232012130390.
	assert: c + f equals: 0.
	assert: d + f equals: -9009794925061437128082056516562671.
	assert: e + f equals: -9192035207434863408045622907274924.
	assert: f + f equals: -18017647306385797299901854919405314.
)
public testLargeIntegerAnd = (
	|
	a = 16rFFAABBCCDDEE997766.
	b = 16rEEEEEEEEEEEEEEEE.
	c = 16rCC0011223344556677.
	d = 16r8888008888888888.
	e = 0 - a.
	f = 0 - b.
	g = 0 - c.
	h = 0 - d.
	|

	assert: (a bitAnd: a) equals: a.
	assert: (a bitAnd: b) equals: 12297866913035871846.
	assert: (a bitAnd: c) equals: 3763140576185509045862.
	assert: (a bitAnd: d) equals: 9838113972397015040.
	assert: (a bitAnd: e) equals: 2.
	assert: (a bitAnd: f) equals: 4703924523943555305730.
	assert: (a bitAnd: g) equals: 953081814671082131712.
	assert: (a bitAnd: h) equals: 4706384276884194162528.

	assert: (b bitAnd: a) equals: 12297866913035871846.
	assert: (b bitAnd: b) equals: b.
	assert: (b bitAnd: c) equals: 37530569565798.
	assert: (b bitAnd: d) equals: 9838113972397049992.
	assert: (b bitAnd: e) equals: 4919094222426376330.
	assert: (b bitAnd: f) equals: 2.
	assert: (b bitAnd: g) equals: 17216923604892682376.
	assert: (b bitAnd: h) equals: 7378847163065198184.

	assert: (c bitAnd: a) equals: 3763140576185509045862.
	assert: (c bitAnd: b) equals: 37530569565798.
	assert: (c bitAnd: c) equals: c.
	assert: (c bitAnd: d) equals: 0.
	assert: (c bitAnd: e) equals: 37529428688914.
	assert: (c bitAnd: f) equals: 3763140576184368168978.
	assert: (c bitAnd: g) equals: 1.
	assert: (c bitAnd: h) equals: 3763140613714937734768.

	assert: (d bitAnd: a) equals: 9838113972397015040.
	assert: (d bitAnd: b) equals: 9838113972397049992.
	assert: (d bitAnd: c) equals: 0.
	assert: (d bitAnd: d) equals: d.
	assert: (d bitAnd: e) equals: 34952.
	assert: (d bitAnd: f) equals: -0.
	assert: (d bitAnd: g) equals: 9838113972397049992.
	assert: (d bitAnd: h) equals: 8.

	assert: (e bitAnd: a) equals: 2.
	assert: (e bitAnd: b) equals: 4919094222426376330.
	assert: (e bitAnd: c) equals: 37529428688914.
	assert: (e bitAnd: d) equals: 34952.
	assert: (e bitAnd: e) equals: e.
	assert: (e bitAnd: f) equals: -4721141485079017553902.
	assert: (e bitAnd: g) equals: -4716222428386019866488.
	assert: (e bitAnd: h) equals: -4716222390856591212520.

	assert: (f bitAnd: a) equals: 4703924523943555305730.
	assert: (f bitAnd: b) equals: 2.
	assert: (f bitAnd: c) equals: 3763140576184368168978.
	assert: (f bitAnd: d) equals: 0.
	assert: (f bitAnd: e) equals: -4721141485079017553902.
	assert: (f bitAnd: f) equals: f.
	assert: (f bitAnd: g) equals: -3780357537319830417152.
	assert: (f bitAnd: h) equals: -17216961135462248176.

	assert: (g bitAnd: a) equals: 953081814671082131712.
	assert: (g bitAnd: b) equals: 17216923604892682376.
	assert: (g bitAnd: c) equals: 1.
	assert: (g bitAnd: d) equals: 9838113972397049992.
	assert: (g bitAnd: e) equals: -4716222428386019866488.
	assert: (g bitAnd: f) equals: -3780357537319830417152.
	assert: (g bitAnd: g) equals: g.
	assert: (g bitAnd: h) equals: -3772978727687334784760.

	assert: (h bitAnd: a) equals: 4706384276884194162528.
	assert: (h bitAnd: b) equals: 7378847163065198184.
	assert: (h bitAnd: c) equals: 3763140613714937734768.
	assert: (h bitAnd: d) equals: 8.
	assert: (h bitAnd: e) equals: -4716222390856591212520.
	assert: (h bitAnd: f) equals: -17216961135462248176.
	assert: (h bitAnd: g) equals: -3772978727687334784760.
	assert: (h bitAnd: h) equals: h.

	assert: (0 bitAnd: a) equals: 0.
	assert: (0 bitAnd: b) equals: 0.
	assert: (0 bitAnd: c) equals: 0.
	assert: (0 bitAnd: d) equals: 0.
	assert: (0 bitAnd: e) equals: 0.
	assert: (0 bitAnd: f) equals: 0.
	assert: (0 bitAnd: g) equals: 0.
	assert: (0 bitAnd: h) equals: 0.

	assert: (a bitAnd: 0) equals: 0.
	assert: (b bitAnd: 0) equals: 0.
	assert: (c bitAnd: 0) equals: 0.
	assert: (d bitAnd: 0) equals: 0.
	assert: (e bitAnd: 0) equals: 0.
	assert: (f bitAnd: 0) equals: 0.
	assert: (g bitAnd: 0) equals: 0.
	assert: (h bitAnd: 0) equals: 0.
)
public testLargeIntegerAsFloat = (
	assert: largestNegativeLargeInteger asFloat equals: (Float parse: '-9223372036854775809.0').
	assert: smallestPositiveLargeInteger asFloat equals: (Float parse: '9223372036854775808.0').

	assert: (1 << 52) asFloat equals: (Float parse: '4503599627370496.0').
	assert: (2 << 52) asFloat equals: (Float parse: '9007199254740992.0').
	assert: (3 << 52) asFloat equals: (Float parse: '13510798882111488.0').
	assert: (1 << 53) asFloat equals: (Float parse: '9007199254740992.0').
	assert: (2 << 53) asFloat equals: (Float parse: '18014398509481984.0').
	assert: (3 << 53) asFloat equals: (Float parse: '27021597764222976.0').
	assert: (1 << 54) asFloat equals: (Float parse: '18014398509481984.0').
	assert: (2 << 54) asFloat equals: (Float parse: '36028797018963970.0').
	assert: (3 << 54) asFloat equals: (Float parse: '54043195528445950.0').

	assert: (1 << 52 + 1) asFloat equals: (Float parse: '4503599627370497.0').
	assert: (2 << 52 + 1) asFloat equals: (Float parse: '9007199254740992.0').
	assert: (3 << 52 + 1) asFloat equals: (Float parse: '13510798882111488.0').
	assert: (1 << 53 + 1) asFloat equals: (Float parse: '9007199254740992.0').
	assert: (2 << 53 + 1) asFloat equals: (Float parse: '18014398509481984.0').
	assert: (3 << 53 + 1) asFloat equals: (Float parse: '27021597764222976.0').
	assert: (1 << 54 + 1) asFloat equals: (Float parse: '18014398509481984.0').
	assert: (2 << 54 + 1) asFloat equals: (Float parse: '36028797018963970.0').
	assert: (3 << 54 + 1) asFloat equals: (Float parse: '54043195528445950.0').

	assert: (1 << 52 + 2) asFloat equals: (Float parse: '4503599627370498.0').
	assert: (2 << 52 + 2) asFloat equals: (Float parse: '9007199254740994.0').
	assert: (3 << 52 + 2) asFloat equals: (Float parse: '13510798882111490.0').
	assert: (1 << 53 + 2) asFloat equals: (Float parse: '9007199254740994.0').
	assert: (2 << 53 + 2) asFloat equals: (Float parse: '18014398509481984.0').
	assert: (3 << 53 + 2) asFloat equals: (Float parse: '27021597764222976.0').
	assert: (1 << 54 + 2) asFloat equals: (Float parse: '18014398509481984.0').
	assert: (2 << 54 + 2) asFloat equals: (Float parse: '36028797018963970.0').
	assert: (3 << 54 + 2) asFloat equals: (Float parse: '54043195528445950.0').

	assert: (1 << 52 + 3) asFloat equals: (Float parse: '4503599627370499.0').
	assert: (2 << 52 + 3) asFloat equals: (Float parse: '9007199254740996.0').
	assert: (3 << 52 + 3) asFloat equals: (Float parse: '13510798882111492.0').
	assert: (1 << 53 + 3) asFloat equals: (Float parse: '9007199254740996.0').
	assert: (2 << 53 + 3) asFloat equals: (Float parse: '18014398509481988.0').
	assert: (3 << 53 + 3) asFloat equals: (Float parse: '27021597764222980.0').
	assert: (1 << 54 + 3) asFloat equals: (Float parse: '18014398509481988.0').
	assert: (2 << 54 + 3) asFloat equals: (Float parse: '36028797018963970.0').
	assert: (3 << 54 + 3) asFloat equals: (Float parse: '54043195528445950.0').

	assert: (16rABABABABABABABAB << 1) asFloat equals: (Float parse: '24740339110622220000.0').
	assert: (16rABABABABABABABAB << 32) asFloat equals: (Float parse: '5.312947368603608e+28').
	assert: (16rABABABABABABABAB << 64) asFloat equals: (Float parse: '2.2818935193521754e+38').
	assert: (16rABABABABABABABAB << 512) asFloat equals: (Float parse: '1.658568574584348e+173').
	assert: (16rABABABABABABABAB << 1024) asFloat equals: (Float parse: 'Infinity').

	assert: (((1 << 53) - 1) << (1023 - 52)) asFloat equals: (Float parse: '1.7976931348623157e+308').
	assert: ((1 << 53) << (1023 - 52)) asFloat equals: (Float parse: 'Infinity').
)
public testLargeIntegerAsString = (
	assert: largestNegativeLargeInteger asString equals: '-9223372036854775809'.
	assert: smallestPositiveLargeInteger asString equals: '9223372036854775808'.

	assert: 16rFFFFFFFFFFFFFFFF asString equals: '18446744073709551615'.
	assert: 16rABCDABCDABCDABCD asString equals: '12379739850550389709'.
	assert: -9999999999999999999 asString equals: '-9999999999999999999'.
)
public testLargeIntegerComparisions = (
	assert: smallestPositiveLargeInteger = smallestPositiveLargeInteger.
	deny: smallestPositiveLargeInteger < smallestPositiveLargeInteger.
	deny: smallestPositiveLargeInteger > smallestPositiveLargeInteger.
	assert: smallestPositiveLargeInteger <= smallestPositiveLargeInteger.
	assert: smallestPositiveLargeInteger >= smallestPositiveLargeInteger.

	assert: largestNegativeLargeInteger = largestNegativeLargeInteger.
	deny: largestNegativeLargeInteger < largestNegativeLargeInteger.
	deny: largestNegativeLargeInteger > largestNegativeLargeInteger.
	assert: largestNegativeLargeInteger <= largestNegativeLargeInteger.
	assert: largestNegativeLargeInteger >= largestNegativeLargeInteger.

	deny: smallestPositiveLargeInteger = largestNegativeLargeInteger.
	deny: smallestPositiveLargeInteger < largestNegativeLargeInteger.
	assert: smallestPositiveLargeInteger > largestNegativeLargeInteger.
	deny: smallestPositiveLargeInteger <= largestNegativeLargeInteger.
	assert: smallestPositiveLargeInteger >= largestNegativeLargeInteger.

	deny: largestNegativeLargeInteger = smallestPositiveLargeInteger.
	assert: largestNegativeLargeInteger < smallestPositiveLargeInteger.
	deny: largestNegativeLargeInteger > smallestPositiveLargeInteger.
	assert: largestNegativeLargeInteger <= smallestPositiveLargeInteger.
	deny: largestNegativeLargeInteger >= smallestPositiveLargeInteger.

	deny: smallestPositiveLargeInteger = 0.
	deny: smallestPositiveLargeInteger < 0.
	assert: smallestPositiveLargeInteger > 0.
	deny: smallestPositiveLargeInteger <= 0.
	assert: smallestPositiveLargeInteger >= 0.

	deny: 0 = smallestPositiveLargeInteger.
	assert: 0 < smallestPositiveLargeInteger.
	deny: 0 > smallestPositiveLargeInteger.
	assert: 0 <= smallestPositiveLargeInteger.
	deny: 0 >= smallestPositiveLargeInteger.

	deny: largestNegativeLargeInteger = 0.
	assert: largestNegativeLargeInteger < 0.
	deny: largestNegativeLargeInteger > 0.
	assert: largestNegativeLargeInteger <= 0.
	deny: largestNegativeLargeInteger >= 0.

	deny: 0 = largestNegativeLargeInteger.
	deny: 0 < largestNegativeLargeInteger.
	assert: 0 > largestNegativeLargeInteger.
	deny: 0 <= largestNegativeLargeInteger.
	assert: 0 >= largestNegativeLargeInteger.

	deny: smallestPositiveLargeInteger = maxInt64.
	deny: smallestPositiveLargeInteger < maxInt64.
	assert: smallestPositiveLargeInteger > maxInt64.
	deny: smallestPositiveLargeInteger <= maxInt64.
	assert: smallestPositiveLargeInteger >= maxInt64.

	deny: maxInt64 = smallestPositiveLargeInteger.
	assert: maxInt64 < smallestPositiveLargeInteger.
	deny: maxInt64 > smallestPositiveLargeInteger.
	assert: maxInt64 <= smallestPositiveLargeInteger.
	deny: maxInt64 >= smallestPositiveLargeInteger.

	deny: largestNegativeLargeInteger = minInt64.
	assert: largestNegativeLargeInteger < minInt64.
	deny: largestNegativeLargeInteger > minInt64.
	assert: largestNegativeLargeInteger <= minInt64.
	deny: largestNegativeLargeInteger >= minInt64.

	deny: minInt64 = largestNegativeLargeInteger.
	deny: minInt64 < largestNegativeLargeInteger.
	assert: minInt64 > largestNegativeLargeInteger.
	deny: minInt64 <= largestNegativeLargeInteger.
	assert: minInt64 >= largestNegativeLargeInteger.

	(* Difference at middle digit. *)
	deny: 16rFFFFAAAAFFFFFFFF = 16rFFFFBBBBFFFFFFFF.
	assert: 16rFFFFAAAAFFFFFFFF < 16rFFFFBBBBFFFFFFFF.
	deny: 16rFFFFAAAAFFFFFFFF > 16rFFFFBBBBFFFFFFFF.
	assert: 16rFFFFAAAAFFFFFFFF <= 16rFFFFBBBBFFFFFFFF.
	deny: 16rFFFFAAAAFFFFFFFF >= 16rFFFFBBBBFFFFFFFF.

	deny: 16rFFFFBBBBFFFFFFFF = 16rFFFFAAAAFFFFFFFF.
	deny: 16rFFFFBBBBFFFFFFFF < 16rFFFFAAAAFFFFFFFF.
	assert: 16rFFFFBBBBFFFFFFFF > 16rFFFFAAAAFFFFFFFF.
	deny: 16rFFFFBBBBFFFFFFFF <= 16rFFFFAAAAFFFFFFFF.
	assert: 16rFFFFBBBBFFFFFFFF >= 16rFFFFAAAAFFFFFFFF.

	(* Difference at last digit. *)
	deny: 16rFFFFFFFFFFFFFFFA = 16rFFFFFFFFFFFFFFFB.
	assert: 16rFFFFFFFFFFFFFFFA < 16rFFFFFFFFFFFFFFFB.
	deny: 16rFFFFFFFFFFFFFFFA > 16rFFFFFFFFFFFFFFFB.
	assert: 16rFFFFFFFFFFFFFFFA <= 16rFFFFFFFFFFFFFFFB.
	deny: 16rFFFFFFFFFFFFFFFA >= 16rFFFFFFFFFFFFFFFB.

	deny: 16rFFFFFFFFFFFFFFFB = 16rFFFFFFFFFFFFFFFA.
	deny: 16rFFFFFFFFFFFFFFFB < 16rFFFFFFFFFFFFFFFA.
	assert: 16rFFFFFFFFFFFFFFFB > 16rFFFFFFFFFFFFFFFA.
	deny: 16rFFFFFFFFFFFFFFFB <= 16rFFFFFFFFFFFFFFFA.
	assert: 16rFFFFFFFFFFFFFFFB >= 16rFFFFFFFFFFFFFFFA.

	(* Different number of digits. *)
	deny: 16rFFFFFFFFFFFFFFFF = 16rFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF.
	assert: 16rFFFFFFFFFFFFFFFF < 16rFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF.
	deny: 16rFFFFFFFFFFFFFFFF > 16rFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF.
	assert: 16rFFFFFFFFFFFFFFFF <= 16rFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF.
	deny: 16rFFFFFFFFFFFFFFFF >= 16rFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF.

	deny: 16rFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF = 16rFFFFFFFFFFFFFFFF.
	deny: 16rFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF < 16rFFFFFFFFFFFFFFFF.
	assert: 16rFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF > 16rFFFFFFFFFFFFFFFF.
	deny: 16rFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF <= 16rFFFFFFFFFFFFFFFF.
	assert: 16rFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF >= 16rFFFFFFFFFFFFFFFF.
)
public testLargeIntegerDiv = (
	|
	a = 16rC425942592C7528C08D25976E.
	b = 16r9087475AA2733891DCA2F72AF2B.
	c = 16r1BC2B572BD48EF6C8EE227273D781.
	d = 0 - a.
	e = 0 - b.
	f = 0 - c.
	|

	assert: a // 1 equals: a.
	assert: b // 1 equals: b.
	assert: c // 1 equals: c.
	assert: d // 1 equals: d.
	assert: e // 1 equals: e.
	assert: f // 1 equals: f.

	assert: a // -1 equals: 0 - a.
	assert: b // -1 equals: 0 - b.
	assert: c // -1 equals: 0 - c.
	assert: d // -1 equals: 0 - d.
	assert: e // -1 equals: 0 - e.
	assert: f // -1 equals: 0 - f.

	assert: a // 254 equals: 3823904994245976894208885275.
	assert: b // 254 equals: 721305331661278575175966329024.
	assert: c // 254 equals: 35467809658239758464373730156309.
	assert: d // 254 equals: -3823904994245976894208885276.
	assert: e // 254 equals: -721305331661278575175966329025.
	assert: f // 254 equals: -35467809658239758464373730156310.

	assert: a // 255 equals: 3808909288386188749525713176.
	assert: b // 255 equals: 718476683301822580763511559106.
	assert: c // 255 equals: 35328720208599602548827166508637.
	assert: d // 255 equals: -3808909288386188749525713177.
	assert: e // 255 equals: -718476683301822580763511559107.
	assert: f // 255 equals: -35328720208599602548827166508638.

	assert: a // 256 equals: 3794030736478430199722878359.
	assert: b // 256 equals: 715670133757674836307404092079.
	assert: c // 256 equals: 35190717395284760351370810389463.
	assert: d // 256 equals: -3794030736478430199722878360.
	assert: e // 256 equals: -715670133757674836307404092080.
	assert: f // 256 equals: -35190717395284760351370810389464.

	assert: a // -254 equals: -3823904994245976894208885276.
	assert: b // -254 equals: -721305331661278575175966329025.
	assert: c // -254 equals: -35467809658239758464373730156310.
	assert: d // -254 equals: 3823904994245976894208885275.
	assert: e // -254 equals: 721305331661278575175966329024.
	assert: f // -254 equals: 35467809658239758464373730156309.

	assert: a // -255 equals: -3808909288386188749525713177.
	assert: b // -255 equals: -718476683301822580763511559107.
	assert: c // -255 equals: -35328720208599602548827166508638.
	assert: d // -255 equals: 3808909288386188749525713176.
	assert: e // -255 equals: 718476683301822580763511559106.
	assert: f // -255 equals: 35328720208599602548827166508637.

	assert: a // -256 equals: -3794030736478430199722878360.
	assert: b // -256 equals: -715670133757674836307404092080.
	assert: c // -256 equals: -35190717395284760351370810389464.
	assert: d // -256 equals: 3794030736478430199722878359.
	assert: e // -256 equals: 715670133757674836307404092079.
	assert: f // -256 equals: 35190717395284760351370810389463.

	assert: a // a equals: 1.
	assert: b // a equals: 188.
	assert: c // a equals: 9275.
	assert: d // a equals: -1.
	assert: e // a equals: -189.
	assert: f // a equals: -9276.

	assert: a // b equals: 0.
	assert: b // b equals: 1.
	assert: c // b equals: 49.
	assert: d // b equals: -1.
	assert: e // b equals: -1.
	assert: f // b equals: -50.

	assert: a // c equals: 0.
	assert: b // c equals: 0.
	assert: c // c equals: 1.
	assert: d // c equals: -1.
	assert: e // c equals: -1.
	assert: f // c equals: -1.

	assert: a // d equals: -1.
	assert: b // d equals: -189.
	assert: c // d equals: -9276.
	assert: d // d equals: 1.
	assert: e // d equals: 188.
	assert: f // d equals: 9275.

	assert: a // e equals: -1.
	assert: b // e equals: -1.
	assert: c // e equals: -50.
	assert: d // e equals: 0.
	assert: e // e equals: 1.
	assert: f // e equals: 49.

	assert: a // f equals: -1.
	assert: b // f equals: -1.
	assert: c // f equals: -1.
	assert: d // f equals: 0.
	assert: e // f equals: 0.
	assert: f // f equals: 1.

	should: [a // 0] signal: Error.
	should: [b // 0] signal: Error.
	should: [c // 0] signal: Error.
	should: [d // 0] signal: Error.
	should: [e // 0] signal: Error.
	should: [f // 0] signal: Error.

	assert: 0 // a equals: 0.
	assert: 0 // b equals: 0.
	assert: 0 // c equals: 0.
	assert: 0 // d equals: 0.
	assert: 0 // e equals: 0.
	assert: 0 // f equals: 0.
)
public testLargeIntegerDivide = (
	|
	a = 16rC425942592C7528C08D25976E.
	b = 16r9087475AA2733891DCA2F72AF2B.
	c = 16r1BC2B572BD48EF6C8EE227273D781.
	d = 0 - a.
	e = 0 - b.
	f = 0 - c.
	|

	assert: a / 1 equals: a.
	assert: b / 1 equals: b.
	assert: c / 1 equals: c.
	assert: d / 1 equals: d.
	assert: e / 1 equals: e.
	assert: f / 1 equals: f.

	assert: a / -1 equals: 0 - a.
	assert: b / -1 equals: 0 - b.
	assert: c / -1 equals: 0 - c.
	assert: d / -1 equals: 0 - d.
	assert: e / -1 equals: 0 - e.
	assert: f / -1 equals: 0 - f.

	assert: a / 254 > 0.  deny: (a / 254) isKindOfInteger.
	assert: b / 254 > 0.  deny: (b / 254) isKindOfInteger.
	assert: c / 254 > 0.  deny: (c / 254) isKindOfInteger.
	assert: d / 254 < 0.  deny: (d / 254) isKindOfInteger.
	assert: e / 254 < 0.  deny: (e / 254) isKindOfInteger.
	assert: f / 254 < 0.  deny: (f / 254) isKindOfInteger.

	assert: a / 255 > 0.  deny: (a / 255) isKindOfInteger.
	assert: b / 255 > 0.  deny: (b / 255) isKindOfInteger.
	assert: c / 255 > 0.  deny: (c / 255) isKindOfInteger.
	assert: d / 255 < 0.  deny: (d / 255) isKindOfInteger.
	assert: e / 255 < 0.  deny: (e / 255) isKindOfInteger.
	assert: f / 255 < 0.  deny: (f / 255) isKindOfInteger.

	assert: a / 256 > 0.  deny: (a / 256) isKindOfInteger.
	assert: b / 256 > 0.  deny: (b / 256) isKindOfInteger.
	assert: c / 256 > 0.  deny: (c / 256) isKindOfInteger.
	assert: d / 256 < 0.  deny: (d / 256) isKindOfInteger.
	assert: e / 256 < 0.  deny: (e / 256) isKindOfInteger.
	assert: f / 256 < 0.  deny: (f / 256) isKindOfInteger.

	assert: a / -254 < 0.  deny: (a / -254) isKindOfInteger.
	assert: b / -254 < 0.  deny: (b / -254) isKindOfInteger.
	assert: c / -254 < 0.  deny: (c / -254) isKindOfInteger.
	assert: d / -254 > 0.  deny: (d / -254) isKindOfInteger.
	assert: e / -254 > 0.  deny: (e / -254) isKindOfInteger.
	assert: f / -254 > 0.  deny: (f / -254) isKindOfInteger.

	assert: a / -255 < 0.  deny: (a / -255) isKindOfInteger.
	assert: b / -255 < 0.  deny: (b / -255) isKindOfInteger.
	assert: c / -255 < 0.  deny: (c / -255) isKindOfInteger.
	assert: d / -255 > 0.  deny: (d / -255) isKindOfInteger.
	assert: e / -255 > 0.  deny: (e / -255) isKindOfInteger.
	assert: f / -255 > 0.  deny: (f / -255) isKindOfInteger.

	assert: a / -256 < 0.  deny: (a / -256) isKindOfInteger.
	assert: b / -256 < 0.  deny: (b / -256) isKindOfInteger.
	assert: c / -256 < 0.  deny: (c / -256) isKindOfInteger.
	assert: d / -256 > 0.  deny: (d / -256) isKindOfInteger.
	assert: e / -256 > 0.  deny: (e / -256) isKindOfInteger.
	assert: f / -256 > 0.  deny: (f / -256) isKindOfInteger.

	assert: a / a equals: 1.
	assert: b / a > 0.  deny: (b / a) isKindOfInteger.
	assert: c / a > 0.  deny: (c / a) isKindOfInteger.
	assert: d / a equals: -1.
	assert: e / a < 0.  deny: (e / a) isKindOfInteger.
	assert: f / a < 0.  deny: (f / a) isKindOfInteger.

	assert: a / b > 0.  deny: (a / b) isKindOfInteger.
	assert: b / b equals: 1.
	assert: c / b > 0.  deny: (c / b) isKindOfInteger.
	assert: d / b < 0.  deny: (d / b) isKindOfInteger.
	assert: e / b equals: -1.
	assert: f / b < 0.  deny: (f / b) isKindOfInteger.

	assert: a / c > 0.  deny: (a / c) isKindOfInteger.
	assert: b / c > 0.  deny: (b / c) isKindOfInteger.
	assert: c / c equals: 1.
	assert: d / c < 0.  deny: (d / c) isKindOfInteger.
	assert: e / c < 0.  deny: (e / c) isKindOfInteger.
	assert: f / c equals: -1.

	assert: a / d equals: -1.
	assert: b / d < 0.  deny: (b / d) isKindOfInteger.
	assert: c / d < 0.  deny: (c / d) isKindOfInteger.
	assert: d / d equals: 1.
	assert: e / d > 0.  deny: (e / d) isKindOfInteger.
	assert: f / d > 0.  deny: (f / d) isKindOfInteger.

	assert: a / e < 0.  deny: (a / e) isKindOfInteger.
	assert: b / e equals: -1.
	assert: c / e < 0.  deny: (c / e) isKindOfInteger.
	assert: d / e > 0.  deny: (d / e) isKindOfInteger.
	assert: e / e equals: 1.
	assert: f / e > 0.  deny: (f / e) isKindOfInteger.

	assert: a / f < 0.  deny: (a / f) isKindOfInteger.
	assert: b / f < 0.  deny: (b / f) isKindOfInteger.
	assert: c / f equals: -1.
	assert: d / f > 0.  deny: (d / f) isKindOfInteger.
	assert: e / f > 0.  deny: (e / f) isKindOfInteger.
	assert: f / f equals: 1.

	assert: a * a / a equals: a.
	assert: a * f / a equals: f.
	assert: a * f / f equals: a.
	assert: f * f / f equals: f.

	assert: b * b / b equals: b.
	assert: b * e / b equals: e.
	assert: b * e / e equals: b.
	assert: e * e / e equals: e.

	assert: c * c / c equals: c.
	assert: c * d / c equals: d.
	assert: c * d / d equals: c.
	assert: d * d / d equals: d.

	should: [a / 0] signal: Error.
	should: [b / 0] signal: Error.
	should: [c / 0] signal: Error.
	should: [d / 0] signal: Error.
	should: [e / 0] signal: Error.
	should: [f / 0] signal: Error.

	assert: 0 / a equals: 0.
	assert: 0 / b equals: 0.
	assert: 0 / c equals: 0.
	assert: 0 / d equals: 0.
	assert: 0 / e equals: 0.
	assert: 0 / f equals: 0.
)
public testLargeIntegerInvert = (
	assert: largestNegativeLargeInteger bitInvert equals: smallestPositiveLargeInteger.
	assert: smallestPositiveLargeInteger bitInvert equals: largestNegativeLargeInteger.
	assert: 16rFFFFFFFFFFFFFFFF bitInvert equals: -18446744073709551616.
	assert: 16rFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF bitInvert equals: -340282366920938463463374607431768211456.
	assert: -18446744073709551616 bitInvert equals: 16rFFFFFFFFFFFFFFFF.
	assert: -340282366920938463463374607431768211456 bitInvert equals: 16rFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF.
)
public testLargeIntegerMod = (
	|
	a = 16rC425942592C7528C08D25976E.
	b = 16r9087475AA2733891DCA2F72AF2B.
	c = 16r1BC2B572BD48EF6C8EE227273D781.
	d = 0 - a.
	e = 0 - b.
	f = 0 - c.
	|

	assert: a \\ 1 equals: 0.
	assert: b \\ 1 equals: 0.
	assert: c \\ 1 equals: 0.
	assert: d \\ 1 equals: 0.
	assert: e \\ 1 equals: 0.
	assert: f \\ 1 equals: 0.

	assert: a \\ -1 equals: 0.
	assert: b \\ -1 equals: 0.
	assert: c \\ -1 equals: 0.
	assert: d \\ -1 equals: 0.
	assert: e \\ -1 equals: 0.
	assert: f \\ -1 equals: 0.

	assert: a \\ 254 equals: 164.
	assert: b \\ 254 equals: 171.
	assert: c \\ 254 equals: 171.
	assert: d \\ 254 equals: 90.
	assert: e \\ 254 equals: 83.
	assert: f \\ 254 equals: 83.

	assert: a \\ 255 equals: 134.
	assert: b \\ 255 equals: 237.
	assert: c \\ 255 equals: 222.
	assert: d \\ 255 equals: 121.
	assert: e \\ 255 equals: 18.
	assert: f \\ 255 equals: 33.

	assert: a \\ 256 equals: 110.
	assert: b \\ 256 equals: 43.
	assert: c \\ 256 equals: 129.
	assert: d \\ 256 equals: 146.
	assert: e \\ 256 equals: 213.
	assert: f \\ 256 equals: 127.

	assert: a \\ -254 equals: -90.
	assert: b \\ -254 equals: -83.
	assert: c \\ -254 equals: -83.
	assert: d \\ -254 equals: -164.
	assert: e \\ -254 equals: -171.
	assert: f \\ -254 equals: -171.

	assert: a \\ -255 equals: -121.
	assert: b \\ -255 equals: -18.
	assert: c \\ -255 equals: -33.
	assert: d \\ -255 equals: -134.
	assert: e \\ -255 equals: -237.
	assert: f \\ -255 equals: -222.

	assert: a \\ -256 equals: -146.
	assert: b \\ -256 equals: -213.
	assert: c \\ -256 equals: -127.
	assert: d \\ -256 equals: -110.
	assert: e \\ -256 equals: -43.
	assert: f \\ -256 equals: -129.

	assert: a \\ a equals: 0.
	assert: b \\ a equals: 612442956730869442432757889635.
	assert: c \\ a equals: 277072498513983728925083072807.
	assert: d \\ a equals: 0.
	assert: e \\ a equals: 358828911807608688696298970379.
	assert: f \\ a equals: 694199370024494402203973787207.

	assert: a \\ b equals: 971271868538478131129056860014.
	assert: b \\ b equals: 0.
	assert: c \\ b equals: 31457495336625503310850528661574.
	assert: d \\ b equals: 182240282373426279963566390712253.
	assert: e \\ b equals: 0.
	assert: f \\ b equals: 151754058905339254783844918910693.

	assert: a \\ c equals: a.
	assert: b \\ c equals: b.
	assert: c \\ c equals: 0.
	assert: d \\ c equals: 9007852381324360171819798402842643.
	assert: e \\ c equals: 8825612098950933891856232012130390.
	assert: f \\ c equals: 0.

	assert: a \\ d equals: 0.
	assert: b \\ d equals: -358828911807608688696298970379.
	assert: c \\ d equals: -694199370024494402203973787207.
	assert: d \\ d equals: 0.
	assert: e \\ d equals: -612442956730869442432757889635.
	assert: f \\ d equals: -277072498513983728925083072807.

	assert: a \\ e equals: -182240282373426279963566390712253.
	assert: b \\ e equals: 0.
	assert: c \\ e equals: -151754058905339254783844918910693.
	assert: d \\ e equals: -971271868538478131129056860014.
	assert: e \\ e equals: 0.
	assert: f \\ e equals: -31457495336625503310850528661574.

	assert: a \\ f equals: -9007852381324360171819798402842643.
	assert: b \\ f equals: -8825612098950933891856232012130390.
	assert: c \\ f equals: 0.
	assert: d \\ f equals: d.
	assert: e \\ f equals: e.
	assert: f \\ f equals: 0.

	should: [a \\ 0] signal: Error.
	should: [b \\ 0] signal: Error.
	should: [c \\ 0] signal: Error.
	should: [d \\ 0] signal: Error.
	should: [e \\ 0] signal: Error.
	should: [f \\ 0] signal: Error.

	assert: 0 \\ a equals: 0.
	assert: 0 \\ b equals: 0.
	assert: 0 \\ c equals: 0.
	assert: 0 \\ d equals: 0.
	assert: 0 \\ e equals: 0.
	assert: 0 \\ f equals: 0.
)
public testLargeIntegerOr = (
	|
	a = 16rFFAABBCCDDEE997766.
	b = 16rEEEEEEEEEEEEEEEE.
	c = 16rCC0011223344556677.
	d = 16r8888008888888888.
	e = 0 - a.
	f = 0 - b.
	g = 0 - c.
	h = 0 - d.
	|

	assert: (a bitOr: a) equals: a.
	assert: (a bitOr: b) equals: 4721141485079017553902.
	assert: (a bitOr: c) equals: 4716222428386019866487.
	assert: (a bitOr: d) equals: 4716222390856591212526.
	assert: (a bitOr: e) equals: -2.
	assert: (a bitOr: f) equals: -4919094222426376330.
	assert: (a bitOr: g) equals: -37529428688913.
	assert: (a bitOr: h) equals: -34946.

	assert: (b bitOr: a) equals: 4721141485079017553902.
	assert: (b bitOr: b) equals: b.
	assert: (b bitOr: c) equals: 3780357537319830417151.
	assert: (b bitOr: d) equals: 17216961135462248174.
	assert: (b bitOr: e) equals: -4703924523943555305730.
	assert: (b bitOr: f) equals: -2.
	assert: (b bitOr: g) equals: -3763140576184368168977.
	assert: (b bitOr: h) equals: -2.

	assert: (c bitOr: a) equals: 4716222428386019866487.
	assert: (c bitOr: b) equals: 3780357537319830417151.
	assert: (c bitOr: c) equals: c.
	assert: (c bitOr: d) equals: 3772978727687334784767.
	assert: (c bitOr: e) equals: -953081814671082131713.
	assert: (c bitOr: f) equals: -17216923604892682377.
	assert: (c bitOr: g) equals: -1.
	assert: (c bitOr: h) equals: -9838113972397049985.

	assert: (d bitOr: a) equals: 4716222390856591212526.
	assert: (d bitOr: b) equals: 17216961135462248174.
	assert: (d bitOr: c) equals: 3772978727687334784767.
	assert: (d bitOr: d) equals: d.
	assert: (d bitOr: e) equals: -4706384276884194162534.
	assert: (d bitOr: f) equals: -7378847163065198182.
	assert: (d bitOr: g) equals: -3763140613714937734775.
	assert: (d bitOr: h) equals: -8.

	assert: (e bitOr: a) equals: -2.
	assert: (e bitOr: b) equals: -4703924523943555305730.
	assert: (e bitOr: c) equals: -953081814671082131713.
	assert: (e bitOr: d) equals: -4706384276884194162534.
	assert: (e bitOr: e) equals: e.
	assert: (e bitOr: f) equals: -12297866913035871846.
	assert: (e bitOr: g) equals: -3763140576185509045861.
	assert: (e bitOr: h) equals: -9838113972397015046.

	assert: (f bitOr: a) equals: -4919094222426376330.
	assert: (f bitOr: b) equals: -2.
	assert: (f bitOr: c) equals: -17216923604892682377.
	assert: (f bitOr: d) equals: -7378847163065198182.
	assert: (f bitOr: e) equals: -12297866913035871846.
	assert: (f bitOr: f) equals: f.
	assert: (f bitOr: g) equals: -37530569565797.
	assert: (f bitOr: h) equals: -9838113972397049990.

	assert: (g bitOr: a) equals: -37529428688913.
	assert: (g bitOr: b) equals: -3763140576184368168977.
	assert: (g bitOr: c) equals: -1.
	assert: (g bitOr: d) equals: -3763140613714937734775.
	assert: (g bitOr: e) equals: -3763140576185509045861.
	assert: (g bitOr: f) equals: -37530569565797.
	assert: (g bitOr: g) equals: g.
	assert: (g bitOr: h) equals: -7.

	assert: (h bitOr: a) equals: -34946.
	assert: (h bitOr: b) equals: -2.
	assert: (h bitOr: c) equals: -9838113972397049985.
	assert: (h bitOr: d) equals: -8.
	assert: (h bitOr: e) equals: -9838113972397015046.
	assert: (h bitOr: f) equals: -9838113972397049990.
	assert: (h bitOr: g) equals: -7.
	assert: (h bitOr: h) equals: h.

	assert: (0 bitOr: a) equals: a.
	assert: (0 bitOr: b) equals: b.
	assert: (0 bitOr: c) equals: c.
	assert: (0 bitOr: d) equals: d.
	assert: (0 bitOr: e) equals: e.
	assert: (0 bitOr: f) equals: f.
	assert: (0 bitOr: g) equals: g.
	assert: (0 bitOr: h) equals: h.

	assert: (a bitOr: 0) equals: a.
	assert: (b bitOr: 0) equals: b.
	assert: (c bitOr: 0) equals: c.
	assert: (d bitOr: 0) equals: d.
	assert: (e bitOr: 0) equals: e.
	assert: (f bitOr: 0) equals: f.
	assert: (g bitOr: 0) equals: g.
	assert: (h bitOr: 0) equals: h.
)
public testLargeIntegerParse = (
	assert: (Integer parse: '-9223372036854775809') equals: largestNegativeLargeInteger.
	assert: (Integer parse: '9223372036854775808') equals: smallestPositiveLargeInteger.

	assert: (Integer parse: 'FFFFFFFFFFFFFFFF' radix: 16) equals: 16rFFFFFFFFFFFFFFFF.
	assert: (Integer parse: 'ABCDABCDABCDABCD' radix: 16) equals: 16rABCDABCDABCDABCD.
	assert: (Integer parse: '-9999999999999999999') equals: -9999999999999999999.
)
public testLargeIntegerQuo = (
	|
	a = 16rC425942592C7528C08D25976E.
	b = 16r9087475AA2733891DCA2F72AF2B.
	c = 16r1BC2B572BD48EF6C8EE227273D781.
	d = 0 - a.
	e = 0 - b.
	f = 0 - c.
	|

	assert: (a quo: 1) equals: a.
	assert: (b quo: 1) equals: b.
	assert: (c quo: 1) equals: c.
	assert: (d quo: 1) equals: d.
	assert: (e quo: 1) equals: e.
	assert: (f quo: 1) equals: f.

	assert: (a quo: -1) equals: 0 - a.
	assert: (b quo: -1) equals: 0 - b.
	assert: (c quo: -1) equals: 0 - c.
	assert: (d quo: -1) equals: 0 - d.
	assert: (e quo: -1) equals: 0 - e.
	assert: (f quo: -1) equals: 0 - f.

	assert: (a quo: 254) equals: 3823904994245976894208885275.
	assert: (b quo: 254) equals: 721305331661278575175966329024.
	assert: (c quo: 254) equals: 35467809658239758464373730156309.
	assert: (d quo: 254) equals: -3823904994245976894208885275.
	assert: (e quo: 254) equals: -721305331661278575175966329024.
	assert: (f quo: 254) equals: -35467809658239758464373730156309.

	assert: (a quo: 255) equals: 3808909288386188749525713176.
	assert: (b quo: 255) equals: 718476683301822580763511559106.
	assert: (c quo: 255) equals: 35328720208599602548827166508637.
	assert: (d quo: 255) equals: -3808909288386188749525713176.
	assert: (e quo: 255) equals: -718476683301822580763511559106.
	assert: (f quo: 255) equals: -35328720208599602548827166508637.

	assert: (a quo: 256) equals: 3794030736478430199722878359.
	assert: (b quo: 256) equals: 715670133757674836307404092079.
	assert: (c quo: 256) equals: 35190717395284760351370810389463.
	assert: (d quo: 256) equals: -3794030736478430199722878359.
	assert: (e quo: 256) equals: -715670133757674836307404092079.
	assert: (f quo: 256) equals: -35190717395284760351370810389463.

	assert: (a quo: -254) equals: -3823904994245976894208885275.
	assert: (b quo: -254) equals: -721305331661278575175966329024.
	assert: (c quo: -254) equals: -35467809658239758464373730156309.
	assert: (d quo: -254) equals: 3823904994245976894208885275.
	assert: (e quo: -254) equals: 721305331661278575175966329024.
	assert: (f quo: -254) equals: 35467809658239758464373730156309.

	assert: (a quo: -255) equals: -3808909288386188749525713176.
	assert: (b quo: -255) equals: -718476683301822580763511559106.
	assert: (c quo: -255) equals: -35328720208599602548827166508637.
	assert: (d quo: -255) equals: 3808909288386188749525713176.
	assert: (e quo: -255) equals: 718476683301822580763511559106.
	assert: (f quo: -255) equals: 35328720208599602548827166508637.

	assert: (a quo: -256) equals: -3794030736478430199722878359.
	assert: (b quo: -256) equals: -715670133757674836307404092079.
	assert: (c quo: -256) equals: -35190717395284760351370810389463.
	assert: (d quo: -256) equals: 3794030736478430199722878359.
	assert: (e quo: -256) equals: 715670133757674836307404092079.
	assert: (f quo: -256) equals: 35190717395284760351370810389463.

	assert: (a quo: a) equals: 1.
	assert: (b quo: a) equals: 188.
	assert: (c quo: a) equals: 9275.
	assert: (d quo: a) equals: -1.
	assert: (e quo: a) equals: -188.
	assert: (f quo: a) equals: -9275.

	assert: (a quo: b) equals: 0.
	assert: (b quo: b) equals: 1.
	assert: (c quo: b) equals: 49.
	assert: (d quo: b) equals: 0.
	assert: (e quo: b) equals: -1.
	assert: (f quo: b) equals: -49.

	assert: (a quo: c) equals: 0.
	assert: (b quo: c) equals: 0.
	assert: (c quo: c) equals: 1.
	assert: (d quo: c) equals: 0.
	assert: (e quo: c) equals: 0.
	assert: (f quo: c) equals: -1.

	assert: (a quo: d) equals: -1.
	assert: (b quo: d) equals: -188.
	assert: (c quo: d) equals: -9275.
	assert: (d quo: d) equals: 1.
	assert: (e quo: d) equals: 188.
	assert: (f quo: d) equals: 9275.

	assert: (a quo: e) equals: 0.
	assert: (b quo: e) equals: -1.
	assert: (c quo: e) equals: -49.
	assert: (d quo: e) equals: 0.
	assert: (e quo: e) equals: 1.
	assert: (f quo: e) equals: 49.

	assert: (a quo: f) equals: 0.
	assert: (b quo: f) equals: 0.
	assert: (c quo: f) equals: -1.
	assert: (d quo: f) equals: 0.
	assert: (e quo: f) equals: 0.
	assert: (f quo: f) equals: 1.

	should: [a quo: 0] signal: Error.
	should: [b quo: 0] signal: Error.
	should: [c quo: 0] signal: Error.
	should: [d quo: 0] signal: Error.
	should: [e quo: 0] signal: Error.
	should: [f quo: 0] signal: Error.

	assert: (0 quo: a) equals: 0.
	assert: (0 quo: b) equals: 0.
	assert: (0 quo: c) equals: 0.
	assert: (0 quo: d) equals: 0.
	assert: (0 quo: e) equals: 0.
	assert: (0 quo: f) equals: 0.
)
public testLargeIntegerRem = (
	|
	a = 16rC425942592C7528C08D25976E.
	b = 16r9087475AA2733891DCA2F72AF2B.
	c = 16r1BC2B572BD48EF6C8EE227273D781.
	d = 0 - a.
	e = 0 - b.
	f = 0 - c.
	|

	assert: (a rem: 1) equals: 0.
	assert: (b rem: 1) equals: 0.
	assert: (c rem: 1) equals: 0.
	assert: (d rem: 1) equals: 0.
	assert: (e rem: 1) equals: 0.
	assert: (f rem: 1) equals: 0.

	assert: (a rem: -1) equals: 0.
	assert: (b rem: -1) equals: 0.
	assert: (c rem: -1) equals: 0.
	assert: (d rem: -1) equals: 0.
	assert: (e rem: -1) equals: 0.
	assert: (f rem: -1) equals: 0.

	assert: (a rem: 254) equals: 164.
	assert: (b rem: 254) equals: 171.
	assert: (c rem: 254) equals: 171.
	assert: (d rem: 254) equals: -164.
	assert: (e rem: 254) equals: -171.
	assert: (f rem: 254) equals: -171.

	assert: (a rem: 255) equals: 134.
	assert: (b rem: 255) equals: 237.
	assert: (c rem: 255) equals: 222.
	assert: (d rem: 255) equals: -134.
	assert: (e rem: 255) equals: -237.
	assert: (f rem: 255) equals: -222.

	assert: (a rem: 256) equals: 110.
	assert: (b rem: 256) equals: 43.
	assert: (c rem: 256) equals: 129.
	assert: (d rem: 256) equals: -110.
	assert: (e rem: 256) equals: -43.
	assert: (f rem: 256) equals: -129.

	assert: (a rem: -254) equals: 164.
	assert: (b rem: -254) equals: 171.
	assert: (c rem: -254) equals: 171.
	assert: (d rem: -254) equals: -164.
	assert: (e rem: -254) equals: -171.
	assert: (f rem: -254) equals: -171.

	assert: (a rem: -255) equals: 134.
	assert: (b rem: -255) equals: 237.
	assert: (c rem: -255) equals: 222.
	assert: (d rem: -255) equals: -134.
	assert: (e rem: -255) equals: -237.
	assert: (f rem: -255) equals: -222.

	assert: (a rem: -256) equals: 110.
	assert: (b rem: -256) equals: 43.
	assert: (c rem: -256) equals: 129.
	assert: (d rem: -256) equals: -110.
	assert: (e rem: -256) equals: -43.
	assert: (f rem: -256) equals: -129.

	assert: (a rem: a) equals: 0.
	assert: (b rem: a) equals: 612442956730869442432757889635.
	assert: (c rem: a) equals: 277072498513983728925083072807.
	assert: (d rem: a) equals: 0.
	assert: (e rem: a) equals: -612442956730869442432757889635.
	assert: (f rem: a) equals: -277072498513983728925083072807.

	assert: (a rem: b) equals: a.
	assert: (b rem: b) equals: 0.
	assert: (c rem: b) equals: 31457495336625503310850528661574.
	assert: (d rem: b) equals: d.
	assert: (e rem: b) equals: 0.
	assert: (f rem: b) equals: -31457495336625503310850528661574.

	assert: (a rem: c) equals: a.
	assert: (b rem: c) equals: b.
	assert: (c rem: c) equals: 0.
	assert: (d rem: c) equals: d.
	assert: (e rem: c) equals: e.
	assert: (f rem: c) equals: 0.

	assert: (a rem: d) equals: 0.
	assert: (b rem: d) equals: 612442956730869442432757889635.
	assert: (c rem: d) equals: 277072498513983728925083072807.
	assert: (d rem: d) equals: 0.
	assert: (e rem: d) equals: -612442956730869442432757889635.
	assert: (f rem: d) equals: -277072498513983728925083072807.

	assert: (a rem: e) equals: a.
	assert: (b rem: e) equals: 0.
	assert: (c rem: e) equals: 31457495336625503310850528661574.
	assert: (d rem: e) equals: d.
	assert: (e rem: e) equals: 0.
	assert: (f rem: e) equals: -31457495336625503310850528661574.

	assert: (a rem: f) equals: a.
	assert: (b rem: f) equals: b.
	assert: (c rem: f) equals: 0.
	assert: (d rem: f) equals: d.
	assert: (e rem: f) equals: e.
	assert: (f rem: f) equals: 0.

	should: [a rem: 0] signal: Error.
	should: [b rem: 0] signal: Error.
	should: [c rem: 0] signal: Error.
	should: [d rem: 0] signal: Error.
	should: [e rem: 0] signal: Error.
	should: [f rem: 0] signal: Error.

	assert: (0 rem: a) equals: 0.
	assert: (0 rem: b) equals: 0.
	assert: (0 rem: c) equals: 0.
	assert: (0 rem: d) equals: 0.
	assert: (0 rem: e) equals: 0.
	assert: (0 rem: f) equals: 0.
)
public testLargeIntegerShiftLeft = (
	|
	a = 16rABCD1234DCBA432155.
	b = 0 - 16rABCD1234DCBA432155.
	|
	assert: a << 0 equals: a.
	assert: b << 0 equals: b.

	assert: a << 7 equals: 405653781510951904782976.
	assert: b << 7 equals: -405653781510951904782976.
	assert: a << 8 equals: 811307563021903809565952.
	assert: b << 8 equals: -811307563021903809565952.
	assert: a << 9 equals: 1622615126043807619131904.
	assert: b << 9 equals: -1622615126043807619131904.

	assert: a << 15 equals: 103847368066803687624441856.
	assert: b << 15 equals: -103847368066803687624441856.
	assert: a << 16 equals: 207694736133607375248883712.
	assert: b << 16 equals: -207694736133607375248883712.
	assert: a << 17 equals: 415389472267214750497767424.
	assert: b << 17 equals: -415389472267214750497767424.

	assert: a << 31 equals: 6805741113626046472155421474816.
	assert: b << 31 equals: -6805741113626046472155421474816.
	assert: a << 32 equals: 13611482227252092944310842949632.
	assert: b << 32 equals: -13611482227252092944310842949632.
	assert: a << 33 equals: 27222964454504185888621685899264.
	assert: b << 33 equals: -27222964454504185888621685899264.

	assert: a << 63 equals: 29230435508066489571683709863430807617536.
	assert: b << 63 equals: -29230435508066489571683709863430807617536.
	assert: a << 64 equals: 58460871016132979143367419726861615235072.
	assert: b << 64 equals: -58460871016132979143367419726861615235072.
	assert: a << 65 equals: 116921742032265958286734839453723230470144.
	assert: b << 65 equals: -116921742032265958286734839453723230470144.

	(* should: [a << maxInt31] signal: OutOfMemory.
	should: [b << maxInt31] signal: OutOfMemory.
	should: [a << maxInt63] signal: OutOfMemory.
	should: [b << maxInt63] signal: OutOfMemory.
	should: [a << maxInt64] signal: OutOfMemory.
	should: [b << maxInt64] signal: OutOfMemory.
	should: [a << a] signal: OutOfMemory.
	should: [b << a] signal: OutOfMemory. *)

	should: [a << -1] signal: Error.
	should: [b << -1] signal: Error.
	should: [a << minInt31] signal: Error.
	should: [b << minInt31] signal: Error.
	should: [a << minInt63] signal: Error.
	should: [b << minInt63] signal: Error.
	should: [a << minInt64] signal: Error.
	should: [b << minInt64] signal: Error.
	should: [a << b] signal: Error.
	should: [b << b] signal: Error.
)
public testLargeIntegerShiftRight = (
	|
	a = 16rABCD1234DCBA432100.
	b = 0 - 16rABCD1234DCBA432100.
	|
	assert: a >> 0 equals: a.
	assert: b >> 0 equals: b.

	assert: a >> 7 equals: 24759141937924310594.
	assert: b >> 7 equals: -24759141937924310594.
	assert: a >> 8 equals: 12379570968962155297.
	assert: b >> 8 equals: -12379570968962155297.
	assert: a >> 9 equals: 6189785484481077648.
	assert: b >> 9 equals: -6189785484481077649.

	assert: a >> 15 equals: 96715398195016838.
	assert: b >> 15 equals: -96715398195016839.
	assert: a >> 16 equals: 48357699097508419.
	assert: b >> 16 equals: -48357699097508420.
	assert: a >> 17 equals: 24178849548754209.
	assert: b >> 17 equals: -24178849548754210.

	assert: a >> 31 equals: 1475759860153.
	assert: b >> 31 equals: -1475759860154.
	assert: a >> 32 equals: 737879930076.
	assert: b >> 32 equals: -737879930077.
	assert: a >> 33 equals: 368939965038.
	assert: b >> 34 equals: -184469982520.

	assert: a >> 63 equals: 343.
	assert: b >> 63 equals: -344.
	assert: a >> 64 equals: 171.
	assert: b >> 64 equals: -172.
	assert: a >> 65 equals: 85.
	assert: b >> 65 equals: -86.

	assert: a >> maxInt31 equals: 0.
	assert: b >> maxInt31 equals: -1.
	assert: a >> maxInt63 equals: 0.
	assert: b >> maxInt63 equals: -1.
	assert: a >> maxInt64 equals: 0.
	assert: b >> maxInt64 equals: -1.
	assert: a >> a equals: 0.
	assert: b >> a equals: -1.

	should: [a >> -1] signal: Error.
	should: [b >> -1] signal: Error.
	should: [a >> minInt31] signal: Error.
	should: [b >> minInt31] signal: Error.
	should: [a >> minInt63] signal: Error.
	should: [b >> minInt63] signal: Error.
	should: [a >> minInt64] signal: Error.
	should: [b >> minInt64] signal: Error.
	should: [a >> b] signal: Error.
	should: [b >> b] signal: Error.
)
public testLargeIntegerSubtract = (
	|
	a = 16rC425942592C7528C08D25976E.
	b = 16r9087475AA2733891DCA2F72AF2B.
	c = 16r1BC2B572BD48EF6C8EE227273D781.
	d = 0 - a.
	e = 0 - b.
	f = 0 - c.
	|

	assert: minInt64 - minInt64 equals: 0.
	assert: maxInt64 - maxInt64 equals: 0.
	assert: largestNegativeLargeInteger - 1 equals: -9223372036854775810.
	assert: largestNegativeLargeInteger - -1 equals: -9223372036854775808.
	assert: smallestPositiveLargeInteger - 1 equals: 9223372036854775807.
	assert: smallestPositiveLargeInteger - -1 equals: 9223372036854775809.
	assert: smallestPositiveLargeInteger - largestNegativeLargeInteger equals: 18446744073709551617.

	assert: a - a equals: 0.
	assert: b - a equals: 182240282373426279963566390712253.
	assert: c - a equals: 9007852381324360171819798402842643.
	assert: d - a equals: -1942543737076956262258113720028.
	assert: e - a equals: -184182826110503236225824504432281.
	assert: f - a equals: -9009794925061437128082056516562671.

	assert: a - b equals: -182240282373426279963566390712253.
	assert: b - b equals: 0.
	assert: c - b equals: 8825612098950933891856232012130390.
	assert: d - b equals: -184182826110503236225824504432281.
	assert: e - b equals: -366423108483929516189390895144534.
	assert: f - b equals: -9192035207434863408045622907274924.

	assert: a - c equals: -9007852381324360171819798402842643.
	assert: b - c equals: -8825612098950933891856232012130390.
	assert: c - c equals: 0.
	assert: d - c equals: -9009794925061437128082056516562671.
	assert: e - c equals: -9192035207434863408045622907274924.
	assert: f - c equals: -18017647306385797299901854919405314.

	assert: a - d equals: 1942543737076956262258113720028.
	assert: b - d equals: 184182826110503236225824504432281.
	assert: c - d equals: 9009794925061437128082056516562671.
	assert: d - d equals: 0.
	assert: e - d equals: -182240282373426279963566390712253.
	assert: f - d equals: -9007852381324360171819798402842643.

	assert: a - e equals: 184182826110503236225824504432281.
	assert: b - e equals: 366423108483929516189390895144534.
	assert: c - e equals: 9192035207434863408045622907274924.
	assert: d - e equals: 182240282373426279963566390712253.
	assert: e - e equals: 0.
	assert: f - e equals: -8825612098950933891856232012130390.

	assert: a - f equals: 9009794925061437128082056516562671.
	assert: b - f equals: 9192035207434863408045622907274924.
	assert: c - f equals: 18017647306385797299901854919405314.
	assert: d - f equals: 9007852381324360171819798402842643.
	assert: e - f equals: 8825612098950933891856232012130390.
	assert: f - f equals: 0.
)
public testLargeIntegerXor = (
	|
	a = 16rFFAABBCCDDEE997766.
	b = 16rEEEEEEEEEEEEEEEE.
	c = 16rCC0011223344556677.
	d = 16r8888008888888888.
	e = 0 - a.
	f = 0 - b.
	g = 0 - c.
	h = 0 - d.
	|

	assert: (a bitXor: a) equals: 0.
	assert: (a bitXor: b) equals: 4708843618165981682056.
	assert: (a bitXor: c) equals: 953081852200510820625.
	assert: (a bitXor: d) equals: 4706384276884194197486.
	assert: (a bitXor: e) equals: -4.
	assert: (a bitXor: f) equals: -4708843618165981682060.
	assert: (a bitXor: g) equals: -953081852200510820625.
	assert: (a bitXor: h) equals: -4706384276884194197474.

	assert: (b bitXor: a) equals: 4708843618165981682056.
	assert: (b bitXor: b) equals: 0.
	assert: (b bitXor: c) equals: 3780357499789260851353.
	assert: (b bitXor: d) equals: 7378847163065198182.
	assert: (b bitXor: e) equals: -4708843618165981682060.
	assert: (b bitXor: f) equals: -4.
	assert: (b bitXor: g) equals: -3780357499789260851353.
	assert: (b bitXor: h) equals: -7378847163065198186.

	assert: (c bitXor: a) equals: 953081852200510820625.
	assert: (c bitXor: b) equals: 3780357499789260851353.
	assert: (c bitXor: c) equals: 0.
	assert: (c bitXor: d) equals: 3772978727687334784767.
	assert: (c bitXor: e) equals: -953081852200510820627.
	assert: (c bitXor: f) equals: -3780357499789260851355.
	assert: (c bitXor: g) equals: -2.
	assert: (c bitXor: h) equals: -3772978727687334784753.

	assert: (d bitXor: a) equals: 4706384276884194197486.
	assert: (d bitXor: b) equals: 7378847163065198182.
	assert: (d bitXor: c) equals: 3772978727687334784767.
	assert: (d bitXor: d) equals: 0.
	assert: (d bitXor: e) equals: -4706384276884194197486.
	assert: (d bitXor: f) equals: -7378847163065198182.
	assert: (d bitXor: g) equals: -3772978727687334784767.
	assert: (d bitXor: h) equals: -16.

	assert: (e bitXor: a) equals: -4.
	assert: (e bitXor: b) equals: -4708843618165981682060.
	assert: (e bitXor: c) equals: -953081852200510820627.
	assert: (e bitXor: d) equals: -4706384276884194197486.
	assert: (e bitXor: e) equals: 0.
	assert: (e bitXor: f) equals: 4708843618165981682056.
	assert: (e bitXor: g) equals: 953081852200510820627.
	assert: (e bitXor: h) equals: 4706384276884194197474.

	assert: (f bitXor: a) equals: -4708843618165981682060.
	assert: (f bitXor: b) equals: -4.
	assert: (f bitXor: c) equals: -3780357499789260851355.
	assert: (f bitXor: d) equals: -7378847163065198182.
	assert: (f bitXor: e) equals: 4708843618165981682056.
	assert: (f bitXor: f) equals: 0.
	assert: (f bitXor: g) equals: 3780357499789260851355.
	assert: (f bitXor: h) equals: 7378847163065198186.

	assert: (g bitXor: a) equals: -953081852200510820625.
	assert: (g bitXor: b) equals: -3780357499789260851353.
	assert: (g bitXor: c) equals: -2.
	assert: (g bitXor: d) equals: -3772978727687334784767.
	assert: (g bitXor: e) equals: 953081852200510820627.
	assert: (g bitXor: f) equals: 3780357499789260851355.
	assert: (g bitXor: g) equals: 0.
	assert: (g bitXor: h) equals: 3772978727687334784753.

	assert: (h bitXor: a) equals: -4706384276884194197474.
	assert: (h bitXor: b) equals: -7378847163065198186.
	assert: (h bitXor: c) equals: -3772978727687334784753.
	assert: (h bitXor: d) equals: -16.
	assert: (h bitXor: e) equals: 4706384276884194197474.
	assert: (h bitXor: f) equals: 7378847163065198186.
	assert: (h bitXor: g) equals: 3772978727687334784753.
	assert: (h bitXor: h) equals: 0.

	assert: (0 bitXor: a) equals: a.
	assert: (0 bitXor: b) equals: b.
	assert: (0 bitXor: c) equals: c.
	assert: (0 bitXor: d) equals: d.
	assert: (0 bitXor: e) equals: e.
	assert: (0 bitXor: f) equals: f.
	assert: (0 bitXor: g) equals: g.
	assert: (0 bitXor: h) equals: h.

	assert: (a bitXor: 0) equals: a.
	assert: (b bitXor: 0) equals: b.
	assert: (c bitXor: 0) equals: c.
	assert: (d bitXor: 0) equals: d.
	assert: (e bitXor: 0) equals: e.
	assert: (f bitXor: 0) equals: f.
	assert: (g bitXor: 0) equals: g.
	assert: (h bitXor: 0) equals: h.
)
public testLargeIntegerZeroShiftLeft = (
	(* Shifts need to consider clamping only for zero. *)
	assert: 0 << 32 equals: 0.
	assert: 0 << 64 equals: 0.
	assert: 0 << 96 equals: 0.
	assert: 0 << 128 equals: 0.

	assert: 0 << 31 equals: 0.
	assert: 0 << 63 equals: 0.
	assert: 0 << 95 equals: 0.
	assert: 0 << 127 equals: 0.

	assert: 0 << 33 equals: 0.
	assert: 0 << 65 equals: 0.
	assert: 0 << 97 equals: 0.
	assert: 0 << 129 equals: 0.
)
public testLargeIntegerZeroShiftRight = (
	(* Shifts need to consider clamping only for zero. *)
	assert: 0 >> 32 equals: 0.
	assert: 0 >> 64 equals: 0.
	assert: 0 >> 96 equals: 0.
	assert: 0 >> 128 equals: 0.

	assert: 0 >> 31 equals: 0.
	assert: 0 >> 63 equals: 0.
	assert: 0 >> 95 equals: 0.
	assert: 0 >> 127 equals: 0.

	assert: 0 >> 33 equals: 0.
	assert: 0 >> 65 equals: 0.
	assert: 0 >> 97 equals: 0.
	assert: 0 >> 129 equals: 0.
)
public testMediumIntegerAddOverflow = (
	assert: minInt64 + -1 equals: -9223372036854775809.
	assert: maxInt64 + 1 equals: 9223372036854775808.
	assert: maxInt64 + maxInt64 equals: 18446744073709551614.
	assert: minInt64 + minInt64 equals: -18446744073709551616.
)
public testMediumIntegerAnd = (
	assert: (minInt31 bitAnd: 0) equals: 0.
	assert: (minInt32 bitAnd: 0) equals: 0.
	assert: (minInt63 bitAnd: 0) equals: 0.
	assert: (minInt64 bitAnd: 0) equals: 0.
	assert: (maxInt31 bitAnd: 0) equals: 0.
	assert: (maxInt32 bitAnd: 0) equals: 0.
	assert: (maxInt63 bitAnd: 0) equals: 0.
	assert: (maxInt64 bitAnd: 0) equals: 0.

	assert: (minInt31 bitAnd: minInt31) equals: minInt31.
	assert: (minInt32 bitAnd: minInt32) equals: minInt32.
	assert: (minInt63 bitAnd: minInt63) equals: minInt63.
	assert: (minInt64 bitAnd: minInt64) equals: minInt64.
	assert: (maxInt31 bitAnd: maxInt31) equals: maxInt31.
	assert: (maxInt32 bitAnd: maxInt32) equals: maxInt32.
	assert: (maxInt63 bitAnd: maxInt63) equals: maxInt63.
	assert: (maxInt64 bitAnd: maxInt64) equals: maxInt64.

	assert: (minInt31 bitAnd: maxInt31) equals: 0.
	assert: (minInt32 bitAnd: maxInt32) equals: 0.
	assert: (minInt63 bitAnd: maxInt63) equals: 0.
	assert: (minInt64 bitAnd: maxInt64) equals: 0.

	assert: (maxInt32 bitAnd: maxInt31) equals: maxInt31.
	assert: (maxInt63 bitAnd: maxInt31) equals: maxInt31.
	assert: (maxInt64 bitAnd: maxInt31) equals: maxInt31.

	assert: (maxInt63 bitAnd: maxInt32) equals: maxInt32.
	assert: (maxInt64 bitAnd: maxInt32) equals: maxInt32.

	assert: (maxInt64 bitAnd: maxInt63) equals: maxInt63.
)
public testMediumIntegerAsFloat = (
	assert: maxInt32 asFloat equals: (Float parse: '2147483647.0').
	assert: minInt32 asFloat equals: (Float parse: '-2147483648.0').

	assert: maxInt63 asFloat equals: (Float parse: '4611686018427387903.0').
	assert: minInt63 asFloat equals: (Float parse: '-4611686018427387904.0').

	assert: maxInt64 asFloat equals: (Float parse: '9223372036854775807.0').
	assert: minInt64 asFloat equals: (Float parse: '-9223372036854775808.0').

	assert: 16rCAFECAFECAFECAFE asFloat equals: (Float parse: '14627351835422149374.0').
)
public testMediumIntegerAsString = (
	assert: maxInt64 asString equals: '9223372036854775807'.
	assert: minInt64 asString equals: '-9223372036854775808'.
)
public testMediumIntegerComparisons = (
	assert: minInt64 = minInt64.
	deny: minInt64 < minInt64.
	deny: minInt64 > minInt64.
	assert: minInt64 <= minInt64.
	assert: minInt64 >= minInt64.

	assert: maxInt64 = maxInt64.
	deny: maxInt64 < maxInt64.
	deny: maxInt64 > maxInt64.
	assert: maxInt64 <= maxInt64.
	assert: maxInt64 >= maxInt64.

	deny: maxInt64 = minInt64.
	deny: maxInt64 < minInt64.
	assert: maxInt64 > minInt64.
	deny: maxInt64 <= minInt64.
	assert: maxInt64 >= minInt64.

	deny: minInt64 = maxInt64.
	assert: minInt64 < maxInt64.
	deny: minInt64 > maxInt64.
	assert: minInt64 <= maxInt64.
	deny: minInt64 >= maxInt64.
)
public testMediumIntegerDiv = (
	assert: minInt31 // 1 equals: minInt31.
	assert: minInt32 // 1 equals: minInt32.
	assert: minInt63 // 1 equals: minInt63.
	assert: minInt64 // 1 equals: minInt64.
	assert: maxInt31 // 1 equals: maxInt31.
	assert: maxInt32 // 1 equals: maxInt32.
	assert: maxInt63 // 1 equals: maxInt63.
	assert: maxInt64 // 1 equals: maxInt64.

	assert: minInt31 // -1 equals: 1073741824.
	assert: minInt32 // -1 equals: 2147483648.
	assert: minInt63 // -1 equals: 4611686018427387904.
	(* big int: assert: minInt64 // -1 equals: 9223372036854775808. *)
	assert: maxInt31 // -1 equals: -1073741823.
	assert: maxInt32 // -1 equals: -2147483647.
	assert: maxInt63 // -1 equals: -4611686018427387903.
	assert: maxInt64 // -1 equals: -9223372036854775807.

	assert: minInt31 // 7 equals: -153391690.
	assert: minInt32 // 7 equals: -306783379.
	assert: minInt63 // 7 equals: -658812288346769701.
	(* assert: minInt64 // 7 equals: -1317624576693539402. *)
	assert: maxInt31 // 7 equals: 153391689.
	assert: maxInt32 // 7 equals: 306783378.
	assert: maxInt63 // 7 equals: 658812288346769700.
	(* assert: maxInt64 // 7 equals: 1317624576693539401. *)

	assert: minInt31 // -7 equals: 153391689.
	assert: minInt32 // -7 equals: 306783378.
	assert: minInt63 // -7 equals: 658812288346769700.
	(* big int intermediate: assert: minInt64 // -7 equals: 1317624576693539401. *)
	assert: maxInt31 // -7 equals: -153391689.
	assert: maxInt32 // -7 equals: -306783379.
	assert: maxInt63 // -7 equals: -658812288346769701.
	(* assert: maxInt64 // -7 equals: -1317624576693539401. *)

	(* big int intermediates
	assert: minInt31 // minInt64 equals: 0.
	assert: minInt32 // minInt64 equals: 0.
	assert: minInt63 // minInt64 equals: 0.
	assert: minInt64 // minInt64 equals: 1.
	assert: maxInt31 // minInt64 equals: -1.
	assert: maxInt32 // minInt64 equals: -1.
	assert: maxInt63 // minInt64 equals: -1.
	assert: maxInt64 // minInt64 equals: -1. *)

	should: [minInt64 // 0] signal: Error.
	should: [maxInt64 // 0] signal: Error.

	assert: 0 // minInt64 equals: 0.
	assert: 0 // maxInt64 equals: 0.
)
public testMediumIntegerDivOverflow = (
	assert: minInt64 // -1 equals: 9223372036854775808.
	assert: minInt64 // 7 equals: -1317624576693539402.
	assert: maxInt64 // 7 equals: 1317624576693539401.
	assert: minInt64 // -7 equals: 1317624576693539401.
	assert: maxInt64 // -7 equals: -1317624576693539401.

	assert: minInt31 // minInt64 equals: 0.
	assert: minInt32 // minInt64 equals: 0.
	assert: minInt63 // minInt64 equals: 0.
	assert: minInt64 // minInt64 equals: 1.
	assert: maxInt31 // minInt64 equals: -1.
	assert: maxInt32 // minInt64 equals: -1.
	assert: maxInt63 // minInt64 equals: -1.
	assert: maxInt64 // minInt64 equals: -1.
)
public testMediumIntegerDivide = (
	assert: minInt31 / 1 equals: minInt31.
	assert: minInt32 / 1 equals: minInt32.
	assert: minInt63 / 1 equals: minInt63.
	assert: minInt64 / 1 equals: minInt64.
	assert: maxInt31 / 1 equals: maxInt31.
	assert: maxInt32 / 1 equals: maxInt32.
	assert: maxInt63 / 1 equals: maxInt63.
	assert: maxInt64 / 1 equals: maxInt64.

	assert: minInt31 / -1 equals: 1073741824.
	assert: minInt32 / -1 equals: 2147483648.
	assert: minInt63 / -1 equals: 4611686018427387904.
	(* big int: assert: minInt64 / -1 equals: 9223372036854775808. *)
	assert: maxInt31 / -1 equals: -1073741823.
	assert: maxInt32 / -1 equals: -2147483647.
	assert: maxInt63 / -1 equals: -4611686018427387903.
	assert: maxInt64 / -1 equals: -9223372036854775807.

	should: [minInt64 / 0] signal: Error.
	should: [maxInt64 / 0] signal: Error.

	assert: 0 / minInt64 equals: 0.
	assert: 0 / maxInt64 equals: 0.
)
public testMediumIntegerDivideOverflow = (
	assert: minInt64 / -1 equals: 9223372036854775808.
)
public testMediumIntegerInvert = (
	assert: minInt31 bitInvert equals: maxInt31.
	assert: minInt32 bitInvert equals: maxInt32.
	assert: minInt63 bitInvert equals: maxInt63.
	assert: minInt64 bitInvert equals: maxInt64.
	assert: maxInt31 bitInvert equals: minInt31.
	assert: maxInt32 bitInvert equals: minInt32.
	assert: maxInt63 bitInvert equals: minInt63.
	assert: maxInt64 bitInvert equals: minInt64.
)
public testMediumIntegerMod = (
	assert: minInt31 \\ 1 equals: 0.
	assert: minInt32 \\ 1 equals: 0.
	assert: minInt63 \\ 1 equals: 0.
	assert: minInt64 \\ 1 equals: 0.
	assert: maxInt31 \\ 1 equals: 0.
	assert: maxInt32 \\ 1 equals: 0.
	assert: maxInt63 \\ 1 equals: 0.
	assert: maxInt64 \\ 1 equals: 0.

	assert: minInt31 \\ -1 equals: 0.
	assert: minInt32 \\ -1 equals: 0.
	assert: minInt63 \\ -1 equals: 0.
	assert: minInt64 \\ -1 equals: 0.
	assert: maxInt31 \\ -1 equals: 0.
	assert: maxInt32 \\ -1 equals: 0.
	assert: maxInt63 \\ -1 equals: 0.
	assert: maxInt64 \\ -1 equals: 0.

	assert: minInt31 \\ 7 equals: 6.
	assert: minInt32 \\ 7 equals: 5.
	assert: minInt63 \\ 7 equals: 3.
	assert: minInt64 \\ 7 equals: 6.
	assert: maxInt31 \\ 7 equals: 0.
	assert: maxInt32 \\ 7 equals: 1.
	assert: maxInt63 \\ 7 equals: 3.
	assert: maxInt64 \\ 7 equals: 0.

	assert: minInt31 \\ -7 equals: -1.
	assert: minInt32 \\ -7 equals: -2.
	assert: minInt63 \\ -7 equals: -4.
	assert: minInt64 \\ -7 equals: -1.
	assert: maxInt31 \\ -7 equals: 0.
	assert: maxInt32 \\ -7 equals: -6.
	assert: maxInt63 \\ -7 equals: -4.
	assert: maxInt64 \\ -7 equals: 0.

	assert: minInt31 \\ minInt64 equals: -1073741824.
	assert: minInt32 \\ minInt64 equals: -2147483648.
	assert: minInt63 \\ minInt64 equals: -4611686018427387904.
	assert: minInt64 \\ minInt64 equals: 0.
	assert: maxInt31 \\ minInt64 equals: -9223372035781033985.
	assert: maxInt32 \\ minInt64 equals: -9223372034707292161.
	assert: maxInt63 \\ minInt64 equals: -4611686018427387905.
	assert: maxInt64 \\ minInt64 equals: -1.

	should: [minInt64 \\ 0] signal: Error.
	should: [maxInt64 \\ 0] signal: Error.

	assert: 0 \\ minInt64 equals: 0.
	assert: 0 \\ maxInt64 equals: 0.
)
public testMediumIntegerOperatorsInvalidArgument = (
	should: [maxInt64 + nil] signal: Error.
	should: [maxInt64 - nil] signal: Error.
	should: [maxInt64 / nil] signal: Error.
	should: [maxInt64 * nil] signal: Error.
	should: [maxInt64 // nil] signal: Error.
	should: [maxInt64 \\ nil] signal: Error.
	should: [maxInt64 quo: nil] signal: Error.
	should: [maxInt64 rem: nil] signal: Error.
	should: [maxInt64 << nil] signal: Error.
	should: [maxInt64 >> nil] signal: Error.
	should: [maxInt64 bitAnd: nil] signal: Error.
	should: [maxInt64 bitOr: nil] signal: Error.
	should: [0 bitXor: nil] signal: Error.
)
public testMediumIntegerOr = (
	assert: (minInt31 bitOr: 0) equals: minInt31.
	assert: (minInt32 bitOr: 0) equals: minInt32.
	assert: (minInt63 bitOr: 0) equals: minInt63.
	assert: (minInt64 bitOr: 0) equals: minInt64.
	assert: (maxInt31 bitOr: 0) equals: maxInt31.
	assert: (maxInt32 bitOr: 0) equals: maxInt32.
	assert: (maxInt63 bitOr: 0) equals: maxInt63.
	assert: (maxInt64 bitOr: 0) equals: maxInt64.

	assert: (minInt31 bitOr: minInt31) equals: minInt31.
	assert: (minInt32 bitOr: minInt32) equals: minInt32.
	assert: (minInt63 bitOr: minInt63) equals: minInt63.
	assert: (minInt64 bitOr: minInt64) equals: minInt64.
	assert: (maxInt31 bitOr: maxInt31) equals: maxInt31.
	assert: (maxInt32 bitOr: maxInt32) equals: maxInt32.
	assert: (maxInt63 bitOr: maxInt63) equals: maxInt63.
	assert: (maxInt64 bitOr: maxInt64) equals: maxInt64.

	assert: (minInt31 bitOr: maxInt31) equals: -1.
	assert: (minInt32 bitOr: maxInt32) equals: -1.
	assert: (minInt63 bitOr: maxInt63) equals: -1.
	assert: (minInt64 bitOr: maxInt64) equals: -1.

	assert: (maxInt32 bitOr: maxInt31) equals: maxInt32.
	assert: (maxInt63 bitOr: maxInt31) equals: maxInt63.
	assert: (maxInt64 bitOr: maxInt31) equals: maxInt64.

	assert: (maxInt63 bitOr: maxInt32) equals: maxInt63.
	assert: (maxInt64 bitOr: maxInt32) equals: maxInt64.

	assert: (maxInt64 bitOr: maxInt63) equals: maxInt64.
)
public testMediumIntegerParse = (
	assert: (Integer parse: '9223372036854775807') equals: maxInt64.
	assert: (Integer parse: '-9223372036854775808') equals: minInt64.
)
public testMediumIntegerQuo = (
	assert: (minInt31 quo: 1) equals: minInt31.
	assert: (minInt32 quo: 1) equals: minInt32.
	assert: (minInt63 quo: 1) equals: minInt63.
	assert: (minInt64 quo: 1) equals: minInt64.
	assert: (maxInt31 quo: 1) equals: maxInt31.
	assert: (maxInt32 quo: 1) equals: maxInt32.
	assert: (maxInt63 quo: 1) equals: maxInt63.
	assert: (maxInt64 quo: 1) equals: maxInt64.

	assert: (minInt31 quo: -1) equals: 1073741824.
	assert: (minInt32 quo: -1) equals: 2147483648.
	assert: (minInt63 quo: -1) equals: 4611686018427387904.
	(* big int: assert: (minInt64 quo: -1) equals: 9223372036854775808. *)
	assert: (maxInt31 quo: -1) equals: -1073741823.
	assert: (maxInt32 quo: -1) equals: -2147483647.
	assert: (maxInt63 quo: -1) equals: -4611686018427387903.
	assert: (maxInt64 quo: -1) equals: -9223372036854775807.

	assert: (minInt31 quo: 7) equals: -153391689.
	assert: (minInt32 quo: 7) equals: -306783378.
	assert: (minInt63 quo: 7) equals: -658812288346769700.
	assert: (minInt64 quo: 7) equals: -1317624576693539401.
	assert: (maxInt31 quo: 7) equals: 153391689.
	assert: (maxInt32 quo: 7) equals: 306783378.
	assert: (maxInt63 quo: 7) equals: 658812288346769700.
	assert: (maxInt64 quo: 7) equals: 1317624576693539401.

	assert: (minInt31 quo: -7) equals: 153391689.
	assert: (minInt32 quo: -7) equals: 306783378.
	assert: (minInt63 quo: -7) equals: 658812288346769700.
	assert: (minInt64 quo: -7) equals: 1317624576693539401.
	assert: (maxInt31 quo: -7) equals: -153391689.
	assert: (maxInt32 quo: -7) equals: -306783378.
	assert: (maxInt63 quo: -7) equals: -658812288346769700.
	assert: (maxInt64 quo: -7) equals: -1317624576693539401.

	assert: (minInt31 quo: minInt64) equals: 0.
	assert: (minInt32 quo: minInt64) equals: 0.
	assert: (minInt63 quo: minInt64) equals: 0.
	assert: (minInt64 quo: minInt64) equals: 1.
	assert: (maxInt31 quo: minInt64) equals: 0.
	assert: (maxInt32 quo: minInt64) equals: 0.
	assert: (maxInt63 quo: minInt64) equals: 0.
	assert: (maxInt64 quo: minInt64) equals: 0.

	should: [minInt64 quo: 0] signal: Error.
	should: [maxInt64 quo: 0] signal: Error.

	assert: (0 quo: minInt64) equals: 0.
	assert: (0 quo: maxInt64) equals: 0.
)
public testMediumIntegerQuoOverflow = (
	assert: (minInt64 quo: -1) equals: 9223372036854775808.
)
public testMediumIntegerRem = (
	assert: (minInt31 rem: 1) equals: 0.
	assert: (minInt32 rem: 1) equals: 0.
	assert: (minInt63 rem: 1) equals: 0.
	assert: (minInt64 rem: 1) equals: 0.
	assert: (maxInt31 rem: 1) equals: 0.
	assert: (maxInt32 rem: 1) equals: 0.
	assert: (maxInt63 rem: 1) equals: 0.
	assert: (maxInt64 rem: 1) equals: 0.

	assert: (minInt31 rem: -1) equals: 0.
	assert: (minInt32 rem: -1) equals: 0.
	assert: (minInt63 rem: -1) equals: 0.
	assert: (minInt64 rem: -1) equals: 0.
	assert: (maxInt31 rem: -1) equals: 0.
	assert: (maxInt32 rem: -1) equals: 0.
	assert: (maxInt63 rem: -1) equals: 0.
	assert: (maxInt64 rem: -1) equals: 0.

	assert: (minInt31 rem: 7) equals: -1.
	assert: (minInt32 rem: 7) equals: -2.
	assert: (minInt63 rem: 7) equals: -4.
	assert: (minInt64 rem: 7) equals: -1.
	assert: (maxInt31 rem: 7) equals: 0.
	assert: (maxInt32 rem: 7) equals: 1.
	assert: (maxInt63 rem: 7) equals: 3.
	assert: (maxInt64 rem: 7) equals: 0.

	assert: (minInt31 rem: -7) equals: -1.
	assert: (minInt32 rem: -7) equals: -2.
	assert: (minInt63 rem: -7) equals: -4.
	assert: (minInt64 rem: -7) equals: -1.
	assert: (maxInt31 rem: -7) equals: 0.
	assert: (maxInt32 rem: -7) equals: 1.
	assert: (maxInt63 rem: -7) equals: 3.
	assert: (maxInt64 rem: -7) equals: 0.

	assert: (minInt31 rem: minInt64) equals: -1073741824.
	assert: (minInt32 rem: minInt64) equals: -2147483648.
	assert: (minInt63 rem: minInt64) equals: -4611686018427387904.
	assert: (minInt64 rem: minInt64) equals: 0.
	assert: (maxInt31 rem: minInt64) equals: 1073741823.
	assert: (maxInt32 rem: minInt64) equals: 2147483647.
	assert: (maxInt63 rem: minInt64) equals: 4611686018427387903.
	assert: (maxInt64 rem: minInt64) equals: 9223372036854775807.

	should: [minInt64 rem: 0] signal: Error.
	should: [maxInt64 rem: 0] signal: Error.

	assert: (0 rem: minInt64) equals: 0.
	assert: (0 rem: maxInt64) equals: 0.
)
public testMediumIntegerShiftLeft = (
	assert: minInt31 << 0 equals: minInt31.
	assert: minInt32 << 0 equals: minInt32.
	assert: minInt63 << 0 equals: minInt63.
	assert: minInt64 << 0 equals: minInt64.
	assert: maxInt31 << 0 equals: maxInt31.
	assert: maxInt32 << 0 equals: maxInt32.
	assert: maxInt63 << 0 equals: maxInt63.
	assert: maxInt64 << 0 equals: maxInt64.

	assert: minInt31 << 1 equals: -2147483648.
	assert: minInt32 << 1 equals: -4294967296.
	assert: minInt63 << 1 equals: -9223372036854775808.
	(* big int: assert: minInt64 << 1 equals: -18446744073709551616. *)
	assert: maxInt31 << 1 equals: 2147483646.
	assert: maxInt32 << 1 equals: 4294967294.
	assert: maxInt63 << 1 equals: 9223372036854775806.
	(* big int: assert: maxInt64 << 1 equals: 18446744073709551614. *)

	assert: minInt31 << 2 equals: -4294967296.
	assert: minInt32 << 2 equals: -8589934592.
	(* big int assert: minInt63 << 2 equals: -18446744073709551616. *)
	(* big int assert: minInt64 << 2 equals: -36893488147419103232. *)
	assert: maxInt31 << 2 equals: 4294967292.
	assert: maxInt32 << 2 equals: 8589934588.
	(* big int assert: maxInt63 << 2 equals: 18446744073709551612. *)
	(* big int assert: maxInt64 << 2 equals: 36893488147419103228. *)

	assert: maxInt31 << 33 equals: 9223372028264841216.
	assert: maxInt32 << 32 equals: 9223372032559808512.

	should: [minInt31 << -1] signal: Error.
	should: [minInt32 << -1] signal: Error.
	should: [minInt63 << -1] signal: Error.
	should: [minInt64 << -1] signal: Error.
	should: [maxInt31 << -1] signal: Error.
	should: [maxInt32 << -1] signal: Error.
	should: [maxInt63 << -1] signal: Error.
	should: [maxInt64 << -1] signal: Error.
)
public testMediumIntegerShiftLeftOverflow = (
	assert: minInt64 << 1 equals: -18446744073709551616.
	assert: maxInt64 << 1 equals: 18446744073709551614.
	assert: minInt63 << 2 equals: -18446744073709551616.
	assert: minInt64 << 2 equals: -36893488147419103232.
	assert: maxInt63 << 2 equals: 18446744073709551612.
	assert: maxInt64 << 2 equals: 36893488147419103228.
)
public testMediumIntegerShiftRight = (
	assert: minInt31 >> 0 equals: minInt31.
	assert: minInt32 >> 0 equals: minInt32.
	assert: minInt63 >> 0 equals: minInt63.
	assert: minInt64 >> 0 equals: minInt64.
	assert: maxInt31 >> 0 equals: maxInt31.
	assert: maxInt32 >> 0 equals: maxInt32.
	assert: maxInt63 >> 0 equals: maxInt63.
	assert: maxInt64 >> 0 equals: maxInt64.

	assert: minInt31 >> 1 equals: -536870912.
	assert: minInt32 >> 1 equals: -1073741824.
	assert: minInt63 >> 1 equals: -2305843009213693952.
	assert: minInt64 >> 1 equals: -4611686018427387904.
	assert: maxInt31 >> 1 equals: 536870911.
	assert: maxInt32 >> 1 equals: 1073741823.
	assert: maxInt63 >> 1 equals: 2305843009213693951.
	assert: maxInt64 >> 1 equals: 4611686018427387903.

	assert: minInt31 >> 2 equals: -268435456.
	assert: minInt32 >> 2 equals: -536870912.
	assert: minInt63 >> 2 equals: -1152921504606846976.
	assert: minInt64 >> 2 equals: -2305843009213693952.
	assert: maxInt31 >> 2 equals: 268435455.
	assert: maxInt32 >> 2 equals: 536870911.
	assert: maxInt63 >> 2 equals: 1152921504606846975.
	assert: maxInt64 >> 2 equals: 2305843009213693951.

	assert: minInt31 >> 29 equals: -2.
	assert: minInt32 >> 30 equals: -2.
	assert: minInt63 >> 61 equals: -2.
	assert: minInt64 >> 62 equals: -2.
	assert: maxInt31 >> 29 equals: 1.
	assert: maxInt32 >> 30 equals: 1.
	assert: maxInt63 >> 61 equals: 1.
	assert: maxInt64 >> 62 equals: 1.

	assert: minInt31 >> 30 equals: -1.
	assert: minInt32 >> 31 equals: -1.
	assert: minInt63 >> 62 equals: -1.
	assert: minInt64 >> 63 equals: -1.
	assert: maxInt31 >> 30 equals: 0.
	assert: maxInt32 >> 31 equals: 0.
	assert: maxInt63 >> 62 equals: 0.
	assert: maxInt64 >> 63 equals: 0.

	assert: minInt31 >> 31 equals: -1.
	assert: minInt32 >> 32 equals: -1.
	assert: minInt63 >> 63 equals: -1.
	assert: minInt64 >> 64 equals: -1.
	assert: maxInt31 >> 31 equals: 0.
	assert: maxInt32 >> 32 equals: 0.
	assert: maxInt63 >> 63 equals: 0.
	assert: maxInt64 >> 64 equals: 0.

	assert: minInt31 >> maxInt64 equals: -1.
	assert: minInt32 >> maxInt64 equals: -1.
	assert: minInt63 >> maxInt64 equals: -1.
	assert: minInt64 >> maxInt64 equals: -1.
	assert: maxInt31 >> maxInt64 equals: 0.
	assert: maxInt32 >> maxInt64 equals: 0.
	assert: maxInt63 >> maxInt64 equals: 0.
	assert: maxInt64 >> maxInt64 equals: 0.

	should: [minInt31 >> -1] signal: Error.
	should: [minInt32 >> -1] signal: Error.
	should: [minInt63 >> -1] signal: Error.
	should: [minInt64 >> -1] signal: Error.
	should: [maxInt31 >> -1] signal: Error.
	should: [maxInt32 >> -1] signal: Error.
	should: [maxInt63 >> -1] signal: Error.
	should: [maxInt64 >> -1] signal: Error.
	should: [minInt31 >> minInt31] signal: Error.
	should: [minInt32 >> minInt31] signal: Error.
	should: [minInt63 >> minInt31] signal: Error.
	should: [minInt64 >> minInt31] signal: Error.
	should: [maxInt31 >> minInt31] signal: Error.
	should: [maxInt32 >> minInt31] signal: Error.
	should: [maxInt63 >> minInt31] signal: Error.
	should: [maxInt64 >> minInt31] signal: Error.
	should: [minInt31 >> minInt64] signal: Error.
	should: [minInt32 >> minInt64] signal: Error.
	should: [minInt63 >> minInt64] signal: Error.
	should: [minInt64 >> minInt64] signal: Error.
	should: [maxInt31 >> minInt64] signal: Error.
	should: [maxInt32 >> minInt64] signal: Error.
	should: [maxInt63 >> minInt64] signal: Error.
	should: [maxInt64 >> minInt64] signal: Error.
)
public testMediumIntegerSubtractOverflow = (
	assert: minInt64 - 1 equals: -9223372036854775809.
	assert: maxInt64 - -1 equals: 9223372036854775808.
	assert: -2 - maxInt64 equals: -9223372036854775809.
	assert: 0 - minInt64 equals: 9223372036854775808.
)
public testMediumIntegerXor = (
	assert: (minInt31 bitXor: 0) equals: minInt31.
	assert: (minInt32 bitXor: 0) equals: minInt32.
	assert: (minInt63 bitXor: 0) equals: minInt63.
	assert: (minInt64 bitXor: 0) equals: minInt64.
	assert: (maxInt31 bitXor: 0) equals: maxInt31.
	assert: (maxInt32 bitXor: 0) equals: maxInt32.
	assert: (maxInt63 bitXor: 0) equals: maxInt63.
	assert: (maxInt64 bitXor: 0) equals: maxInt64.

	assert: (minInt31 bitXor: minInt31) equals: 0.
	assert: (minInt32 bitXor: minInt32) equals: 0.
	assert: (minInt63 bitXor: minInt63) equals: 0.
	assert: (minInt64 bitXor: minInt64) equals: 0.
	assert: (maxInt31 bitXor: maxInt31) equals: 0.
	assert: (maxInt32 bitXor: maxInt32) equals: 0.
	assert: (maxInt63 bitXor: maxInt63) equals: 0.
	assert: (maxInt64 bitXor: maxInt64) equals: 0.

	assert: (minInt31 bitXor: maxInt31) equals: -1.
	assert: (minInt32 bitXor: maxInt32) equals: -1.
	assert: (minInt63 bitXor: maxInt63) equals: -1.
	assert: (minInt64 bitXor: maxInt64) equals: -1.

	assert: (maxInt32 bitXor: maxInt31) equals: 1073741824.
	assert: (maxInt63 bitXor: maxInt31) equals: 4611686017353646080.
	assert: (maxInt64 bitXor: maxInt31) equals: 9223372035781033984.

	assert: (maxInt63 bitXor: maxInt32) equals: 4611686016279904256.
	assert: (maxInt64 bitXor: maxInt32) equals: 9223372034707292160.

	assert: (maxInt64 bitXor: maxInt63) equals: 4611686018427387904.
)
public testSmallIntegerAnd = (
	assert: (1 bitAnd: 0) equals: 0.
	assert: (-1 bitAnd: 0) equals: 0.

	assert: (3 bitAnd: 1) equals: 1.
	assert: (-3 bitAnd: 1) equals: 1.

	assert: (3 bitAnd: 2) equals: 2.
	assert: (-3 bitAnd: 2) equals: 0.

	assert: (3 bitAnd: -1) equals: 3.
	assert: (-3 bitAnd: -1) equals: -3.
)
public testSmallIntegerAsFloat = (
	assert: 7 asFloat equals: (Float parse: '7.0').

	assert: maxInt31 asFloat equals: (Float parse: '1073741823.0').
	assert: minInt31 asFloat equals: (Float parse: '-1073741824.0').

	assert: 16rCAFECAFE asFloat equals: (Float parse: '3405695742.0').
)
public testSmallIntegerAsString = (
	assert: 3 asString equals: '3'.
	assert: -4 asString equals: '-4'.
	assert: 16rF asString equals: '15'.
	assert: maxInt31 asString equals: '1073741823'.
	assert: minInt31 asString equals: '-1073741824'.
)
public testSmallIntegerComparisonErrors = (
	deny: 42 = '42'.
	should: [42 < '42'] signal: Error.
	should: [42 > '42'] signal: Error.
	should: [42 <= '42'] signal: Error.
	should: [42 >= '42'] signal: Error.

	deny: 42 = {42}.
	should: [42 < {42}] signal: Error.
	should: [42 > {42}] signal: Error.
	should: [42 <= {42}] signal: Error.
	should: [42 >= {42}] signal: Error.
)
public testSmallIntegerComparisons = (
	assert: 42 = 42.
	deny: 42 < 42.
	deny: 42 > 42.
	assert: 42 <= 42.
	assert: 42 >= 42.

	deny: 3 = 4.
	assert: 3 < 4.
	deny: 3 > 4.
	assert: 3 <= 4.
	deny: 3 >= 4.

	deny: 5 = 7.
	assert: 5 < 7.
	deny: 5 > 7.
	assert: 5 <= 7.
	deny: 5 >= 7.

	deny: -5 = 7.
	assert: -5 < 7.
	deny: -5 > 7.
	assert: -5 <= 7.
	deny: -5 >= 7.

	deny: 5 = -7.
	deny: 5 < -7.
	assert: 5 > -7.
	deny: 5 <= -7.
	assert: 5 >= -7.

	deny: -5 = -7.
	deny: -5 < -7.
	assert: -5 > -7.
	deny: -5 <= -7.
	assert: -5 >= -7.
)
public testSmallIntegerDiv = (
	assert: -3 // 7 equals: -1.
	assert: 3 // -7 equals: -1.
	assert: -3 // -7 equals: 0.
	assert: 3 // 7 equals: 0.
	assert: -7 // 3 equals: -3.
	assert: 7 // -3 equals: -3.
	assert: -7 // -3 equals: 2.
	assert: 7 // 3  equals: 2.

	should: [42 // 0] signal: Error.

	assert: 0 // 42 equals: 0.
)
public testSmallIntegerDivideExact = (
	assert: 8 / 4 equals: 2.
	assert: 8 / 1 equals: 8.
	should: [8 / 0] signal: Error.
	assert: 0 / 8 equals: 0.

	assert: 3 / 3 equals: 1.
	assert: -3 / 3 equals: -1.
	assert: 3 / -3 equals: -1.
	assert: -3 / -3 equals: 1.
)
public testSmallIntegerDivideFraction = (
	assert: 4 / 6 equals: 2 / 3.
)
public testSmallIntegerInvert = (
	assert: 42 bitInvert equals: -43.
	assert: 1 bitInvert equals: -2.
	assert: 0 bitInvert equals: -1.
	assert: -1 bitInvert equals: 0.
	assert: -42 bitInvert equals: 41.
)
public testSmallIntegerMod = (
	assert: -3 \\ 7 equals: 4.
	assert: 3 \\ -7 equals: -4.
	assert: -3 \\ -7 equals: -3.
	assert: 3 \\ 7 equals: 3.
	assert: -7 \\ 3 equals: 2.
	assert: 7 \\ -3 equals: -2.
	assert: -7 \\ -3 equals: -1.
	assert: 7 \\ 3 equals: 1.

	should: [42 \\ 0] signal: Error.

	assert: 0 \\ 42 equals: 0.
)
public testSmallIntegerMultiplyOverflow = (
	(* On 64 bit: smi * smi -> large *)
	assert: minInt63 * 3 equals: -13835058055282163712.
	assert: maxInt63 * 3 equals: 13835058055282163709.

	assert: minInt63 * -3 equals: 13835058055282163712.
	assert: maxInt63 * -3 equals: -13835058055282163709.

	assert: minInt63 * minInt63 equals: 21267647932558653966460912964485513216.
	assert: maxInt63 * maxInt63 equals: 21267647932558653957237540927630737409.
)
public testSmallIntegerOperatorsInvalidArgument = (
	should: [0 + nil] signal: Error.
	should: [0 - nil] signal: Error.
	should: [0 / nil] signal: Error.
	should: [0 * nil] signal: Error.
	should: [0 // nil] signal: Error.
	should: [0 \\ nil] signal: Error.
	should: [0 quo: nil] signal: Error.
	should: [0 rem: nil] signal: Error.
	should: [0 << nil] signal: Error.
	should: [0 >> nil] signal: Error.
	should: [0 bitAnd: nil] signal: Error.
	should: [0 bitOr: nil] signal: Error.
	should: [0 bitXor: nil] signal: Error.
)
public testSmallIntegerOr = (
	assert: (1 bitOr: 0) equals: 1.
	assert: (-1 bitOr: 0) equals: -1.

	assert: (3 bitOr: 1) equals: 3.
	assert: (-3 bitOr: 1) equals: -3.

	assert: (3 bitOr: 2) equals: 3.
	assert: (-3 bitOr: 2) equals: -1.

	assert: (3 bitOr: -1) equals: -1.
	assert: (-3 bitOr: -1) equals: -1.
)
public testSmallIntegerQuo = (
	assert: (-3 quo: 7) equals: 0.
	assert: (3 quo: -7) equals: 0.
	assert: (-3 quo: -7) equals: 0.
	assert: (3 quo: 7) equals: 0.
	assert: (-7 quo: 3) equals: -2.
	assert: (7 quo: -3) equals: -2.
	assert: (-7 quo: -3) equals: 2.
	assert: (7 quo: 3) equals: 2.

	should: [42 quo: 0] signal: Error.

	assert: (0 quo: 42) equals: 0.
)
public testSmallIntegerRem = (
	assert: (-3 rem: 7) equals: -3.
	assert: (3 rem: -7) equals: 3.
	assert: (-3 rem: -7) equals: -3.
	assert: (3 rem: 7) equals: 3.
	assert: (-7 rem: 3) equals: -1.
	assert: (7 rem: -3) equals: 1.
	assert: (-7 rem: -3) equals: -1.
	assert: (7 rem: 3) equals: 1.

	should: [42 rem: 0] signal: Error.

	assert: (0 rem: 42) equals: 0.
)
public testSmallIntegerShiftLeft = (
	assert: 1 << 2 equals: 4.
	assert: -1 << 2 equals: -4.

	assert: 0 << 2 equals: 0.

	assert: 1 << 0 equals: 1.
	assert: -1 << 0 equals: -1.

	should: [4 << -1] signal: Error.
	should: [-4 << -1] signal: Error.
)
public testSmallIntegerShiftRight = (
	assert: 4 >> 2 equals: 1.
	assert: 4 >> 3 equals: 0. (* A bad implementation will put value bits into the tag bit. *)
	assert: 4 >> 31 equals: 0.
	assert: 4 >> 32 equals: 0.
	assert: 4 >> 33 equals: 0.
	assert: 4 >> 63 equals: 0.
	assert: 4 >> 64 equals: 0.
	assert: 4 >> 65 equals: 0.
	assert: 4 >> maxInt31 equals: 0.

	assert: -4 >> 2 equals: -1.
	assert: -4 >> 3 equals: -1.
	assert: -4 >> 31 equals: -1.
	assert: -4 >> 32 equals: -1.
	assert: -4 >> 33 equals: -1.
	assert: -4 >> 63 equals: -1.
	assert: -4 >> 64 equals: -1.
	assert: -4 >> 65 equals: -1.
	assert: -4 >> maxInt31 equals: -1.

	assert: 0 >> 2 equals: 0.

	assert: 4 >> 0 equals: 4.
	assert: -4 >> 0 equals: -4.

	should: [4 >> -1] signal: Error.
	should: [-4 >> -1] signal: Error.
	should: [4 >> minInt31] signal: Error.
	should: [-4 >> minInt31] signal: Error.
)
public testSmallIntegerXor = (
	assert: (42 bitXor: 42) equals: 0.

	assert: (1 bitXor: 0) equals: 1.
	assert: (-1 bitXor: 0) equals: -1.

	assert: (3 bitXor: 1) equals: 2.
	assert: (-3 bitXor: 1) equals: -4.

	assert: (3 bitXor: 2) equals: 1.
	assert: (-3 bitXor: 2) equals: -1.

	assert: (3 bitXor: -1) equals: -4.
	assert: (-3 bitXor: -1) equals: 2.
)
public testIntegerRaisedTo = (
	| r |
	r:: 0 ** 0.
	assert: r isKindOfInteger.
	assert: r equals: 1.
	r:: 10 ** 1.
	assert: r isKindOfInteger.
	assert: r equals: 10.
	r:: 10 ** 2.
	assert: r isKindOfInteger.
	assert: r equals: 100.
	r:: 10 ** 3.
	assert: r isKindOfInteger.
	assert: r equals: 1000.
	r:: 10 ** 4.
	assert: r isKindOfInteger.
	assert: r equals: 10000.
	r:: 10 ** 5.
	assert: r isKindOfInteger.
	assert: r equals: 100000.
	r:: 10 ** 6.
	assert: r isKindOfInteger.
	assert: r equals: 1000000.
	r:: 10 ** 7.
	assert: r isKindOfInteger.
	assert: r equals: 10000000.

	r:: 10 ** -1.
	assert: r isKindOfFraction.
	assert: r equals: 1/10.
	r:: 10 ** -2.
	assert: r isKindOfFraction.
	assert: r equals: 1/100.
	r:: 10 ** -3.
	assert: r isKindOfFraction.
	assert: r equals: 1/1000.

	(* Even exponent *)
	r:: 1984 ** 10.
	assert: r isKindOfInteger.
	assert: r equals:  944967077844237655443063256907776.
	r:: 1984 ** -10.
	assert: r isKindOfFraction.
	assert: r equals: 1/944967077844237655443063256907776.
	r:: -1984 ** 10.
	assert: r isKindOfInteger.
	assert: r equals:  944967077844237655443063256907776.
	r:: -1984 ** -10.
	assert: r isKindOfFraction.
	assert: r equals: 1/944967077844237655443063256907776.

	(* Odd exponent *)
	r:: 1984 ** 5.
	assert: r isKindOfInteger.
	assert: r equals: 30740316814311424.
	r:: 1984 ** -5.
	assert: r isKindOfFraction.
	assert: r equals:  1/30740316814311424.
	r:: -1984 ** 5.
	assert: r isKindOfInteger.
	assert: r equals: -30740316814311424.
	r:: -1984 ** -5.
	assert: r isKindOfFraction.
	assert: r equals:  -1/30740316814311424.
)
) : (
TEST_CONTEXT = ()
)
public class ObjectTests = TestContext () (
public testClassProtected = (
	| o = Object new. |
	should: [o class] signal: MessageNotUnderstood.
	shouldnt: [self class] signal: MessageNotUnderstood.
)
public testDoesNotUnderstand = (
	| o = Object new. p = DnuAnswerMessage new. |
	should: [o foobar] signal: MessageNotUnderstood.

	assert: p foobar selector equals: #foobar.
	assert: p foobar arguments isKindOfArray.
	assert: p foobar arguments size equals: 0.

	assert: (p + 42) selector equals: #+.
	assert: (p + 42) arguments isKindOfArray.
	assert: (p + 42) arguments size equals: 1.
	assert: ((p + 42) arguments at: 1) equals: 42.

	assert: (p with: 3 with: 4) selector equals: #with:with:.
	assert: (p with: 3 with: 4) arguments isKindOfArray.
	assert: (p with: 3 with: 4) arguments size equals: 2.
	assert: ((p with: 3 with: 4) arguments at: 1) equals: 3.
	assert: ((p with: 3 with: 4) arguments at: 2) equals: 4.
)
public testEquals = (
	| a b |
	a:: Object new.
	b:: Object new.

	assert: a = a.
	assert: b = b.
	deny: a = b.
	deny: b = a.
)
public testGlobalsProtected = (
	| o = Object new. |
	should: [o Array] signal: MessageNotUnderstood.
	should: [o ByteArray] signal: MessageNotUnderstood.
	should: [o Error] signal: MessageNotUnderstood.
	should: [o Exception] signal: MessageNotUnderstood.
	should: [o Float] signal: MessageNotUnderstood.
	should: [o Integer] signal: MessageNotUnderstood.
	should: [o Object] signal: MessageNotUnderstood.
	should: [o String] signal: MessageNotUnderstood.
	should: [o Symbol] signal: MessageNotUnderstood.
	should: [o Future] signal: MessageNotUnderstood.
	should: [o Delay] signal: MessageNotUnderstood.
	should: [o WeakArray] signal: MessageNotUnderstood.
)
public testHash = (
	| o = Object new. |
	assert: o hash isKindOfInteger.
	assert: o hash > 0.
)
public testNonBooleanIfFalse = (
	(* According to the language, this ought to signal MessageNotUnderstood. However, our implementations do the standard cheat that compiles various control messages without creating their closure arguments, and raises NonBooleanReceiver if the receiver ends being something other than true or false. This test checks this is at least not fatal. *)
	| o = Object new. |
	should: [o ifFalse: []] signal: Exception.
)
public testNonBooleanIfTrue = (
	(* According to the language, this ought to signal MessageNotUnderstood. However, our implementations do the standard cheat that compiles various control messages without creating their closure arguments, and raises NonBooleanReceiver if the receiver ends being something other than true or false. This test checks this is at least not fatal. *)
	| o = Object new. |
	should: [o ifTrue: []] signal: Exception.
)
public testNonBooleanWhileFalse = (
	(* According to the language, this ought to signal MessageNotUnderstood. However, our implementations do the standard cheat that compiles various control messages without creating their closure arguments, and raises NonBooleanReceiver if the receiver ends being something other than true or false. This test checks this is at least not fatal. *)
	| o = Object new. |
	should: [[o] whileFalse: []] signal: Exception.
)
public testNonBooleanWhileTrue = (
	(* According to the language, this ought to signal MessageNotUnderstood. However, our implementations do the standard cheat that compiles various control messages without creating their closure arguments, and raises NonBooleanReceiver if the receiver ends being something other than true or false. This test checks this is at least not fatal. *)
	| o = Object new. |
	should: [[o] whileTrue: []] signal: Exception.
)
public testNotPolymorphicWithClosure = (
	| o = Object new. |
	should: [o value] signal: MessageNotUnderstood.
)
public testPrintString = (
	| o = Object new. |
	assert: o printString isKindOfString.
	assert: o printString size > 0.
)
public testYourself = (
	| o = Object new. |
	assert: o yourself equals: o.
)
) : (
TEST_CONTEXT = ()
)
public class StopwatchTests = TestContext () (
busyMilliseconds: millis = (
	| stopwatch = Stopwatch new. |
	stopwatch start.
	[stopwatch elapsedMilliseconds < millis] whileTrue.
)
public testStopwatchAccumulate = (
	| stopwatch = Stopwatch new. |
	stopwatch start.
	busyMilliseconds: 5.
	stopwatch stop.
	assert: [stopwatch elapsedMilliseconds >= 5].
	assert: [stopwatch elapsedMicroseconds >= 5000].

	busyMilliseconds: 5.

	stopwatch start.
	busyMilliseconds: 5.
	stopwatch stop.
	assert: [stopwatch elapsedMilliseconds >= 10].
	assert: [stopwatch elapsedMicroseconds >= 10000].

	busyMilliseconds: 5.

	stopwatch start.
	busyMilliseconds: 5.
	stopwatch stop.
	assert: [stopwatch elapsedMilliseconds >= 15].
	assert: [stopwatch elapsedMicroseconds >= 15000].
)
public testStopwatchDoubleStart = (
	| stopwatch = Stopwatch new. |
	stopwatch start.

	busyMilliseconds: 5.

	stopwatch start. (* Should not reset the elapsed time. *)

	busyMilliseconds: 5.

	assert: [stopwatch elapsedMilliseconds >= 10].
	assert: [stopwatch elapsedMicroseconds >= 10000].
	stopwatch stop.
	assert: [stopwatch elapsedMilliseconds >= 10].
	assert: [stopwatch elapsedMicroseconds >= 10000].
)
public testStopwatchEqualityIsIdentity = (
	|
	stopwatch1 = Stopwatch new.
	stopwatch2 = Stopwatch new.
	|
	assert: stopwatch1 elapsedMilliseconds equals: stopwatch2 elapsedMilliseconds.
	assert: stopwatch1 elapsedMicroseconds equals: stopwatch2 elapsedMicroseconds.
	deny: stopwatch1 equals: stopwatch2.
)
public testStopwatchInitialState = (
	| stopwatch = Stopwatch new. |
	assert: stopwatch elapsedMilliseconds equals: 0.
	assert: stopwatch elapsedMicroseconds equals: 0.
)
public testStopwatchInitiallyStopped = (
	| stopwatch = Stopwatch new. |
	busyMilliseconds: 5.

	assert: stopwatch elapsedMilliseconds equals: 0.
	assert: stopwatch elapsedMicroseconds equals: 0.
)
public testStopwatchMovesAfterStarted = (
	| stopwatch |
	stopwatch:: Stopwatch new.
	stopwatch start.
	[stopwatch elapsedMilliseconds < 5] whileTrue.

	stopwatch:: Stopwatch new.
	stopwatch start.
	[stopwatch elapsedMicroseconds < 5] whileTrue.
)
public testStopwatchStartStopValues = (
	| stopwatch = Stopwatch new. |
	assert: stopwatch start equals: stopwatch.
	assert: stopwatch stop equals: stopwatch.
)
) : (
TEST_CONTEXT = ()
)
public class StringBuilderTests = TestContext () (
public testIsKindOfStringBuilder = (
	deny: {} isKindOfStringBuilder.
	deny: (Array new: 0) isKindOfStringBuilder.
	deny: (ByteArray new: 0) isKindOfStringBuilder.
	assert: StringBuilder new isKindOfStringBuilder.
	deny: '' isKindOfStringBuilder.
	deny: nil isKindOfStringBuilder.
	deny: false isKindOfStringBuilder.
	deny: true isKindOfStringBuilder.
	deny: 0 isKindOfStringBuilder.
)
public testStringBuilderAddByte = (
	| builder = StringBuilder new. string |
	assert: builder size equals: 0.

	65 to: 90 do: [:byte | builder addByte: byte].

	string:: builder asString.
	assert: string isKindOfString.
	assert: string size equals: 26.
	assert: string equals: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.

	assert: builder size equals: 26.
)
public testStringBuilderAsByteArray = (
	| builder = StringBuilder new. bytes |
	assert: builder size equals: 0.

	builder add: 'apple'.
	assert: builder size equals: 5.

	builder add: 'banana'.
	assert: builder size equals: 11.

	builder add: 'orange'.
	assert: builder size equals: 17.

	bytes:: builder asByteArray.
	assert: bytes isKindOfByteArray.
	assert: bytes size equals: 17.

	assert: builder size equals: 17.
)
public testStringBuilderAsString = (
	| builder = StringBuilder new. string |
	assert: builder size equals: 0.

	builder add: 'apple'.
	assert: builder size equals: 5.

	builder add: 'banana'.
	assert: builder size equals: 11.

	builder add: 'orange'.
	assert: builder size equals: 17.

	string:: builder asString.
	assert: string isKindOfString.
	assert: string size equals: 17.
	assert: string equals: 'applebananaorange'.

	assert: builder size equals: 17.
)
public testStringBuilderEqualityIsIdentity = (
	|
	empty1 = StringBuilder new.
	empty2 = StringBuilder new.
	simple1 = StringBuilder new.
	simple2 = StringBuilder new.
	|
	simple1 add: 'strawberry'.
	simple2 add: 'strawberry'.

	assert: empty1 equals: empty1.
	assert: empty2 equals: empty2.
	deny: empty1 equals: empty2.
	deny: empty2 equals: empty1.

	assert: simple1 equals: simple1.
	assert: simple2 equals: simple2.
	deny: simple1 equals: simple2.
	deny: simple2 equals: simple1.
)
public testStringBuilderIsEmpty = (
	| builder |
	assert: StringBuilder new isEmpty.
	assert: (StringBuilder new: 16) isEmpty.

	builder:: StringBuilder new.
	assert: builder isEmpty.
	builder add: #element.
	deny: builder isEmpty.
)
public testStringBuilderNew = (
	assert: (StringBuilder new) size equals: 0.
	assert: (StringBuilder new: 0) size equals: 0.
	assert: (StringBuilder new: 16) size equals: 0.

	should: [StringBuilder new: -1] signal: Error.
	should: [StringBuilder new: '10'] signal: Error.
	should: [StringBuilder new: nil] signal: Error.
)
) : (
TEST_CONTEXT = ()
)
public class StringTests = TestContext () (
public testIsKindOfString = (
	assert: 'foo' isKindOfString.
	assert: #foo isKindOfString.
	assert: ('foo', 'bar') isKindOfString.
	assert: 'Îñţérñåţîöñåļîžåţîờñ' isKindOfString.
	deny: 1 isKindOfString.
	deny: 1.5 isKindOfString.
	deny: 1.5 asFloat isKindOfString.
	deny: true isKindOfString.
	deny: nil isKindOfString.
	deny: {} isKindOfString.
	deny: [] isKindOfString.
)
public testStringAdd = (
	should: ['foo' + 'bar'] signal: MessageNotUnderstood.
)
public testStringAsString = (
	assert: 'foo' asString equals: 'foo'.
	assert: #foo asString equals: 'foo'.
)
public testStringAt = (
	assert: ('foo' at: 1) equals: 102.
	assert: ('foo' at: 2) equals: 111.
	assert: ('foo' at: 3) equals: 111.

	should: ['foo' at: 0] signal: Error.
	should: ['foo' at: 4] signal: Error.

	should: ['' at: 0] signal: Error.

	should: ['foo' at: -1] signal: Error.
	should: ['foo' at: nil] signal: Error.
	should: ['foo' at: 1 asFloat] signal: Error.
)
public testStringConcatenation = (
	assert: 'foo' , 'bar' equals: 'foobar'.
	assert: 'foo' , 'bar', '' equals: 'foobar'.
	assert: ('foo' , 'bar') size equals: 6.

	should: ['foo', 3] signal: Error.
	should: ['foo', true] signal: Error.
	should: ['foo', nil] signal: Error.
	should: [3, 'foo'] signal: MessageNotUnderstood.
	should: [true, 'foo'] signal: MessageNotUnderstood.
	should: [nil, 'foo'] signal: MessageNotUnderstood.
)
public testStringCopyByteArrayFromTo = (
	| copy |
	copy:: ('Hello, world!' copyByteArrayFrom: 8 to: 12).
	assert: copy size equals: 5.
	assert: (copy at: 1) equals: 119.
	assert: (copy at: 5) equals: 100.
	copy:: 'Hello, world!' copyByteArrayFrom: 5 to: 5.
	assert: copy size equals: 1.
	assert: (copy at: 1) equals: 111.

	1 to: 5 do:
		[:start | assert: ('Hello' copyByteArrayFrom: start to: start - 1) size equals: 0].

	assert: ('' copyByteArrayFrom: 1 to: 0) size equals: 0.

	should: ['' copyByteArrayFrom: 0 to: 0] signal: Error.
	should: ['' copyByteArrayFrom: 2 to: 0] signal: Error.
	should: ['' copyByteArrayFrom: 1 to: 1] signal: Error.

	should: ['Hello, world!' copyByteArrayFrom: 13 to: 14] signal: Error.
	should: ['Hello, world!' copyByteArrayFrom: 0 to: 1] signal: Error.
	should: ['Hello, world!' copyByteArrayFrom: 8 to: nil] signal: Error.
	should: ['Hello, world!' copyByteArrayFrom: nil to: 9] signal: Error.
	should: ['Hello, world!' copyByteArrayFrom: 2 to: 90] signal: Error.
	should: ['Hello, world!' copyByteArrayFrom: 80 to: 90] signal: Error.
	should: ['Hello, world!' copyByteArrayFrom: 2 to: 5 asFloat] signal: Error.
	should: ['Hello, world!' copyByteArrayFrom: 2 asFloat to: 5] signal: Error.
)
public testStringCopyFromTo = (
	assert: ('Hello, world!' copyFrom: 8 to: 12) equals: 'world'.
	assert: ('Hello, world!' copyFrom: 5 to: 5) equals: 'o'.

	1 to: 5 do:
		[:start | assert: ('Hello' copyFrom: start to: start - 1) equals: ''].

	assert: ('' copyFrom: 1 to: 0) equals: ''.

	should: ['' copyFrom: 0 to: 0] signal: Error.
	should: ['' copyFrom: 2 to: 0] signal: Error.
	should: ['' copyFrom: 1 to: 1] signal: Error.

	should: ['Hello, world!' copyFrom: 13 to: 14] signal: Error.
	should: ['Hello, world!' copyFrom: 0 to: 1] signal: Error.
	should: ['Hello, world!' copyFrom: 8 to: nil] signal: Error.
	should: ['Hello, world!' copyFrom: nil to: 9] signal: Error.
	should: ['Hello, world!' copyFrom: 2 to: 90] signal: Error.
	should: ['Hello, world!' copyFrom: 80 to: 90] signal: Error.
	should: ['Hello, world!' copyFrom: 2 to: 5 asFloat] signal: Error.
	should: ['Hello, world!' copyFrom: 2 asFloat to: 5] signal: Error.
)
public testStringCopyStringFromTo = (
	assert: ('Hello, world!' copyStringFrom: 8 to: 12) equals: 'world'.
	assert: ('Hello, world!' copyStringFrom: 5 to: 5) equals: 'o'.

	1 to: 5 do:
		[:start | assert: ('Hello' copyStringFrom: start to: start - 1) equals: ''].

	assert: ('' copyStringFrom: 1 to: 0) equals: ''.

	should: ['' copyStringFrom: 0 to: 0] signal: Error.
	should: ['' copyStringFrom: 2 to: 0] signal: Error.
	should: ['' copyStringFrom: 1 to: 1] signal: Error.

	should: ['Hello, world!' copyStringFrom: 13 to: 14] signal: Error.
	should: ['Hello, world!' copyStringFrom: 0 to: 1] signal: Error.
	should: ['Hello, world!' copyStringFrom: 8 to: nil] signal: Error.
	should: ['Hello, world!' copyStringFrom: nil to: 9] signal: Error.
	should: ['Hello, world!' copyStringFrom: 2 to: 90] signal: Error.
	should: ['Hello, world!' copyStringFrom: 80 to: 90] signal: Error.
	should: ['Hello, world!' copyStringFrom: 2 to: 5 asFloat] signal: Error.
	should: ['Hello, world!' copyStringFrom: 2 asFloat to: 5] signal: Error.
)
public testStringEndsWith = (
	| foo empty |
	foo:: ByteArray new: 3.
	foo at: 1 put: 102.
	foo at: 2 put: 111.
	foo at: 3 put: 111.
	empty:: ByteArray new: 0.

	assert: ('foo' endsWith: 'o').
	assert: ('foo' endsWith: 'foo').
	assert: ('foo' endsWith: foo).
	assert: ('foo' endsWith: '').
	assert: ('foo' endsWith: empty).
	assert: ('' endsWith: '').
	assert: ('' endsWith: empty).
	deny: ('foo' endsWith: 'toolongfoo').
	deny: ('foo' endsWith: 'boo').
	deny: ('foo' endsWith: 'bar').
	deny: ('' endsWith: 'foo').
	deny: ('' endsWith: foo).

	should: ['0' endsWith: 0] signal: Error.
	should: ['foo' endsWith: true] signal: Error.
	should: ['foo' endsWith: nil] signal: Error.
)
public testStringEquals = (
	assert: 'foo' equals: 'foo'.
	assert: #foo equals: 'foo'.
	assert: 'foo' equals: #foo.

	deny: 'foo' = 'bar'.
	deny: '3' = 3.
	deny: 3 = '3'.
)
public testStringFirstLast = (
	assert: ('bar' first) equals: 98.
	assert: ('bar' last) equals: 114.

	should: ['' first] signal: Error.
	should: ['' last] signal: Error.
)
public testStringFloatIndex = (
	should: ['foo' at: 1 asFloat] signal: Error.
)
public testStringHash = (
	assert: 'foo' hash isKindOfInteger.
	assert: 'foo' hash > 0.

	assert: 'foobar' hash equals: ('foo', 'bar') hash.

	assert: '' hash isKindOfInteger.
	assert: '' hash > 0.
)
public testStringImmutable = (
	| nonSymbol |
	nonSymbol:: 'foo' , 'bar'.

	should: [nonSymbol at: 1 put: "w"] signal: MessageNotUnderstood.
	assert: nonSymbol equals: 'foobar'.

	should: [nonSymbol at: 1 put: 65] signal: MessageNotUnderstood.
	assert: nonSymbol equals: 'foobar'.
)
public testStringIndexOf = (
	assert: ('fofofobar' indexOf: 'fofo') equals: 1.
	assert: ('fofofobar' indexOf: 'bar') equals: 7.
	assert: ('fofofobar' indexOf: 'barr') equals: 0.
	assert: ('fofofobar' indexOf: 'fob') equals: 5.
	assert: ('fofofobar' indexOf: 'baz') equals: 0.
	assert: ('fofofobar' indexOf: 'f') equals: 1.
	assert: ('fofofobar' indexOf: 'r') equals: 9.
	assert: ('fofofobar' indexOf: '') equals: 1.

	assert: ('tiny' indexOf: 'toolong') equals: 0.

	assert: ('' indexOf: '') equals: 1.
	assert: ('' indexOf: 'baz') equals: 0.

	should: ['fofofobar' indexOf: 0] signal: Error.
	should: ['' indexOf: Object new] signal: Error.
)
public testStringIndexOfStartingAt = (
	assert: ('fofofobar' indexOf: 'fofo' startingAt: 1) equals: 1.
	assert: ('fofofobar' indexOf: 'fofo' startingAt: 2) equals: 3.
	assert: ('fofofobar' indexOf: 'fofo' startingAt: 3) equals: 3.
	assert: ('fofofobar' indexOf: 'fofo' startingAt: 4) equals: 0.
	assert: ('fofofobar' indexOf: 'bar' startingAt: 1) equals: 7.
	assert: ('fofofobar' indexOf: 'bar' startingAt: 7) equals: 7.
	assert: ('fofofobar' indexOf: 'bar' startingAt: 8) equals: 0.
	assert: ('fofofobar' indexOf: 'barr' startingAt: 6) equals: 0.
	assert: ('fofofobar' indexOf: 'fob' startingAt: 5) equals: 5.
	assert: ('fofofobar' indexOf: 'fob' startingAt: 6) equals: 0.
	assert: ('fofofobar' indexOf: 'baz' startingAt: 1) equals: 0.
	assert: ('fofofobar' indexOf: 'f' startingAt: 1) equals: 1.
	assert: ('fofofobar' indexOf: 'f' startingAt: 2) equals: 3.
	assert: ('fofofobar' indexOf: 'r' startingAt: 1) equals: 9.
	assert: ('fofofobar' indexOf: 'r' startingAt: 9) equals: 9.
	assert: ('fofofobar' indexOf: '' startingAt: 1) equals: 1.
	assert: ('fofofobar' indexOf: '' startingAt: 5) equals: 5.
	assert: ('fofofobar' indexOf: '' startingAt: 9) equals: 9.

	assert: ('tiny' indexOf: 'toolong' startingAt: 1) equals: 0.
	assert: ('tiny' indexOf: 'toolong' startingAt: 3) equals: 0.

	assert: ('' indexOf: '' startingAt: 1) equals: 1.
	assert: ('' indexOf: 'baz' startingAt: 1) equals: 0.

	should: ['fofofobar' indexOf: 0 startingAt: 1] signal: Error.
	should: ['fofobobar' indexOf: Object new startingAt: 1] signal: Error.

	should: ['fofofobar' indexOf: 'foo' startingAt: 0] signal: Error.
	should: ['fofofobar' indexOf: 'foo' startingAt: 11] signal: Error.
	should: ['' indexOf: '' startingAt: 0] signal: Error.
	should: ['' indexOf: '' startingAt: 2] signal: Error.
)
public testStringIsEmpty = (
	assert: '' isEmpty.
	deny: 'zebra' isEmpty.
)
public testStringLastIndexOf = (
	assert: ('fofofobar' lastIndexOf: 'fofo') equals: 3.
	assert: ('fofofobar' lastIndexOf: 'bar') equals: 7.
	assert: ('fofofobar' lastIndexOf: 'barr') equals: 0.
	assert: ('fofofobar' lastIndexOf: 'fob') equals: 5.
	assert: ('fofofobar' lastIndexOf: 'baz') equals: 0.
	assert: ('fofofobar' lastIndexOf: 'f') equals: 5.
	assert: ('fofofobar' lastIndexOf: 'r') equals: 9.
	assert: ('fofofobar' lastIndexOf: '') equals: 10.

	assert: ('tiny' lastIndexOf: 'toolong') equals: 0.

	assert: ('' lastIndexOf: '') equals: 1.
	assert: ('' lastIndexOf: 'baz') equals: 0.

	should: ['fofofobar' lastIndexOf: 0] signal: Error.
	should: ['' lastIndexOf: Object new] signal: Error.
)
public testStringLastIndexOfStartingAt = (
	assert: ('fofofobar' lastIndexOf: 'fofo' startingAt: 10) equals: 3.
	assert: ('fofofobar' lastIndexOf: 'fofo' startingAt: 4) equals: 3.
	assert: ('fofofobar' lastIndexOf: 'fofo' startingAt: 3) equals: 3.
	assert: ('fofofobar' lastIndexOf: 'fofo' startingAt: 1) equals: 1.
	assert: ('fofofobar' lastIndexOf: 'bar' startingAt: 10) equals: 7.
	assert: ('fofofobar' lastIndexOf: 'bar' startingAt: 7) equals: 7.
	assert: ('fofofobar' lastIndexOf: 'bar' startingAt: 6) equals: 0.
	assert: ('fofofobar' lastIndexOf: 'barr' startingAt: 10) equals: 0.
	assert: ('fofofobar' lastIndexOf: 'fob' startingAt: 10) equals: 5.
	assert: ('fofofobar' lastIndexOf: 'fob' startingAt: 4) equals: 0.
	assert: ('fofofobar' lastIndexOf: 'baz' startingAt: 10) equals: 0.
	assert: ('fofofobar' lastIndexOf: 'f' startingAt: 10) equals: 5.
	assert: ('fofofobar' lastIndexOf: 'f' startingAt: 4) equals: 3.
	assert: ('fofofobar' lastIndexOf: 'f' startingAt: 2) equals: 1.
	assert: ('fofofobar' lastIndexOf: 'r' startingAt: 10) equals: 9.
	assert: ('fofofobar' lastIndexOf: 'r' startingAt: 9) equals: 9.
	assert: ('fofofobar' lastIndexOf: 'r' startingAt: 8) equals: 0.
	assert: ('fofofobar' lastIndexOf: '' startingAt: 10) equals: 10.
	assert: ('fofofobar' lastIndexOf: '' startingAt: 5) equals: 5.
	assert: ('fofofobar' lastIndexOf: '' startingAt: 1) equals: 1.

	assert: ('tiny' lastIndexOf: 'toolong' startingAt: 4) equals: 0.
	assert: ('tiny' lastIndexOf: 'toolong' startingAt: 2) equals: 0.

	assert: ('' lastIndexOf: '' startingAt: 1) equals: 1.
	assert: ('' lastIndexOf: 'baz' startingAt: 1) equals: 0.

	should: ['fofofobar' lastIndexOf: 0 startingAt: 1] signal: Error.
	should: ['' lastIndexOf: Object new startingAt: 1] signal: Error.

	should: ['fofofobar' lastIndexOf: 'foo' startingAt: 0] signal: Error.
	should: ['fofofobar' lastIndexOf: 'foo' startingAt: 11] signal: Error.
	should: ['' lastIndexOf: '' startingAt: 0] signal: Error.
	should: ['' lastIndexOf: '' startingAt: 2] signal: Error.
)
public testStringSize = (
	assert: 'foo' size equals: 3.
	assert: #foo size equals: 3.
	assert: '' size equals: 0.
)
public testStringStartsWith = (
	| foo empty |
	foo:: ByteArray new: 3.
	foo at: 1 put: 102.
	foo at: 2 put: 111.
	foo at: 3 put: 111.
	empty:: ByteArray new: 0.

	assert: ('foo' startsWith: 'f').
	assert: ('foo' startsWith: 'foo').
	assert: ('foo' startsWith: foo).
	assert: ('foo' startsWith: '').
	assert: ('foo' startsWith: empty).
	assert: ('' startsWith: '').
	assert: ('' startsWith: empty).
	deny: ('foo' startsWith: 'toolong').
	deny: ('foo' startsWith: 'fob').
	deny: ('foo' startsWith: 'bar').
	deny: ('' startsWith: 'foo').
	deny: ('' startsWith: foo).

	should: ['0' startsWith: 0] signal: Error.
	should: ['foo' startsWith: true] signal: Error.
	should: ['foo' startsWith: nil] signal: Error.
)
public testStringWith = (
	assert: (String with: 122) equals: 'z'.
	assert: ((String with: 0) at: 1) equals: 0.

	should: [String with: -1] signal: Error.
	should: [String with: 16r110000] signal: Error.
	should: [String with: nil] signal: Error.
	should: [String with: 122 asFloat] signal: Error.
	should: [String with: 'z'] signal: Error.
)
public testStringWithAll = (
	| bytearray list result |
	result:: String withAll: {122}.
	assert: result size equals: 1.
	assert: result equals: 'z'.

	result:: String withAll: {122. 101. 98. 114. 97}.
	assert: result size equals: 5.
	assert: result equals: 'zebra'.
	assert: (result at: 1) equals: 122.
	assert: (result at: 2) equals: 101.
	assert: (result at: 3) equals: 98.
	assert: (result at: 4) equals: 114.
	assert: (result at: 5) equals: 97.

	bytearray:: ByteArray new: 0.
	result:: String withAll: bytearray.
	assert: result size equals: 0.
	assert: result equals: ''.

	bytearray:: ByteArray new: 1.
	bytearray at: 1 put: 122.
	result:: String withAll: bytearray.
	assert: result size equals: 1.
	assert: result equals: 'z'.

	bytearray:: ByteArray new: 5.
	bytearray at: 1 put: 122.
	bytearray at: 2 put: 101.
	bytearray at: 3 put: 98.
	bytearray at: 4 put: 114.
	bytearray at: 5 put: 97.
	result:: String withAll: bytearray.
	assert: result size equals: 5.
	assert: result equals: 'zebra'.
	assert: (result at: 1) equals: 122.
	assert: (result at: 2) equals: 101.
	assert: (result at: 3) equals: 98.
	assert: (result at: 4) equals: 114.
	assert: (result at: 5) equals: 97.

	result:: String withAll: ''.
	assert: result size equals: 0.
	assert: result equals: ''.

	result:: String withAll: 'soup'.
	assert: result size equals: 4.
	assert: result equals: 'soup'.
	assert: (result at: 1) equals: 115.
	assert: (result at: 2) equals: 111.
	assert: (result at: 3) equals: 117.
	assert: (result at: 4) equals: 112.

	list:: List new.
	list add: 102.
	list add: 111.
	list add: 120.
	result:: String withAll: list.
	assert: result size equals: 3.
	assert: result equals: 'fox'.
	assert: (result at: 1) equals: 102.
	assert: (result at: 2) equals: 111.
	assert: (result at: 3) equals: 120.

	should: [String withAll: -1] signal: Error.
	should: [String withAll: 16r110000] signal: Error.
	should: [String withAll: nil] signal: Error.
	should: [String withAll: 122 asFloat] signal: Error.

	should: [String withAll: {-1}] signal: Error.
	should: [String withAll: {16r256}] signal: Error.
	should: [String withAll: {nil}] signal: Error.
	should: [String withAll: {122 asFloat}] signal: Error.
	should: [String withAll: {'z'}] signal: Error.

	list:: List new.
	list add: 256.
	should: [String withAll: list] signal: Error.
)
public testWideStringAsString = (
	assert: 'Îñţérñåţîöñåļîžåţîờñ' asString equals: 'Îñţérñåţîöñåļîžåţîờñ'.
	assert: #'Îñţérñåţîöñåļîžåţîờñ' asString equals: 'Îñţérñåţîöñåļîžåţîờñ'.
)
public testWideStringAt = (
	assert: ('Îñţérñåţîöñåļîžåţîờñ' at: 1) equals: 195.
	assert: ('Îñţérñåţîöñåļîžåţîờñ' at: 2) equals: 142.
	assert: ('Îñţérñåţîöñåļîžåţîờñ' at: 3) equals: 195.
	assert: ('Îñţérñåţîöñåļîžåţîờñ' at: 15) equals: 163.
	assert: ('Îñţérñåţîöñåļîžåţîờñ' at: 20) equals: 195.
	assert: ('Îñţérñåţîöñåļîžåţîờñ' at: 36) equals: 225.
	assert: ('Îñţérñåţîöñåļîžåţîờñ' at: 37) equals: 187.
	assert: ('Îñţérñåţîöñåļîžåţîờñ' at: 38) equals: 157.
	assert: ('Îñţérñåţîöñåļîžåţîờñ' at: 40) equals: 177.

	should: ['Îñţérñåţîöñåļîžåţîờñ' at: 0] signal: Error.
	should: ['Îñţérñåţîöñåļîžåţîờñ' at: 41] signal: Error.

	should: ['Îñţérñåţîöñåļîžåţîờñ' at: -1] signal: Error.
	should: ['Îñţérñåţîöñåļîžåţîờñ' at: nil] signal: Error.
	should: ['Îñţérñåţîöñåļîžåţîờñ' at: 1 asFloat] signal: Error.
)
public testWideStringConcatenation = (
	assert: 'Îñţérñåţîöñåļ' , 'îžåţîờñ' equals: 'Îñţérñåţîöñåļîžåţîờñ'.
	assert: 'Îñţérñåţîöñåļ' , 'îžåţîờñ', '' equals: 'Îñţérñåţîöñåļîžåţîờñ'.
	assert: ('Îñţérñåţîöñåļ' , 'îžåţîờñ') size equals: 40.

	assert: 'Îñţérñåţîöñåļ' , 'ASCII' equals: 'ÎñţérñåţîöñåļASCII'.
	assert: 'Îñţérñåţîöñåļ' , 'ASCII', '' equals: 'ÎñţérñåţîöñåļASCII'.
	assert: ('Îñţérñåţîöñåļ' , 'ASCII') size equals: 30.

	assert: 'ASCII' , 'Îñţérñåţîöñåļ' equals: 'ASCIIÎñţérñåţîöñåļ'.
	assert: 'ASCII' , 'Îñţérñåţîöñåļ', '' equals: 'ASCIIÎñţérñåţîöñåļ'.
	assert: ('ASCII' , 'Îñţérñåţîöñåļ') size equals: 30.

	should: ['Îñţérñåţîöñåļ', 3] signal: Error.
	should: ['Îñţérñåţîöñåļ', true] signal: Error.
	should: ['Îñţérñåţîöñåļ', nil] signal: Error.
	should: [3, 'Îñţérñåţîöñåļ'] signal: MessageNotUnderstood.
	should: [true, 'Îñţérñåţîöñåļ'] signal: MessageNotUnderstood.
	should: [nil, 'Îñţérñåţîöñåļ'] signal: MessageNotUnderstood.
)
public testWideStringCopyFromTo = (
	assert: ('Îñţérñåţîöñåļîžåţîờñ' copyFrom: 10 to: 25) equals: 'ñåţîöñåļ'.
	assert: ('Îñţérñåţîöñåļîžåţîờñ' copyFrom: 5 to: 6) equals: 'ţ'.
	assert: ('Îñţérñåţîöñåļîžåţîờñ ASCII' copyFrom: 42 to: 46) equals: 'ASCII'.

	should: ['Îñţérñåţîöñåļîžåţîờñ' copyFrom: 8 to: nil] signal: Error.
	should: ['Îñţérñåţîöñåļîžåţîờñ' copyFrom: nil to: 9] signal: Error.
	should: ['Îñţérñåţîöñåļîžåţîờñ' copyFrom: 80 to: 90] signal: Error.
)
public testWideStringEndsWith = (
	assert: ('Îñţérñåţîöñåļîžåţîờñ' endsWith: 'ñ').
	assert: ('Îñţérñåţîöñåļîžåţîờñ' endsWith: 'Îñţérñåţîöñåļîžåţîờñ').
	assert: ('Îñţérñåţîöñåļîžåţîờñ' endsWith: '').
	deny: ('Îñţérñåţîöñåļîžåţîờñ' endsWith: 'ÎñţérñåţîöñåļîžåţîờñÎñţérñåţîöñåļîžåţîờñ').
	deny: ('Îñţérñåţîöñåļîžåţîờñ' endsWith: 'Îñţérîžåţîờñ').
	deny: ('Îñţérñåţîöñåļîžåţîờñ' endsWith: 'ñåţîöñåļÎñţérîžåţîờñ').
	deny: ('' endsWith: 'Îñţérñåţîöñåļîžåţîờñ').

	assert: ('ÎñţérñåţîöñåļîžåţîờñASCII' endsWith: 'I').
	assert: ('ÎñţérñåţîöñåļîžåţîờñASCII' endsWith: 'ÎñţérñåţîöñåļîžåţîờñASCII').
	assert: ('ÎñţérñåţîöñåļîžåţîờñASCII' endsWith: '').
	deny: ('ÎñţérñåţîöñåļîžåţîờñASCII' endsWith: 'ÎñţérñåţîöñåļîžåţîờñÎñţérñåţîöñåļîžåţîờñASCII').
	deny: ('ÎñţérñåţîöñåļîžåţîờñASCII' endsWith: 'ÎñţérîžåţîờñASCII').
	deny: ('ÎñţérñåţîöñåļîžåţîờñASCII' endsWith: 'foobar').
	deny: ('ÎñţérñåţîöñåļîžåţîờñASCII' endsWith: 'ñåţîöñåļÎñţérîžåţîờñASCII').

	deny: ('ASCII' endsWith: 'ÎñţérîžåţîờñASCII').
	deny: ('ASCII' endsWith: 'Îñţér').

	should: ['Îñţérñåţîöñåļîžåţîờñ' endsWith: 0] signal: Error.
	should: ['Îñţérñåţîöñåļîžåţîờñ' endsWith: true] signal: Error.
	should: ['Îñţérñåţîöñåļîžåţîờñ' endsWith: nil] signal: Error.
)
public testWideStringSize = (
	(* :todo: It's not clear that being able to quickly iterate code points is actually that useful. *)
	assert: 'Îñţérñåţîöñåļîžåţîờñ' size equals: 40.
	assert: #'Îñţérñåţîöñåļîžåţîờñ' size equals: 40.
)
public testWideStringStartsWith = (
	assert: ('Îñţérñåţîöñåļîžåţîờñ' startsWith: 'Î').
	assert: ('Îñţérñåţîöñåļîžåţîờñ' startsWith: 'Îñţérñåţîöñåļ').
	assert: ('Îñţérñåţîöñåļîžåţîờñ' startsWith: '').
	deny: ('Îñţérñåţîöñåļîžåţîờñ' startsWith: 'ÎñţérñåţîöñåļîžåţîờñÎñţérñåţîöñåļîžåţîờñ').
	deny: ('Îñţérñåţîöñåļîžåţîờñ' startsWith: 'Îñţérîžåţîờñ').
	deny: ('Îñţérñåţîöñåļîžåţîờñ' startsWith: 'ñåţîöñåļÎñţérîžåţîờñ').

	assert: ('ASCIIÎñţérñåţîöñåļîžåţîờñ' startsWith: 'A').
	assert: ('ASCIIÎñţérñåţîöñåļîžåţîờñ' startsWith: 'ASCIIÎñţérñåţîöñåļ').
	assert: ('ASCIIÎñţérñåţîöñåļîžåţîờñ' startsWith: '').
	deny: ('ASCIIÎñţérñåţîöñåļîžåţîờñ' startsWith: 'ASCIIÎñţérñåţîöñåļîžåţîờñÎñţérñåţîöñåļîžåţîờñ').
	deny: ('ASCIIÎñţérñåţîöñåļîžåţîờñ' startsWith: 'ASCIIÎñţérîžåţîờñ').
	deny: ('ASCIIÎñţérñåţîöñåļîžåţîờñ' startsWith: 'foobar').
	deny: ('ASCIIÎñţérñåţîöñåļîžåţîờñ' startsWith: 'ASCIIñåţîöñåļÎñţérîžåţîờñ').

	deny: ('ASCII' startsWith: 'ASCIIÎñţérîžåţîờñ').
	deny: ('ASCII' startsWith: 'Îñţér').

	should: ['Îñţérñåţîöñåļîžåţîờñ' startsWith: 0] signal: Error.
	should: ['Îñţérñåţîöñåļîžåţîờñ' startsWith: true] signal: Error.
	should: ['Îñţérñåţîöñåļîžåţîờñ' startsWith: nil] signal: Error.
)
) : (
TEST_CONTEXT = ()
)
class TestException = Exception () (
) : (
)
largestNegativeLargeInteger = (
	(* -1 << 63 - 1 *)
	^-9223372036854775809
)
maxDoubleInt = (
	(* 1 << 53 *)
	^9007199254740992
)
maxInt31 = (
	(* 1 << 30 - 1 *)
	^1073741823
)
maxInt32 = (
	(* 1 << 31 - 1 *)
	^2147483647
)
maxInt63 = (
	(* 1 << 62 - 1 *)
	^4611686018427387903
)
maxInt64 = (
	(* 1 << 63 - 1 *)
	^9223372036854775807
)
minDoubleInt = (
	(* -1 << 53 *)
	^-9007199254740992
)
minInt31 = (
	(* -1 << 30 *)
	^-1073741824
)
minInt32 = (
	(* -1 << 31 *)
	^-2147483648
)
minInt63 = (
	(* -1 << 62 *)
	^-4611686018427387904
)
minInt64 = (
	(* -1 << 63 *)
	^-9223372036854775808
)
smallestPositiveLargeInteger = (
	(* 1 << 63 *)
	^9223372036854775808
)
) : (
)