| 
					
				 | 
			
			
				@@ -1344,7 +1344,7 @@ return smalltalk.withContext(function($ctx1) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 self._subclassResponsibility(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 return self}, function($ctx1) {$ctx1.fill(self,"collectionWithDuplicates",{},smalltalk.CollectionTest)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-source: "collectionWithDuplicates\x0a\x09\x22Answers pre-filled collection of type tested,\x0a\x09with exactly five distinct elements,\x0a\x09some of them appearing multiple times.\x22\x0a\x0a\x09self subclassResponsibility", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+source: "collectionWithDuplicates\x0a\x09\x22Answers pre-filled collection of type tested,\x0a\x09with exactly five distinct elements,\x0a\x09some of them appearing multiple times, if possible.\x22\x0a\x0a\x09self subclassResponsibility", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 messageSends: ["subclassResponsibility"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 }), 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -5009,6 +5009,375 @@ referencedClasses: ["String"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.StringTest.klass); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.addClass('SetTest', smalltalk.CollectionTest, [], 'Kernel-Tests'); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.addMethod( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.method({ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+selector: "collection", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+protocol: 'fixture', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+fn: function (){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+function $Set(){return smalltalk.Set||(typeof Set=="undefined"?nil:Set)} 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return smalltalk.withContext(function($ctx1) {  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+var $2,$3,$1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$2=_st($Set())._new(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+_st($2)._add_((1)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["add:"]=1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+_st($2)._add_((2)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["add:"]=2; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+_st($2)._add_((3)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["add:"]=3; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+_st($2)._add_((-4)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$3=_st($2)._yourself(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$1=$3; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return $1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx1) {$ctx1.fill(self,"collection",{},smalltalk.SetTest)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+source: "collection\x0a\x09^ Set new\x0a\x09\x09add: 1;\x0a\x09\x09add: 2;\x0a\x09\x09add: 3;\x0a\x09\x09add: -4;\x0a\x09\x09yourself", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["add:", "new", "yourself"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+referencedClasses: ["Set"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.SetTest); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.addMethod( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.method({ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+selector: "collectionOfPrintStrings", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+protocol: 'fixture', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+fn: function (){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+function $Set(){return smalltalk.Set||(typeof Set=="undefined"?nil:Set)} 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return smalltalk.withContext(function($ctx1) {  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+var $2,$3,$1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$2=_st($Set())._new(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+_st($2)._add_("1"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["add:"]=1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+_st($2)._add_("2"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["add:"]=2; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+_st($2)._add_("3"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["add:"]=3; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+_st($2)._add_("-4"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$3=_st($2)._yourself(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$1=$3; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return $1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx1) {$ctx1.fill(self,"collectionOfPrintStrings",{},smalltalk.SetTest)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+source: "collectionOfPrintStrings\x0a\x09^ Set new\x0a\x09\x09add: '1';\x0a\x09\x09add: '2';\x0a\x09\x09add: '3';\x0a\x09\x09add: '-4';\x0a\x09\x09yourself", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["add:", "new", "yourself"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+referencedClasses: ["Set"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.SetTest); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.addMethod( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.method({ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+selector: "collectionSize", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+protocol: 'fixture', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+fn: function (){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return smalltalk.withContext(function($ctx1) {  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return (4); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx1) {$ctx1.fill(self,"collectionSize",{},smalltalk.SetTest)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+source: "collectionSize\x0a\x09^ 4", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.SetTest); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.addMethod( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.method({ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+selector: "collectionWithDuplicates", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+protocol: 'fixture', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+fn: function (){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return smalltalk.withContext(function($ctx1) {  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+var $2,$3,$1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$2=self._collection(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+_st($2)._add_("yet another"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$3=_st($2)._yourself(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$1=$3; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return $1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx1) {$ctx1.fill(self,"collectionWithDuplicates",{},smalltalk.SetTest)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+source: "collectionWithDuplicates\x0a\x09\x22Set has no duplicates\x22\x0a\x09^ self collection add: 'yet another'; yourself", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["add:", "collection", "yourself"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.SetTest); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.addMethod( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.method({ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+selector: "collectionWithNewValue", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+protocol: 'fixture', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+fn: function (){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+function $Set(){return smalltalk.Set||(typeof Set=="undefined"?nil:Set)} 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return smalltalk.withContext(function($ctx1) {  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+var $2,$3,$1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$2=_st($Set())._new(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+_st($2)._add_((1)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["add:"]=1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+_st($2)._add_((2)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["add:"]=2; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+_st($2)._add_((3)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["add:"]=3; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+_st($2)._add_("N"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["add:"]=4; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+_st($2)._add_((-4)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$3=_st($2)._yourself(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$1=$3; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return $1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx1) {$ctx1.fill(self,"collectionWithNewValue",{},smalltalk.SetTest)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+source: "collectionWithNewValue\x0a\x09^ Set new\x0a\x09\x09add: 1;\x0a\x09\x09add: 2;\x0a\x09\x09add: 3;\x0a\x09\x09add: 'N';\x0a\x09\x09add: -4;\x0a\x09\x09yourself", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["add:", "new", "yourself"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+referencedClasses: ["Set"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.SetTest); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.addMethod( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.method({ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+selector: "testAddRemove", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+protocol: 'tests', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+fn: function (){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+var set; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+function $Set(){return smalltalk.Set||(typeof Set=="undefined"?nil:Set)} 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return smalltalk.withContext(function($ctx1) {  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+var $1,$2; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+set=_st($Set())._new(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+self._assert_(_st(set)._isEmpty()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["assert:"]=1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+_st(set)._add_((3)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["add:"]=1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$1=_st(set)._includes_((3)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["includes:"]=1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+self._assert_($1); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["assert:"]=2; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+_st(set)._add_((5)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$2=_st(set)._includes_((5)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["includes:"]=2; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+self._assert_($2); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+_st(set)._remove_((3)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+self._deny_(_st(set)._includes_((3))); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return self}, function($ctx1) {$ctx1.fill(self,"testAddRemove",{set:set},smalltalk.SetTest)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+source: "testAddRemove\x0a\x09| set |\x0a\x09set := Set new.\x0a\x09\x0a\x09self assert: set isEmpty.\x0a\x0a\x09set add: 3.\x0a\x09self assert: (set includes: 3).\x0a\x0a\x09set add: 5.\x0a\x09self assert: (set includes: 5).\x0a\x0a\x09set remove: 3.\x0a\x09self deny: (set includes: 3)", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["new", "assert:", "isEmpty", "add:", "includes:", "remove:", "deny:"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+referencedClasses: ["Set"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.SetTest); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.addMethod( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.method({ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+selector: "testAt", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+protocol: 'tests', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+fn: function (){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+function $Set(){return smalltalk.Set||(typeof Set=="undefined"?nil:Set)} 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+function $Error(){return smalltalk.Error||(typeof Error=="undefined"?nil:Error)} 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return smalltalk.withContext(function($ctx1) {  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+self._should_raise_((function(){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return smalltalk.withContext(function($ctx2) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return _st(_st($Set())._new())._at_put_((1),(2)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}),$Error()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return self}, function($ctx1) {$ctx1.fill(self,"testAt",{},smalltalk.SetTest)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+source: "testAt\x0a\x09self should: [ Set new at: 1 put: 2 ] raise: Error", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["should:raise:", "at:put:", "new"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+referencedClasses: ["Set", "Error"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.SetTest); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.addMethod( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.method({ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+selector: "testCollect", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+protocol: 'tests', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+fn: function (){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return smalltalk.withContext(function($ctx1) {  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+var $2,$1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.SetTest.superclass.fn.prototype._testCollect.apply(_st(self), []); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$2=[(5), (6), (8)]._asSet(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["asSet"]=1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$1=_st($2)._collect_((function(x){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return smalltalk.withContext(function($ctx2) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return _st(x).__backslash_backslash((3)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx2) {$ctx2.fillBlock({x:x},$ctx1,1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+self._assert_equals_($1,[(0), (2)]._asSet()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return self}, function($ctx1) {$ctx1.fill(self,"testCollect",{},smalltalk.SetTest)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+source: "testCollect\x0a\x09super testCollect.\x0a\x09self assert: (#(5 6 8) asSet collect: [ :x | x \x5c\x5c 3 ]) equals: #(0 2) asSet", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["testCollect", "assert:equals:", "collect:", "asSet", "\x5c\x5c"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.SetTest); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.addMethod( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.method({ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+selector: "testComparing", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+protocol: 'tests', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+fn: function (){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return smalltalk.withContext(function($ctx1) {  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+var $1,$2,$3,$4,$6,$7,$5,$9,$8; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$1=[(0), (2)]._asSet(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["asSet"]=1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$2=[(0), (2)]._asSet(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["asSet"]=2; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+self._assert_equals_($1,$2); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["assert:equals:"]=1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$3=[(2), (0)]._asSet(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["asSet"]=3; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$4=[(0), (2)]._asSet(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["asSet"]=4; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+self._assert_equals_($3,$4); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$6=[(0), (2), (3)]._asSet(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["asSet"]=5; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$7=[(0), (2)]._asSet(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["asSet"]=6; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$5=_st($6).__eq($7); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["="]=1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+self._deny_($5); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["deny:"]=1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$9=[(1), (2)]._asSet(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["asSet"]=7; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$8=_st($9).__eq([(0), (2)]._asSet()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+self._deny_($8); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return self}, function($ctx1) {$ctx1.fill(self,"testComparing",{},smalltalk.SetTest)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+source: "testComparing\x0a\x09self assert: #(0 2) asSet equals: #(0 2) asSet.\x0a\x09self assert: #(2 0) asSet equals: #(0 2) asSet.\x0a\x09self deny: #(0 2 3) asSet = #(0 2) asSet.\x0a\x09self deny: #(1 2) asSet = #(0 2) asSet", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["assert:equals:", "asSet", "deny:", "="], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.SetTest); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.addMethod( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.method({ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+selector: "testPrintString", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+protocol: 'tests', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+fn: function (){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+var set; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+function $Set(){return smalltalk.Set||(typeof Set=="undefined"?nil:Set)} 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return smalltalk.withContext(function($ctx1) {  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+var $1,$2,$3,$4,$5,$6,$7,$8,$9; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+set=_st($Set())._new(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$1=_st(set)._printString(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["printString"]=1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+self._assert_equals_($1,"a Set ()"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["assert:equals:"]=1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$2=set; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+_st($2)._add_((1)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["add:"]=1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$3=_st($2)._add_((3)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["add:"]=2; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$4=_st(set)._printString(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["printString"]=2; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+self._assert_equals_($4,"a Set (1 3)"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["assert:equals:"]=2; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+_st(set)._add_("foo"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["add:"]=3; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$5=_st(set)._printString(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["printString"]=3; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+self._assert_equals_($5,"a Set (1 3 'foo')"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["assert:equals:"]=3; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$6=set; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+_st($6)._remove_((1)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["remove:"]=1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$7=_st($6)._remove_((3)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$8=_st(set)._printString(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["printString"]=4; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+self._assert_equals_($8,"a Set ('foo')"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["assert:equals:"]=4; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+_st(set)._add_((3)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["add:"]=4; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$9=_st(set)._printString(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["printString"]=5; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+self._assert_equals_($9,"a Set ('foo' 3)"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["assert:equals:"]=5; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+_st(set)._add_((3)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+self._assert_equals_(_st(set)._printString(),"a Set ('foo' 3)"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return self}, function($ctx1) {$ctx1.fill(self,"testPrintString",{set:set},smalltalk.SetTest)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+source: "testPrintString\x0a\x09| set |\x0a\x09set := Set new.\x0a\x09self assert: set printString equals: 'a Set ()'.\x0a\x09set add: 1; add: 3.\x0a\x09self assert: set printString equals: 'a Set (1 3)'.\x0a\x09set add: 'foo'.\x0a\x09self assert: set printString equals: 'a Set (1 3 ''foo'')'.\x0a\x09set remove: 1; remove: 3.\x0a\x09self assert: set printString equals: 'a Set (''foo'')'.\x0a\x09set add: 3.\x0a\x09self assert: set printString equals: 'a Set (''foo'' 3)'.\x0a\x09set add: 3.\x0a\x09self assert: set printString equals: 'a Set (''foo'' 3)'", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["new", "assert:equals:", "printString", "add:", "remove:"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+referencedClasses: ["Set"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.SetTest); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.addMethod( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.method({ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+selector: "testUnboxedObjects", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+protocol: 'tests', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+fn: function (){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return smalltalk.withContext(function($ctx1) {  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+var $4,$3,$2,$1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$4="foo"._yourself(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["yourself"]=1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$3=[$4,"foo"._yourself()]; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$2=_st($3)._asSet(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$1=_st($2)._asArray(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+self._assert_equals_($1,["foo"]); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return self}, function($ctx1) {$ctx1.fill(self,"testUnboxedObjects",{},smalltalk.SetTest)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+source: "testUnboxedObjects\x0a\x09self assert: {'foo' yourself. 'foo' yourself} asSet asArray equals: #('foo')", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["assert:equals:", "asArray", "asSet", "yourself"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.SetTest); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.addMethod( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.method({ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+selector: "testUnicity", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+protocol: 'tests', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+fn: function (){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+var set; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+function $Set(){return smalltalk.Set||(typeof Set=="undefined"?nil:Set)} 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return smalltalk.withContext(function($ctx1) {  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+var $1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+set=_st($Set())._new(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+_st(set)._add_((21)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["add:"]=1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+_st(set)._add_("hello"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["add:"]=2; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+_st(set)._add_((21)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["add:"]=3; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$1=_st(set)._size(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["size"]=1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+self._assert_equals_($1,(2)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["assert:equals:"]=1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+_st(set)._add_("hello"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+self._assert_equals_(_st(set)._size(),(2)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+$ctx1.sendIdx["assert:equals:"]=2; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+self._assert_equals_(_st(set)._asArray(),[(21), "hello"]); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return self}, function($ctx1) {$ctx1.fill(self,"testUnicity",{set:set},smalltalk.SetTest)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+source: "testUnicity\x0a\x09| set |\x0a\x09set := Set new.\x0a\x09set add: 21.\x0a\x09set add: 'hello'.\x0a\x0a\x09set add: 21.\x0a\x09self assert: set size equals: 2.\x0a\x09\x0a\x09set add: 'hello'.\x0a\x09self assert: set size equals: 2.\x0a\x0a\x09self assert: set asArray equals: #(21 'hello')", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: ["new", "add:", "assert:equals:", "size", "asArray"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+referencedClasses: ["Set"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.SetTest); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.addMethod( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.method({ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+selector: "collectionClass", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+protocol: 'fixture', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+fn: function (){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+function $Set(){return smalltalk.Set||(typeof Set=="undefined"?nil:Set)} 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return smalltalk.withContext(function($ctx1) {  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+return $Set(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}, function($ctx1) {$ctx1.fill(self,"collectionClass",{},smalltalk.SetTest.klass)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+source: "collectionClass\x0a\x09^ Set", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+messageSends: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+referencedClasses: ["Set"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+smalltalk.SetTest.klass); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.addClass('ConsoleTranscriptTest', smalltalk.TestCase, [], 'Kernel-Tests'); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.addMethod( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.method({ 
			 | 
		
	
	
		
			
				| 
					
				 | 
			
			
				@@ -7668,262 +8037,6 @@ smalltalk.RandomTest); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-smalltalk.addClass('SetTest', smalltalk.TestCase, [], 'Kernel-Tests'); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-smalltalk.addMethod( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-smalltalk.method({ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-selector: "testAddRemove", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-protocol: 'tests', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-fn: function (){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-var set; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-function $Set(){return smalltalk.Set||(typeof Set=="undefined"?nil:Set)} 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return smalltalk.withContext(function($ctx1) {  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-var $1,$2; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-set=_st($Set())._new(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-self._assert_(_st(set)._isEmpty()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$ctx1.sendIdx["assert:"]=1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-_st(set)._add_((3)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$ctx1.sendIdx["add:"]=1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$1=_st(set)._includes_((3)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$ctx1.sendIdx["includes:"]=1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-self._assert_($1); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$ctx1.sendIdx["assert:"]=2; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-_st(set)._add_((5)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$2=_st(set)._includes_((5)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$ctx1.sendIdx["includes:"]=2; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-self._assert_($2); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-_st(set)._remove_((3)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-self._deny_(_st(set)._includes_((3))); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return self}, function($ctx1) {$ctx1.fill(self,"testAddRemove",{set:set},smalltalk.SetTest)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-source: "testAddRemove\x0a\x09| set |\x0a\x09set := Set new.\x0a\x09\x0a\x09self assert: set isEmpty.\x0a\x0a\x09set add: 3.\x0a\x09self assert: (set includes: 3).\x0a\x0a\x09set add: 5.\x0a\x09self assert: (set includes: 5).\x0a\x0a\x09set remove: 3.\x0a\x09self deny: (set includes: 3)", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["new", "assert:", "isEmpty", "add:", "includes:", "remove:", "deny:"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-referencedClasses: ["Set"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-smalltalk.SetTest); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-smalltalk.addMethod( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-smalltalk.method({ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-selector: "testAt", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-protocol: 'tests', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-fn: function (){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-function $Set(){return smalltalk.Set||(typeof Set=="undefined"?nil:Set)} 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-function $Error(){return smalltalk.Error||(typeof Error=="undefined"?nil:Error)} 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return smalltalk.withContext(function($ctx1) {  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-self._should_raise_((function(){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return smalltalk.withContext(function($ctx2) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return _st(_st($Set())._new())._at_put_((1),(2)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)})}),$Error()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return self}, function($ctx1) {$ctx1.fill(self,"testAt",{},smalltalk.SetTest)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-source: "testAt\x0a\x09self should: [ Set new at: 1 put: 2 ] raise: Error", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["should:raise:", "at:put:", "new"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-referencedClasses: ["Set", "Error"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-smalltalk.SetTest); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-smalltalk.addMethod( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-smalltalk.method({ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-selector: "testCollect", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-protocol: 'tests', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-fn: function (){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return smalltalk.withContext(function($ctx1) {  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-var $2,$1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$2=[(5), (6), (8)]._asSet(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$ctx1.sendIdx["asSet"]=1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$1=_st($2)._collect_((function(x){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return smalltalk.withContext(function($ctx2) { 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return _st(x).__backslash_backslash((3)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}, function($ctx2) {$ctx2.fillBlock({x:x},$ctx1,1)})})); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-self._assert_equals_($1,[(0), (2)]._asSet()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return self}, function($ctx1) {$ctx1.fill(self,"testCollect",{},smalltalk.SetTest)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-source: "testCollect\x0a\x09self assert: (#(5 6 8) asSet collect: [ :x | x \x5c\x5c 3 ]) equals: #(0 2) asSet", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["assert:equals:", "collect:", "asSet", "\x5c\x5c"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-smalltalk.SetTest); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-smalltalk.addMethod( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-smalltalk.method({ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-selector: "testComparing", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-protocol: 'tests', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-fn: function (){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return smalltalk.withContext(function($ctx1) {  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-var $1,$2,$3,$4,$6,$7,$5,$9,$8; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$1=[(0), (2)]._asSet(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$ctx1.sendIdx["asSet"]=1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$2=[(0), (2)]._asSet(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$ctx1.sendIdx["asSet"]=2; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-self._assert_equals_($1,$2); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$ctx1.sendIdx["assert:equals:"]=1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$3=[(2), (0)]._asSet(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$ctx1.sendIdx["asSet"]=3; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$4=[(0), (2)]._asSet(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$ctx1.sendIdx["asSet"]=4; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-self._assert_equals_($3,$4); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$6=[(0), (2), (3)]._asSet(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$ctx1.sendIdx["asSet"]=5; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$7=[(0), (2)]._asSet(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$ctx1.sendIdx["asSet"]=6; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$5=_st($6).__eq($7); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$ctx1.sendIdx["="]=1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-self._deny_($5); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$ctx1.sendIdx["deny:"]=1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$9=[(1), (2)]._asSet(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$ctx1.sendIdx["asSet"]=7; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$8=_st($9).__eq([(0), (2)]._asSet()); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-self._deny_($8); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return self}, function($ctx1) {$ctx1.fill(self,"testComparing",{},smalltalk.SetTest)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-source: "testComparing\x0a\x09self assert: #(0 2) asSet equals: #(0 2) asSet.\x0a\x09self assert: #(2 0) asSet equals: #(0 2) asSet.\x0a\x09self deny: #(0 2 3) asSet = #(0 2) asSet.\x0a\x09self deny: #(1 2) asSet = #(0 2) asSet", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["assert:equals:", "asSet", "deny:", "="], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-smalltalk.SetTest); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-smalltalk.addMethod( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-smalltalk.method({ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-selector: "testPrintString", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-protocol: 'tests', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-fn: function (){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-var set; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-function $Set(){return smalltalk.Set||(typeof Set=="undefined"?nil:Set)} 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return smalltalk.withContext(function($ctx1) {  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-var $1,$2,$3,$4,$5,$6,$7,$8,$9; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-set=_st($Set())._new(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$1=_st(set)._printString(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$ctx1.sendIdx["printString"]=1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-self._assert_equals_($1,"a Set ()"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$ctx1.sendIdx["assert:equals:"]=1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$2=set; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-_st($2)._add_((1)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$ctx1.sendIdx["add:"]=1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$3=_st($2)._add_((3)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$ctx1.sendIdx["add:"]=2; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$4=_st(set)._printString(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$ctx1.sendIdx["printString"]=2; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-self._assert_equals_($4,"a Set (1 3)"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$ctx1.sendIdx["assert:equals:"]=2; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-_st(set)._add_("foo"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$ctx1.sendIdx["add:"]=3; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$5=_st(set)._printString(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$ctx1.sendIdx["printString"]=3; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-self._assert_equals_($5,"a Set (1 3 'foo')"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$ctx1.sendIdx["assert:equals:"]=3; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$6=set; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-_st($6)._remove_((1)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$ctx1.sendIdx["remove:"]=1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$7=_st($6)._remove_((3)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$8=_st(set)._printString(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$ctx1.sendIdx["printString"]=4; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-self._assert_equals_($8,"a Set ('foo')"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$ctx1.sendIdx["assert:equals:"]=4; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-_st(set)._add_((3)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$ctx1.sendIdx["add:"]=4; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$9=_st(set)._printString(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$ctx1.sendIdx["printString"]=5; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-self._assert_equals_($9,"a Set ('foo' 3)"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$ctx1.sendIdx["assert:equals:"]=5; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-_st(set)._add_((3)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-self._assert_equals_(_st(set)._printString(),"a Set ('foo' 3)"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return self}, function($ctx1) {$ctx1.fill(self,"testPrintString",{set:set},smalltalk.SetTest)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-source: "testPrintString\x0a\x09| set |\x0a\x09set := Set new.\x0a\x09self assert: set printString equals: 'a Set ()'.\x0a\x09set add: 1; add: 3.\x0a\x09self assert: set printString equals: 'a Set (1 3)'.\x0a\x09set add: 'foo'.\x0a\x09self assert: set printString equals: 'a Set (1 3 ''foo'')'.\x0a\x09set remove: 1; remove: 3.\x0a\x09self assert: set printString equals: 'a Set (''foo'')'.\x0a\x09set add: 3.\x0a\x09self assert: set printString equals: 'a Set (''foo'' 3)'.\x0a\x09set add: 3.\x0a\x09self assert: set printString equals: 'a Set (''foo'' 3)'", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["new", "assert:equals:", "printString", "add:", "remove:"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-referencedClasses: ["Set"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-smalltalk.SetTest); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-smalltalk.addMethod( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-smalltalk.method({ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-selector: "testSize", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-protocol: 'tests', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-fn: function (){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-function $Set(){return smalltalk.Set||(typeof Set=="undefined"?nil:Set)} 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return smalltalk.withContext(function($ctx1) {  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-var $1,$3,$2; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$1=_st(_st($Set())._new())._size(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$ctx1.sendIdx["size"]=1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-self._assert_equals_($1,(0)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$ctx1.sendIdx["assert:equals:"]=1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$3=_st($Set())._withAll_([(1), (2), (3), (4)]); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$ctx1.sendIdx["withAll:"]=1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$2=_st($3)._size(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$ctx1.sendIdx["size"]=2; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-self._assert_equals_($2,(4)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$ctx1.sendIdx["assert:equals:"]=2; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-self._assert_equals_(_st(_st($Set())._withAll_([(1), (1), (1), (1)]))._size(),(1)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return self}, function($ctx1) {$ctx1.fill(self,"testSize",{},smalltalk.SetTest)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-source: "testSize\x0a\x09self assert: Set new size equals: 0.\x0a\x09self assert: (Set withAll: #(1 2 3 4)) size equals: 4.\x0a\x09self assert: (Set withAll: #(1 1 1 1)) size equals: 1", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["assert:equals:", "size", "new", "withAll:"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-referencedClasses: ["Set"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-smalltalk.SetTest); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-smalltalk.addMethod( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-smalltalk.method({ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-selector: "testUnboxedObjects", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-protocol: 'tests', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-fn: function (){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return smalltalk.withContext(function($ctx1) {  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-var $4,$3,$2,$1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$4="foo"._yourself(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$ctx1.sendIdx["yourself"]=1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$3=[$4,"foo"._yourself()]; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$2=_st($3)._asSet(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$1=_st($2)._asArray(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-self._assert_equals_($1,["foo"]); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return self}, function($ctx1) {$ctx1.fill(self,"testUnboxedObjects",{},smalltalk.SetTest)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-source: "testUnboxedObjects\x0a\x09self assert: {'foo' yourself. 'foo' yourself} asSet asArray equals: #('foo')", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["assert:equals:", "asArray", "asSet", "yourself"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-referencedClasses: [] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-smalltalk.SetTest); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-smalltalk.addMethod( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-smalltalk.method({ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-selector: "testUnicity", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-protocol: 'tests', 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-fn: function (){ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-var self=this; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-var set; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-function $Set(){return smalltalk.Set||(typeof Set=="undefined"?nil:Set)} 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return smalltalk.withContext(function($ctx1) {  
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-var $1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-set=_st($Set())._new(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-_st(set)._add_((21)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$ctx1.sendIdx["add:"]=1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-_st(set)._add_("hello"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$ctx1.sendIdx["add:"]=2; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-_st(set)._add_((21)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$ctx1.sendIdx["add:"]=3; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$1=_st(set)._size(); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$ctx1.sendIdx["size"]=1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-self._assert_equals_($1,(2)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$ctx1.sendIdx["assert:equals:"]=1; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-_st(set)._add_("hello"); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-self._assert_equals_(_st(set)._size(),(2)); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-$ctx1.sendIdx["assert:equals:"]=2; 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-self._assert_equals_(_st(set)._asArray(),[(21), "hello"]); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-return self}, function($ctx1) {$ctx1.fill(self,"testUnicity",{set:set},smalltalk.SetTest)})}, 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-args: [], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-source: "testUnicity\x0a\x09| set |\x0a\x09set := Set new.\x0a\x09set add: 21.\x0a\x09set add: 'hello'.\x0a\x0a\x09set add: 21.\x0a\x09self assert: set size equals: 2.\x0a\x09\x0a\x09set add: 'hello'.\x0a\x09self assert: set size equals: 2.\x0a\x0a\x09self assert: set asArray equals: #(21 'hello')", 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-messageSends: ["new", "add:", "assert:equals:", "size", "asArray"], 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-referencedClasses: ["Set"] 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-}), 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				-smalltalk.SetTest); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				- 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.addClass('StreamTest', smalltalk.TestCase, [], 'Kernel-Tests'); 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.addMethod( 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				 smalltalk.method({ 
			 |