Moves Helios-SUnit files in the new Helios folder

src/Helios-Commands-SUnit.js

@@ -0,0 +1,486 @@
+define("helios/Helios-Commands-SUnit", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_vm/globals", "helios/Helios-Commands-Tools"], function(smalltalk,nil,_st, globals){
+smalltalk.addPackage('Helios-Commands-SUnit');
+smalltalk.packages["Helios-Commands-SUnit"].transport = {"type":"amd","amdNamespace":"helios"};
+
+smalltalk.addClass('HLSUnitCommand', globals.HLToolCommand, [], 'Helios-Commands-SUnit');
+globals.HLSUnitCommand.comment="I group the commands pertaining to Helios-SUnit (`HLSUnitModel`)";
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isValidFor:",
+protocol: 'testing',
+fn: function (aModel){
+var self=this;
+function $HLSUnitModel(){return globals.HLSUnitModel||(typeof HLSUnitModel=="undefined"?nil:HLSUnitModel)}
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(aModel)._isKindOf_($HLSUnitModel());
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"isValidFor:",{aModel:aModel},globals.HLSUnitCommand.klass)})},
+args: ["aModel"],
+source: "isValidFor: aModel\x0a\x09^ aModel isKindOf: HLSUnitModel",
+messageSends: ["isKindOf:"],
+referencedClasses: ["HLSUnitModel"]
+}),
+globals.HLSUnitCommand.klass);
+
+
+smalltalk.addClass('HLSUnitInvertSelectedCommand', globals.HLSUnitCommand, [], 'Helios-Commands-SUnit');
+globals.HLSUnitInvertSelectedCommand.comment="I group the commands that invert selections";
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "i";
+},
+args: [],
+source: "key\x0a\x09^ 'i'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLSUnitInvertSelectedCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Invert selection";
+},
+args: [],
+source: "label\x0a\x09^'Invert selection'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLSUnitInvertSelectedCommand.klass);
+
+
+smalltalk.addClass('HLSUnitInvertSelectedClassesCommand', globals.HLSUnitInvertSelectedCommand, [], 'Helios-Commands-SUnit');
+globals.HLSUnitInvertSelectedClassesCommand.comment="Invert the currently selected classes on a `HLSUnitModel`";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "category",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Classes";
+},
+args: [],
+source: "category\x0a\x09^'Classes'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLSUnitInvertSelectedClassesCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "execute",
+protocol: 'executing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._invertSelectedClasses();
+return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLSUnitInvertSelectedClassesCommand)})},
+args: [],
+source: "execute\x0a\x09self model invertSelectedClasses",
+messageSends: ["invertSelectedClasses", "model"],
+referencedClasses: []
+}),
+globals.HLSUnitInvertSelectedClassesCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isActive",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(_st(self["@model"])._selectedPackages())._notEmpty();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"isActive",{},globals.HLSUnitInvertSelectedClassesCommand)})},
+args: [],
+source: "isActive\x0a\x09^model selectedPackages notEmpty",
+messageSends: ["notEmpty", "selectedPackages"],
+referencedClasses: []
+}),
+globals.HLSUnitInvertSelectedClassesCommand);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "c";
+},
+args: [],
+source: "key\x0a\x09^ 'c'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLSUnitInvertSelectedClassesCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Invert selected classes";
+},
+args: [],
+source: "label\x0a\x09^ 'Invert selected classes'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLSUnitInvertSelectedClassesCommand.klass);
+
+
+smalltalk.addClass('HLSUnitInvertSelectedPackagesCommand', globals.HLSUnitInvertSelectedCommand, [], 'Helios-Commands-SUnit');
+globals.HLSUnitInvertSelectedPackagesCommand.comment="Invert the currently selected packages on a `HLSUnitModel`";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "category",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Packages";
+},
+args: [],
+source: "category\x0a\x09^'Packages'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLSUnitInvertSelectedPackagesCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "execute",
+protocol: 'executing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._invertSelectedPackages();
+return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLSUnitInvertSelectedPackagesCommand)})},
+args: [],
+source: "execute\x0a\x09self model invertSelectedPackages",
+messageSends: ["invertSelectedPackages", "model"],
+referencedClasses: []
+}),
+globals.HLSUnitInvertSelectedPackagesCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isActive",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return true;
+},
+args: [],
+source: "isActive\x0a\x09^true",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLSUnitInvertSelectedPackagesCommand);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "p";
+},
+args: [],
+source: "key\x0a\x09^ 'p'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLSUnitInvertSelectedPackagesCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Invert selected packages";
+},
+args: [],
+source: "label\x0a\x09^ 'Invert selected packages'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLSUnitInvertSelectedPackagesCommand.klass);
+
+
+smalltalk.addClass('HLSUnitRunTests', globals.HLSUnitCommand, [], 'Helios-Commands-SUnit');
+globals.HLSUnitRunTests.comment="Run the test cases in the currently selected classes on a `HLSUnitModel`";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "execute",
+protocol: 'executing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._runTests();
+return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLSUnitRunTests)})},
+args: [],
+source: "execute\x0a\x09self model runTests",
+messageSends: ["runTests", "model"],
+referencedClasses: []
+}),
+globals.HLSUnitRunTests);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isActive",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return true;
+},
+args: [],
+source: "isActive\x0a\x09^true",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLSUnitRunTests);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "r";
+},
+args: [],
+source: "key\x0a\x09^'r'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLSUnitRunTests.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Run Tests";
+},
+args: [],
+source: "label\x0a\x09^'Run Tests'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLSUnitRunTests.klass);
+
+
+smalltalk.addClass('HLSUnitSelectAllCommand', globals.HLSUnitCommand, [], 'Helios-Commands-SUnit');
+globals.HLSUnitSelectAllCommand.comment="I group the select all commands";
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "a";
+},
+args: [],
+source: "key\x0a\x09^ 'a'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLSUnitSelectAllCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Select all";
+},
+args: [],
+source: "label\x0a\x09^ 'Select all'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLSUnitSelectAllCommand.klass);
+
+
+smalltalk.addClass('HLSUnitSelectAllClassesCommand', globals.HLSUnitSelectAllCommand, [], 'Helios-Commands-SUnit');
+globals.HLSUnitSelectAllClassesCommand.comment="Select all available test classes based on what packages are selected on a `HLSUnitModel`";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "category",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Classes";
+},
+args: [],
+source: "category\x0a\x09^'Classes'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLSUnitSelectAllClassesCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "execute",
+protocol: 'executing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._selectAllClasses();
+return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLSUnitSelectAllClassesCommand)})},
+args: [],
+source: "execute\x0a\x09self model selectAllClasses",
+messageSends: ["selectAllClasses", "model"],
+referencedClasses: []
+}),
+globals.HLSUnitSelectAllClassesCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isActive",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(_st(self["@model"])._selectedPackages())._notEmpty();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"isActive",{},globals.HLSUnitSelectAllClassesCommand)})},
+args: [],
+source: "isActive\x0a\x09^model selectedPackages notEmpty",
+messageSends: ["notEmpty", "selectedPackages"],
+referencedClasses: []
+}),
+globals.HLSUnitSelectAllClassesCommand);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "c";
+},
+args: [],
+source: "key\x0a\x09^ 'c'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLSUnitSelectAllClassesCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Select all classes";
+},
+args: [],
+source: "label\x0a\x09^ 'Select all classes'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLSUnitSelectAllClassesCommand.klass);
+
+
+smalltalk.addClass('HLSUnitSelectAllPackagesCommand', globals.HLSUnitSelectAllCommand, [], 'Helios-Commands-SUnit');
+globals.HLSUnitSelectAllPackagesCommand.comment="Select all packages with test cases on a `HLSUnitModel`";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "category",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Packages";
+},
+args: [],
+source: "category\x0a\x09^'Packages'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLSUnitSelectAllPackagesCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "execute",
+protocol: 'executing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self._model())._selectAllPackages();
+return self}, function($ctx1) {$ctx1.fill(self,"execute",{},globals.HLSUnitSelectAllPackagesCommand)})},
+args: [],
+source: "execute\x0a\x09self model selectAllPackages",
+messageSends: ["selectAllPackages", "model"],
+referencedClasses: []
+}),
+globals.HLSUnitSelectAllPackagesCommand);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "isActive",
+protocol: 'testing',
+fn: function (){
+var self=this;
+return true;
+},
+args: [],
+source: "isActive\x0a\x09^true",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLSUnitSelectAllPackagesCommand);
+
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "key",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "p";
+},
+args: [],
+source: "key\x0a\x09^ 'p'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLSUnitSelectAllPackagesCommand.klass);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "label",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return "Select all packages";
+},
+args: [],
+source: "label\x0a\x09^ 'Select all packages'",
+messageSends: [],
+referencedClasses: []
+}),
+globals.HLSUnitSelectAllPackagesCommand.klass);
+
+});

src/Helios-Commands-SUnit.st

@@ -0,0 +1,209 @@
+Smalltalk createPackage: 'Helios-Commands-SUnit'!
+HLToolCommand subclass: #HLSUnitCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-SUnit'!
+!HLSUnitCommand commentStamp!
+I group the commands pertaining to Helios-SUnit (`HLSUnitModel`)!
+
+!HLSUnitCommand class methodsFor: 'testing'!
+
+isValidFor: aModel
+	^ aModel isKindOf: HLSUnitModel
+! !
+
+HLSUnitCommand subclass: #HLSUnitInvertSelectedCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-SUnit'!
+!HLSUnitInvertSelectedCommand commentStamp!
+I group the commands that invert selections!
+
+!HLSUnitInvertSelectedCommand class methodsFor: 'accessing'!
+
+key
+	^ 'i'
+!
+
+label
+	^'Invert selection'
+! !
+
+HLSUnitInvertSelectedCommand subclass: #HLSUnitInvertSelectedClassesCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-SUnit'!
+!HLSUnitInvertSelectedClassesCommand commentStamp!
+Invert the currently selected classes on a `HLSUnitModel`!
+
+!HLSUnitInvertSelectedClassesCommand methodsFor: 'accessing'!
+
+category
+	^'Classes'
+! !
+
+!HLSUnitInvertSelectedClassesCommand methodsFor: 'executing'!
+
+execute
+	self model invertSelectedClasses
+! !
+
+!HLSUnitInvertSelectedClassesCommand methodsFor: 'testing'!
+
+isActive
+	^model selectedPackages notEmpty
+! !
+
+!HLSUnitInvertSelectedClassesCommand class methodsFor: 'accessing'!
+
+key
+	^ 'c'
+!
+
+label
+	^ 'Invert selected classes'
+! !
+
+HLSUnitInvertSelectedCommand subclass: #HLSUnitInvertSelectedPackagesCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-SUnit'!
+!HLSUnitInvertSelectedPackagesCommand commentStamp!
+Invert the currently selected packages on a `HLSUnitModel`!
+
+!HLSUnitInvertSelectedPackagesCommand methodsFor: 'accessing'!
+
+category
+	^'Packages'
+! !
+
+!HLSUnitInvertSelectedPackagesCommand methodsFor: 'executing'!
+
+execute
+	self model invertSelectedPackages
+! !
+
+!HLSUnitInvertSelectedPackagesCommand methodsFor: 'testing'!
+
+isActive
+	^true
+! !
+
+!HLSUnitInvertSelectedPackagesCommand class methodsFor: 'accessing'!
+
+key
+	^ 'p'
+!
+
+label
+	^ 'Invert selected packages'
+! !
+
+HLSUnitCommand subclass: #HLSUnitRunTests
+	instanceVariableNames: ''
+	package: 'Helios-Commands-SUnit'!
+!HLSUnitRunTests commentStamp!
+Run the test cases in the currently selected classes on a `HLSUnitModel`!
+
+!HLSUnitRunTests methodsFor: 'executing'!
+
+execute
+	self model runTests
+! !
+
+!HLSUnitRunTests methodsFor: 'testing'!
+
+isActive
+	^true
+! !
+
+!HLSUnitRunTests class methodsFor: 'accessing'!
+
+key
+	^'r'
+!
+
+label
+	^'Run Tests'
+! !
+
+HLSUnitCommand subclass: #HLSUnitSelectAllCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-SUnit'!
+!HLSUnitSelectAllCommand commentStamp!
+I group the select all commands!
+
+!HLSUnitSelectAllCommand class methodsFor: 'accessing'!
+
+key
+	^ 'a'
+!
+
+label
+	^ 'Select all'
+! !
+
+HLSUnitSelectAllCommand subclass: #HLSUnitSelectAllClassesCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-SUnit'!
+!HLSUnitSelectAllClassesCommand commentStamp!
+Select all available test classes based on what packages are selected on a `HLSUnitModel`!
+
+!HLSUnitSelectAllClassesCommand methodsFor: 'accessing'!
+
+category
+	^'Classes'
+! !
+
+!HLSUnitSelectAllClassesCommand methodsFor: 'executing'!
+
+execute
+	self model selectAllClasses
+! !
+
+!HLSUnitSelectAllClassesCommand methodsFor: 'testing'!
+
+isActive
+	^model selectedPackages notEmpty
+! !
+
+!HLSUnitSelectAllClassesCommand class methodsFor: 'accessing'!
+
+key
+	^ 'c'
+!
+
+label
+	^ 'Select all classes'
+! !
+
+HLSUnitSelectAllCommand subclass: #HLSUnitSelectAllPackagesCommand
+	instanceVariableNames: ''
+	package: 'Helios-Commands-SUnit'!
+!HLSUnitSelectAllPackagesCommand commentStamp!
+Select all packages with test cases on a `HLSUnitModel`!
+
+!HLSUnitSelectAllPackagesCommand methodsFor: 'accessing'!
+
+category
+	^'Packages'
+! !
+
+!HLSUnitSelectAllPackagesCommand methodsFor: 'executing'!
+
+execute
+	self model selectAllPackages
+! !
+
+!HLSUnitSelectAllPackagesCommand methodsFor: 'testing'!
+
+isActive
+	^true
+! !
+
+!HLSUnitSelectAllPackagesCommand class methodsFor: 'accessing'!
+
+key
+	^ 'p'
+!
+
+label
+	^ 'Select all packages'
+! !
+

src/Helios-SUnit-Tests.js

@@ -0,0 +1,422 @@
+define("helios/Helios-SUnit-Tests", ["amber_vm/smalltalk", "amber_vm/nil", "amber_vm/_st", "amber_vm/globals", "amber_core/SUnit"], function(smalltalk,nil,_st, globals){
+smalltalk.addPackage('Helios-SUnit-Tests');
+smalltalk.packages["Helios-SUnit-Tests"].transport = {"type":"amd","amdNamespace":"helios"};
+
+smalltalk.addClass('HLSUnitModelTest', globals.TestCase, ['model'], 'Helios-SUnit-Tests');
+globals.HLSUnitModelTest.comment="Test cases for the functionality of  `HLSUnitModel`";
+smalltalk.addMethod(
+smalltalk.method({
+selector: "setUp",
+protocol: 'initializing',
+fn: function (){
+var self=this;
+function $HLSUnitModel(){return globals.HLSUnitModel||(typeof HLSUnitModel=="undefined"?nil:HLSUnitModel)}
+return smalltalk.withContext(function($ctx1) { 
+($ctx1.supercall = true, globals.HLSUnitModelTest.superclass.fn.prototype._setUp.apply(_st(self), []));
+$ctx1.supercall = false;
+self["@model"]=_st($HLSUnitModel())._new();
+return self}, function($ctx1) {$ctx1.fill(self,"setUp",{},globals.HLSUnitModelTest)})},
+args: [],
+source: "setUp\x0a\x09super setUp.\x0a\x09model := HLSUnitModel new",
+messageSends: ["setUp", "new"],
+referencedClasses: ["HLSUnitModel"]
+}),
+globals.HLSUnitModelTest);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "testClassBecomesAvailable",
+protocol: 'tests',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1;
+$2=_st(self["@model"])._testClasses();
+$ctx1.sendIdx["testClasses"]=1;
+$1=_st($2)._isEmpty();
+self._assert_($1);
+$ctx1.sendIdx["assert:"]=1;
+_st(self["@model"])._selectPackage_(self._thisPackage());
+self._assert_(_st(_st(self["@model"])._testClasses())._includes_(self._class()));
+return self}, function($ctx1) {$ctx1.fill(self,"testClassBecomesAvailable",{},globals.HLSUnitModelTest)})},
+args: [],
+source: "testClassBecomesAvailable\x0a\x09self assert: model testClasses isEmpty.\x0a\x09model selectPackage: self thisPackage.\x0a\x09self assert: (model testClasses includes: self class).\x0a\x09\x0a\x09",
+messageSends: ["assert:", "isEmpty", "testClasses", "selectPackage:", "thisPackage", "includes:", "class"],
+referencedClasses: []
+}),
+globals.HLSUnitModelTest);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "testEmptyTestResults",
+protocol: 'tests',
+fn: function (){
+var self=this;
+function $TestResult(){return globals.TestResult||(typeof TestResult=="undefined"?nil:TestResult)}
+return smalltalk.withContext(function($ctx1) { 
+self._assert_(_st(_st(self["@model"])._testResult())._isKindOf_($TestResult()));
+return self}, function($ctx1) {$ctx1.fill(self,"testEmptyTestResults",{},globals.HLSUnitModelTest)})},
+args: [],
+source: "testEmptyTestResults\x0a\x09self assert: (model testResult isKindOf: TestResult)",
+messageSends: ["assert:", "isKindOf:", "testResult"],
+referencedClasses: ["TestResult"]
+}),
+globals.HLSUnitModelTest);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "testInvertSelectedClasses",
+protocol: 'tests',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$4,$3,$6,$5,$8,$7,$10,$9;
+_st(self["@model"])._selectAllPackages();
+_st(self["@model"])._selectAllClasses();
+$1=self["@model"];
+$2=self._class();
+$ctx1.sendIdx["class"]=1;
+_st($1)._unselectClass_($2);
+$4=_st(self["@model"])._selectedClasses();
+$ctx1.sendIdx["selectedClasses"]=1;
+$3=_st($4)._notEmpty();
+self._assert_($3);
+$6=_st(self["@model"])._selectedClasses();
+$ctx1.sendIdx["selectedClasses"]=2;
+$5=_st($6)._size();
+$ctx1.sendIdx["size"]=1;
+$8=_st(_st(self["@model"])._testClasses())._size();
+$ctx1.sendIdx["size"]=2;
+$7=_st($8).__minus((1));
+self._assert_equals_($5,$7);
+$ctx1.sendIdx["assert:equals:"]=1;
+_st(self["@model"])._invertSelectedClasses();
+$10=_st(self["@model"])._selectedClasses();
+$ctx1.sendIdx["selectedClasses"]=3;
+$9=_st($10)._size();
+self._assert_equals_($9,(1));
+$ctx1.sendIdx["assert:equals:"]=2;
+self._assert_equals_(_st(_st(self["@model"])._selectedClasses())._anyOne(),self._class());
+return self}, function($ctx1) {$ctx1.fill(self,"testInvertSelectedClasses",{},globals.HLSUnitModelTest)})},
+args: [],
+source: "testInvertSelectedClasses\x0a\x09model selectAllPackages.\x0a\x09model selectAllClasses.\x0a\x09model unselectClass: self class.\x0a\x09self assert: model selectedClasses notEmpty.\x0a\x09self assert: model selectedClasses size equals: model testClasses size - 1.\x0a\x09model invertSelectedClasses.\x0a\x09self assert: model selectedClasses size equals: 1.\x0a\x09self assert: model selectedClasses anyOne equals: self class.",
+messageSends: ["selectAllPackages", "selectAllClasses", "unselectClass:", "class", "assert:", "notEmpty", "selectedClasses", "assert:equals:", "size", "-", "testClasses", "invertSelectedClasses", "anyOne"],
+referencedClasses: []
+}),
+globals.HLSUnitModelTest);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "testInvertSelectedPackages",
+protocol: 'tests',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$4,$3,$6,$5,$8,$7,$10,$9;
+_st(self["@model"])._selectAllPackages();
+$1=self["@model"];
+$2=self._thisPackage();
+$ctx1.sendIdx["thisPackage"]=1;
+_st($1)._unselectPackage_($2);
+$4=_st(self["@model"])._selectedPackages();
+$ctx1.sendIdx["selectedPackages"]=1;
+$3=_st($4)._notEmpty();
+self._assert_($3);
+$6=_st(self["@model"])._selectedPackages();
+$ctx1.sendIdx["selectedPackages"]=2;
+$5=_st($6)._size();
+$ctx1.sendIdx["size"]=1;
+$8=_st(_st(self["@model"])._testPackages())._size();
+$ctx1.sendIdx["size"]=2;
+$7=_st($8).__minus((1));
+self._assert_equals_($5,$7);
+$ctx1.sendIdx["assert:equals:"]=1;
+_st(self["@model"])._invertSelectedPackages();
+$10=_st(self["@model"])._selectedPackages();
+$ctx1.sendIdx["selectedPackages"]=3;
+$9=_st($10)._size();
+self._assert_equals_($9,(1));
+$ctx1.sendIdx["assert:equals:"]=2;
+self._assert_equals_(_st(_st(self["@model"])._selectedPackages())._anyOne(),self._thisPackage());
+return self}, function($ctx1) {$ctx1.fill(self,"testInvertSelectedPackages",{},globals.HLSUnitModelTest)})},
+args: [],
+source: "testInvertSelectedPackages\x0a\x09model selectAllPackages.\x0a\x09model unselectPackage: self thisPackage.\x0a\x09self assert: model selectedPackages notEmpty.\x0a\x09self assert: model selectedPackages size equals: model testPackages size - 1.\x0a\x09model invertSelectedPackages.\x0a\x09self assert: model selectedPackages size equals: 1.\x0a\x09self assert: model selectedPackages anyOne equals: self thisPackage.",
+messageSends: ["selectAllPackages", "unselectPackage:", "thisPackage", "assert:", "notEmpty", "selectedPackages", "assert:equals:", "size", "-", "testPackages", "invertSelectedPackages", "anyOne"],
+referencedClasses: []
+}),
+globals.HLSUnitModelTest);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "testSelectAllClasses",
+protocol: 'tests',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$3;
+_st(self["@model"])._selectAllPackages();
+$2=_st(self["@model"])._testClasses();
+$ctx1.sendIdx["testClasses"]=1;
+$1=_st($2)._notEmpty();
+self._assert_($1);
+_st(self["@model"])._selectAllClasses();
+$3=_st(_st(self["@model"])._selectedClasses())._size();
+$ctx1.sendIdx["size"]=1;
+self._assert_equals_($3,_st(_st(self["@model"])._testClasses())._size());
+return self}, function($ctx1) {$ctx1.fill(self,"testSelectAllClasses",{},globals.HLSUnitModelTest)})},
+args: [],
+source: "testSelectAllClasses\x0a\x09model selectAllPackages.\x0a\x09self assert: model testClasses notEmpty.\x0a\x09model selectAllClasses.\x0a\x09self assert: model selectedClasses size equals: model testClasses size",
+messageSends: ["selectAllPackages", "assert:", "notEmpty", "testClasses", "selectAllClasses", "assert:equals:", "size", "selectedClasses"],
+referencedClasses: []
+}),
+globals.HLSUnitModelTest);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "testSelectAllPackages",
+protocol: 'tests',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$3;
+$2=_st(self["@model"])._selectedPackages();
+$ctx1.sendIdx["selectedPackages"]=1;
+$1=_st($2)._isEmpty();
+self._assert_($1);
+_st(self["@model"])._selectAllPackages();
+$3=_st(_st(self["@model"])._selectedPackages())._size();
+$ctx1.sendIdx["size"]=1;
+self._assert_equals_($3,_st(_st(self["@model"])._testPackages())._size());
+return self}, function($ctx1) {$ctx1.fill(self,"testSelectAllPackages",{},globals.HLSUnitModelTest)})},
+args: [],
+source: "testSelectAllPackages\x0a\x09self assert: model selectedPackages isEmpty.\x0a\x09model selectAllPackages.\x0a\x09self assert: model selectedPackages size equals: model testPackages size",
+messageSends: ["assert:", "isEmpty", "selectedPackages", "selectAllPackages", "assert:equals:", "size", "testPackages"],
+referencedClasses: []
+}),
+globals.HLSUnitModelTest);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "testSelectClass",
+protocol: 'tests',
+fn: function (){
+var self=this;
+var announcementFired;
+function $HLClassSelected(){return globals.HLClassSelected||(typeof HLClassSelected=="undefined"?nil:HLClassSelected)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$3,$4;
+_st(self["@model"])._selectPackage_(self._thisPackage());
+$2=_st(self["@model"])._selectedClasses();
+$ctx1.sendIdx["selectedClasses"]=1;
+$1=_st($2)._isEmpty();
+self._assert_($1);
+$ctx1.sendIdx["assert:"]=1;
+_st(_st(self["@model"])._announcer())._on_do_for_($HLClassSelected(),(function(){
+announcementFired=true;
+return announcementFired;
+}),self);
+$3=self["@model"];
+$4=self._class();
+$ctx1.sendIdx["class"]=1;
+_st($3)._selectClass_($4);
+self._assert_equals_(_st(_st(self["@model"])._selectedClasses())._anyOne(),self._class());
+self._assert_(announcementFired);
+return self}, function($ctx1) {$ctx1.fill(self,"testSelectClass",{announcementFired:announcementFired},globals.HLSUnitModelTest)})},
+args: [],
+source: "testSelectClass\x0a\x09| announcementFired |\x0a\x09model selectPackage: self thisPackage.\x0a\x09self assert: model selectedClasses isEmpty.\x0a\x09model announcer on: HLClassSelected\x0a\x09\x09do: [ announcementFired := true ]\x0a\x09\x09for: self.\x0a\x09model selectClass: self class.\x0a\x09self assert: model selectedClasses anyOne equals: self class.\x0a\x09self assert: announcementFired.\x0a\x09\x0a\x09",
+messageSends: ["selectPackage:", "thisPackage", "assert:", "isEmpty", "selectedClasses", "on:do:for:", "announcer", "selectClass:", "class", "assert:equals:", "anyOne"],
+referencedClasses: ["HLClassSelected"]
+}),
+globals.HLSUnitModelTest);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "testSelectPackage",
+protocol: 'tests',
+fn: function (){
+var self=this;
+var announcementFired;
+function $HLPackageSelected(){return globals.HLPackageSelected||(typeof HLPackageSelected=="undefined"?nil:HLPackageSelected)}
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1,$3,$4;
+$2=_st(self["@model"])._selectedPackages();
+$ctx1.sendIdx["selectedPackages"]=1;
+$1=_st($2)._isEmpty();
+self._assert_($1);
+$ctx1.sendIdx["assert:"]=1;
+_st(_st(self["@model"])._announcer())._on_do_for_($HLPackageSelected(),(function(){
+announcementFired=true;
+return announcementFired;
+}),self);
+$3=self["@model"];
+$4=self._thisPackage();
+$ctx1.sendIdx["thisPackage"]=1;
+_st($3)._selectPackage_($4);
+self._assert_equals_(_st(_st(self["@model"])._selectedPackages())._anyOne(),self._thisPackage());
+self._assert_(announcementFired);
+return self}, function($ctx1) {$ctx1.fill(self,"testSelectPackage",{announcementFired:announcementFired},globals.HLSUnitModelTest)})},
+args: [],
+source: "testSelectPackage\x0a\x09| announcementFired |\x0a\x09self assert: model selectedPackages isEmpty.\x0a\x09model announcer on: HLPackageSelected\x0a\x09\x09do: [ announcementFired := true ]\x0a\x09\x09for: self.\x0a\x09model selectPackage: self thisPackage.\x0a\x09self assert: model selectedPackages anyOne equals: self thisPackage.\x0a\x09self assert: announcementFired",
+messageSends: ["assert:", "isEmpty", "selectedPackages", "on:do:for:", "announcer", "selectPackage:", "thisPackage", "assert:equals:", "anyOne"],
+referencedClasses: ["HLPackageSelected"]
+}),
+globals.HLSUnitModelTest);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "testSelectedClassNotListedIfPackageUnselected",
+protocol: 'tests',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2,$3,$4,$6,$5;
+$1=self["@model"];
+$2=self._thisPackage();
+$ctx1.sendIdx["thisPackage"]=1;
+_st($1)._selectPackage_($2);
+$3=self["@model"];
+$4=self._class();
+$ctx1.sendIdx["class"]=1;
+_st($3)._selectClass_($4);
+$6=_st(self["@model"])._selectedClasses();
+$ctx1.sendIdx["selectedClasses"]=1;
+$5=_st($6)._anyOne();
+self._assert_equals_($5,self._class());
+_st(self["@model"])._unselectPackage_(self._thisPackage());
+self._assert_(_st(_st(self["@model"])._selectedClasses())._isEmpty());
+return self}, function($ctx1) {$ctx1.fill(self,"testSelectedClassNotListedIfPackageUnselected",{},globals.HLSUnitModelTest)})},
+args: [],
+source: "testSelectedClassNotListedIfPackageUnselected\x0a\x09model selectPackage: self thisPackage.\x0a\x09model selectClass: self class.\x0a\x09self assert: model selectedClasses anyOne equals: self class.\x0a\x09model unselectPackage: self thisPackage.\x0a\x09self assert: model selectedClasses isEmpty.\x0a\x09",
+messageSends: ["selectPackage:", "thisPackage", "selectClass:", "class", "assert:equals:", "anyOne", "selectedClasses", "unselectPackage:", "assert:", "isEmpty"],
+referencedClasses: []
+}),
+globals.HLSUnitModelTest);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "testTestClassHasOnlyTestClasses",
+protocol: 'tests',
+fn: function (){
+var self=this;
+var notATestClass;
+function $Object(){return globals.Object||(typeof Object=="undefined"?nil:Object)}
+function $Smalltalk(){return globals.Smalltalk||(typeof Smalltalk=="undefined"?nil:Smalltalk)}
+return smalltalk.withContext(function($ctx1) { 
+notATestClass=_st($Object())._subclass_instanceVariableNames_package_("HLNotATestClass","",_st(self._class())._category());
+_st(self["@model"])._selectPackage_(self._thisPackage());
+self._deny_(_st(_st(self["@model"])._testClasses())._includes_(notATestClass));
+_st($Smalltalk())._removeClass_(notATestClass);
+return self}, function($ctx1) {$ctx1.fill(self,"testTestClassHasOnlyTestClasses",{notATestClass:notATestClass},globals.HLSUnitModelTest)})},
+args: [],
+source: "testTestClassHasOnlyTestClasses\x0a\x09| notATestClass |\x0a\x09notATestClass := Object subclass: #HLNotATestClass\x0a\x09\x09instanceVariableNames: ''\x0a\x09\x09package: self class category.\x0a\x09model selectPackage: self thisPackage.\x0a\x09self deny: (model testClasses includes: notATestClass).\x0a\x09Smalltalk removeClass: notATestClass.\x0a\x09\x0a\x09",
+messageSends: ["subclass:instanceVariableNames:package:", "category", "class", "selectPackage:", "thisPackage", "deny:", "includes:", "testClasses", "removeClass:"],
+referencedClasses: ["Object", "Smalltalk"]
+}),
+globals.HLSUnitModelTest);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "testTestPackages",
+protocol: 'tests',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $2,$1;
+$2=_st(self["@model"])._testPackages();
+$ctx1.sendIdx["testPackages"]=1;
+$1=_st($2)._notEmpty();
+self._assert_($1);
+$ctx1.sendIdx["assert:"]=1;
+self._assert_(_st(_st(self["@model"])._testPackages())._anySatisfy_((function(each){
+return smalltalk.withContext(function($ctx2) {
+return _st(each).__eq(self._thisPackage());
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)})})));
+return self}, function($ctx1) {$ctx1.fill(self,"testTestPackages",{},globals.HLSUnitModelTest)})},
+args: [],
+source: "testTestPackages\x0a\x09self assert: model testPackages notEmpty.\x0a\x09self assert: (model testPackages anySatisfy: [:each | each = self thisPackage]).",
+messageSends: ["assert:", "notEmpty", "testPackages", "anySatisfy:", "=", "thisPackage"],
+referencedClasses: []
+}),
+globals.HLSUnitModelTest);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "testUnselectClass",
+protocol: 'tests',
+fn: function (){
+var self=this;
+var announcementFired;
+function $HLClassUnselected(){return globals.HLClassUnselected||(typeof HLClassUnselected=="undefined"?nil:HLClassUnselected)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+_st(self["@model"])._selectPackage_(self._thisPackage());
+$1=self["@model"];
+$2=self._class();
+$ctx1.sendIdx["class"]=1;
+_st($1)._selectClass_($2);
+_st(_st(self["@model"])._announcer())._on_do_for_($HLClassUnselected(),(function(){
+announcementFired=true;
+return announcementFired;
+}),self);
+_st(self["@model"])._unselectClass_(self._class());
+self._assert_(_st(_st(self["@model"])._selectedClasses())._isEmpty());
+$ctx1.sendIdx["assert:"]=1;
+self._assert_(announcementFired);
+return self}, function($ctx1) {$ctx1.fill(self,"testUnselectClass",{announcementFired:announcementFired},globals.HLSUnitModelTest)})},
+args: [],
+source: "testUnselectClass\x0a\x09| announcementFired |\x0a\x09model selectPackage: self thisPackage.\x0a\x09model selectClass: self class.\x0a\x09model announcer on: HLClassUnselected\x0a\x09\x09do: [ announcementFired := true ]\x0a\x09\x09for: self.\x0a\x09model unselectClass: self class.\x0a\x09self assert: model selectedClasses isEmpty.\x0a\x09self assert: announcementFired\x0a\x09\x0a\x09",
+messageSends: ["selectPackage:", "thisPackage", "selectClass:", "class", "on:do:for:", "announcer", "unselectClass:", "assert:", "isEmpty", "selectedClasses"],
+referencedClasses: ["HLClassUnselected"]
+}),
+globals.HLSUnitModelTest);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "testUnselectPackage",
+protocol: 'tests',
+fn: function (){
+var self=this;
+var announcementFired;
+function $HLPackageUnselected(){return globals.HLPackageUnselected||(typeof HLPackageUnselected=="undefined"?nil:HLPackageUnselected)}
+return smalltalk.withContext(function($ctx1) { 
+var $1,$2;
+$1=self["@model"];
+$2=self._thisPackage();
+$ctx1.sendIdx["thisPackage"]=1;
+_st($1)._selectPackage_($2);
+_st(_st(self["@model"])._announcer())._on_do_for_($HLPackageUnselected(),(function(){
+announcementFired=true;
+return announcementFired;
+}),self);
+_st(self["@model"])._unselectPackage_(self._thisPackage());
+self._assert_(_st(_st(self["@model"])._selectedPackages())._isEmpty());
+$ctx1.sendIdx["assert:"]=1;
+self._assert_(announcementFired);
+return self}, function($ctx1) {$ctx1.fill(self,"testUnselectPackage",{announcementFired:announcementFired},globals.HLSUnitModelTest)})},
+args: [],
+source: "testUnselectPackage\x0a\x09| announcementFired |\x0a\x09model selectPackage: self thisPackage.\x0a\x09model announcer on: HLPackageUnselected\x0a\x09\x09do: [ announcementFired := true ]\x0a\x09\x09for: self.\x0a\x09model unselectPackage: self thisPackage.\x0a\x09self assert: model selectedPackages isEmpty.\x0a\x09self assert: announcementFired.",
+messageSends: ["selectPackage:", "thisPackage", "on:do:for:", "announcer", "unselectPackage:", "assert:", "isEmpty", "selectedPackages"],
+referencedClasses: ["HLPackageUnselected"]
+}),
+globals.HLSUnitModelTest);
+
+smalltalk.addMethod(
+smalltalk.method({
+selector: "thisPackage",
+protocol: 'accessing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+var $1;
+$1=_st(self._class())._package();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"thisPackage",{},globals.HLSUnitModelTest)})},
+args: [],
+source: "thisPackage\x0a\x09^self class package",
+messageSends: ["package", "class"],
+referencedClasses: []
+}),
+globals.HLSUnitModelTest);
+
+
+});

src/Helios-SUnit-Tests.st

@@ -0,0 +1,135 @@
+Smalltalk createPackage: 'Helios-SUnit-Tests'!
+TestCase subclass: #HLSUnitModelTest
+	instanceVariableNames: 'model'
+	package: 'Helios-SUnit-Tests'!
+!HLSUnitModelTest commentStamp!
+Test cases for the functionality of  `HLSUnitModel`!
+
+!HLSUnitModelTest methodsFor: 'accessing'!
+
+thisPackage
+	^self class package
+! !
+
+!HLSUnitModelTest methodsFor: 'initializing'!
+
+setUp
+	super setUp.
+	model := HLSUnitModel new
+! !
+
+!HLSUnitModelTest methodsFor: 'tests'!
+
+testClassBecomesAvailable
+	self assert: model testClasses isEmpty.
+	model selectPackage: self thisPackage.
+	self assert: (model testClasses includes: self class).
+!
+
+testEmptyTestResults
+	self assert: (model testResult isKindOf: TestResult)
+!
+
+testInvertSelectedClasses
+	model selectAllPackages.
+	model selectAllClasses.
+	model unselectClass: self class.
+	self assert: model selectedClasses notEmpty.
+	self assert: model selectedClasses size equals: model testClasses size - 1.
+	model invertSelectedClasses.
+	self assert: model selectedClasses size equals: 1.
+	self assert: model selectedClasses anyOne equals: self class.
+!
+
+testInvertSelectedPackages
+	model selectAllPackages.
+	model unselectPackage: self thisPackage.
+	self assert: model selectedPackages notEmpty.
+	self assert: model selectedPackages size equals: model testPackages size - 1.
+	model invertSelectedPackages.
+	self assert: model selectedPackages size equals: 1.
+	self assert: model selectedPackages anyOne equals: self thisPackage.
+!
+
+testSelectAllClasses
+	model selectAllPackages.
+	self assert: model testClasses notEmpty.
+	model selectAllClasses.
+	self assert: model selectedClasses size equals: model testClasses size
+!
+
+testSelectAllPackages
+	self assert: model selectedPackages isEmpty.
+	model selectAllPackages.
+	self assert: model selectedPackages size equals: model testPackages size
+!
+
+testSelectClass
+	| announcementFired |
+	model selectPackage: self thisPackage.
+	self assert: model selectedClasses isEmpty.
+	model announcer on: HLClassSelected
+		do: [ announcementFired := true ]
+		for: self.
+	model selectClass: self class.
+	self assert: model selectedClasses anyOne equals: self class.
+	self assert: announcementFired.
+!
+
+testSelectPackage
+	| announcementFired |
+	self assert: model selectedPackages isEmpty.
+	model announcer on: HLPackageSelected
+		do: [ announcementFired := true ]
+		for: self.
+	model selectPackage: self thisPackage.
+	self assert: model selectedPackages anyOne equals: self thisPackage.
+	self assert: announcementFired
+!
+
+testSelectedClassNotListedIfPackageUnselected
+	model selectPackage: self thisPackage.
+	model selectClass: self class.
+	self assert: model selectedClasses anyOne equals: self class.
+	model unselectPackage: self thisPackage.
+	self assert: model selectedClasses isEmpty.
+!
+
+testTestClassHasOnlyTestClasses
+	| notATestClass |
+	notATestClass := Object subclass: #HLNotATestClass
+		instanceVariableNames: ''
+		package: self class category.
+	model selectPackage: self thisPackage.
+	self deny: (model testClasses includes: notATestClass).
+	Smalltalk removeClass: notATestClass.
+!
+
+testTestPackages
+	self assert: model testPackages notEmpty.
+	self assert: (model testPackages anySatisfy: [:each | each = self thisPackage]).
+!
+
+testUnselectClass
+	| announcementFired |
+	model selectPackage: self thisPackage.
+	model selectClass: self class.
+	model announcer on: HLClassUnselected
+		do: [ announcementFired := true ]
+		for: self.
+	model unselectClass: self class.
+	self assert: model selectedClasses isEmpty.
+	self assert: announcementFired
+!
+
+testUnselectPackage
+	| announcementFired |
+	model selectPackage: self thisPackage.
+	model announcer on: HLPackageUnselected
+		do: [ announcementFired := true ]
+		for: self.
+	model unselectPackage: self thisPackage.
+	self assert: model selectedPackages isEmpty.
+	self assert: announcementFired.
+! !
+