resin 0.3.1 → 0.4.0

data/amber/js/SUnit.js

@@ -7,8 +7,10 @@ selector: "result",
 category: 'accessing',
 fn: function (){
 var self=this;
-return self["@result"];
-},
+return smalltalk.withContext(function($ctx1) { 
+$1=self["@result"];
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"result",{}, smalltalk.ResultAnnouncement)})},
 args: [],
 source: "result\x0a\x09^result",
 messageSends: [],
@@ -23,8 +25,8 @@ selector: "result:",
 category: 'accessing',
 fn: function (aTestResult){
 var self=this;
-self["@result"]=aTestResult;
-return self},
+return smalltalk.withContext(function($ctx1) { 
+return self}, function($ctx1) {$ctx1.fill(self,"result:",{aTestResult:aTestResult}, smalltalk.ResultAnnouncement)})},
 args: ["aTestResult"],
 source: "result: aTestResult\x0a\x09result := aTestResult",
 messageSends: [],
@@ -34,17 +36,17 @@ smalltalk.ResultAnnouncement);
 
 
 
-smalltalk.addClass('TestCase', smalltalk.Object, ['testSelector'], 'SUnit');
+smalltalk.addClass('TestCase', smalltalk.Object, ['testSelector', 'asyncTimeout', 'context'], 'SUnit');
+smalltalk.TestCase.comment="A TestCase is an implementation of the command pattern to run a test.  \x0a\x0a`TestCase` instances are created with the class method `#selector:`, \x0apassing the symbol that names the method to be executed when the test case runs.\x0a\x0aWhen you discover a new fixture, subclass `TestCase` and create a `#test...` method for the first test.  \x0aAs that method develops and more `#test...` methods are added, you will find yourself refactoring temps \x0ainto instance variables for the objects in the fixture and overriding `#setUp` to initialize these variables.  \x0aAs required, override `#tearDown` to nil references, release objects and deallocate."
 smalltalk.addMethod(
 "_assert_",
 smalltalk.method({
 selector: "assert:",
 category: 'testing',
-fn: function (aBoolean) {
-    var self = this;
-    smalltalk.send(self, "_assert_description_", [aBoolean, "Assertion failed"]);
-    return self;
-},
+fn: function (aBoolean){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+return self}, function($ctx1) {$ctx1.fill(self,"assert:",{aBoolean:aBoolean}, smalltalk.TestCase)})},
 args: ["aBoolean"],
 source: "assert: aBoolean\x0a\x09self assert: aBoolean description: 'Assertion failed'",
 messageSends: ["assert:description:"],
@@ -57,13 +59,14 @@ smalltalk.addMethod(
 smalltalk.method({
 selector: "assert:description:",
 category: 'testing',
-fn: function (aBoolean, aString) {
-    var self = this;
-    if (!smalltalk.assert(aBoolean)) {
-        smalltalk.send(self, "_signalFailure_", [aString]);
-    }
-    return self;
-},
+fn: function (aBoolean,aString){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+$1=aBoolean;
+if(! smalltalk.assert($1)){
+_st(self)._signalFailure_(aString);
+};
+return self}, function($ctx1) {$ctx1.fill(self,"assert:description:",{aBoolean:aBoolean,aString:aString}, smalltalk.TestCase)})},
 args: ["aBoolean", "aString"],
 source: "assert: aBoolean description: aString\x0a\x09aBoolean ifFalse: [self signalFailure: aString]",
 messageSends: ["ifFalse:", "signalFailure:"],
@@ -76,12 +79,12 @@ smalltalk.addMethod(
 smalltalk.method({
 selector: "assert:equals:",
 category: 'testing',
-fn: function (expected, actual) {
-    var self = this;
-    var $1;
-    $1 = smalltalk.send(self, "_assert_description_", [smalltalk.send(expected, "__eq", [actual]), smalltalk.send(smalltalk.send(smalltalk.send("Expected: ", "__comma", [smalltalk.send(expected, "_asString", [])]), "__comma", [" but was: "]), "__comma", [smalltalk.send(actual, "_asString", [])])]);
-    return $1;
-},
+fn: function (expected,actual){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+$1=_st(self)._assert_description_(_st(expected).__eq(actual),_st(_st(_st("Expected: ").__comma(_st(expected)._asString())).__comma(" but was: ")).__comma(_st(actual)._asString()));
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"assert:equals:",{expected:expected,actual:actual}, smalltalk.TestCase)})},
 args: ["expected", "actual"],
 source: "assert: expected equals: actual\x0a\x09^ self assert: (expected = actual) description: 'Expected: ', expected asString, ' but was: ', actual asString",
 messageSends: ["assert:description:", "=", ",", "asString"],
@@ -89,16 +92,57 @@ referencedClasses: []
 }),
 smalltalk.TestCase);
 
+smalltalk.addMethod(
+"_async_",
+smalltalk.method({
+selector: "async:",
+category: 'async',
+fn: function (aBlock){
+var self=this;
+var c;
+return smalltalk.withContext(function($ctx1) { 
+_st(self)._errorIfNotAsync_("#async");
+c=self["@context"];
+$1=(function(){
+return smalltalk.withContext(function($ctx2) {
+if(smalltalk.assert($2)){
+return _st(c)._execute_(aBlock);
+};
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})});
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"async:",{aBlock:aBlock,c:c}, smalltalk.TestCase)})},
+args: ["aBlock"],
+source: "async: aBlock\x0a\x09| c |\x0a\x09self errorIfNotAsync: '#async'.\x0a    c := context.\x0a    ^ [ self isAsync ifTrue: [ c execute: aBlock ] ]",
+messageSends: ["errorIfNotAsync:", "ifTrue:", "execute:", "isAsync"],
+referencedClasses: []
+}),
+smalltalk.TestCase);
+
+smalltalk.addMethod(
+"_context_",
+smalltalk.method({
+selector: "context:",
+category: 'accessing',
+fn: function (aRunningTestContext){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+return self}, function($ctx1) {$ctx1.fill(self,"context:",{aRunningTestContext:aRunningTestContext}, smalltalk.TestCase)})},
+args: ["aRunningTestContext"],
+source: "context: aRunningTestContext\x0a\x09context := aRunningTestContext",
+messageSends: [],
+referencedClasses: []
+}),
+smalltalk.TestCase);
+
 smalltalk.addMethod(
 "_deny_",
 smalltalk.method({
 selector: "deny:",
 category: 'testing',
-fn: function (aBoolean) {
-    var self = this;
-    smalltalk.send(self, "_assert_", [smalltalk.send(aBoolean, "_not", [])]);
-    return self;
-},
+fn: function (aBoolean){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+return self}, function($ctx1) {$ctx1.fill(self,"deny:",{aBoolean:aBoolean}, smalltalk.TestCase)})},
 args: ["aBoolean"],
 source: "deny: aBoolean\x0a\x09self assert: aBoolean not",
 messageSends: ["assert:", "not"],
@@ -106,6 +150,61 @@ referencedClasses: []
 }),
 smalltalk.TestCase);
 
+smalltalk.addMethod(
+"_errorIfNotAsync_",
+smalltalk.method({
+selector: "errorIfNotAsync:",
+category: 'error handling',
+fn: function (aString){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+$1=_st(self)._isAsync();
+if(! smalltalk.assert($1)){
+_st(self)._error_(_st(aString).__comma(" used without prior #timeout:"));
+};
+return self}, function($ctx1) {$ctx1.fill(self,"errorIfNotAsync:",{aString:aString}, smalltalk.TestCase)})},
+args: ["aString"],
+source: "errorIfNotAsync: aString\x0a\x09self isAsync ifFalse: [ \x0a    \x09self error: aString, ' used without prior #timeout:' ]",
+messageSends: ["ifFalse:", "error:", ",", "isAsync"],
+referencedClasses: []
+}),
+smalltalk.TestCase);
+
+smalltalk.addMethod(
+"_finished",
+smalltalk.method({
+selector: "finished",
+category: 'async',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self["@asyncTimeout"]=nil;
+return self}, function($ctx1) {$ctx1.fill(self,"finished",{}, smalltalk.TestCase)})},
+args: [],
+source: "finished\x0a\x09self errorIfNotAsync: '#finished'.\x0a\x09asyncTimeout := nil",
+messageSends: ["errorIfNotAsync:"],
+referencedClasses: []
+}),
+smalltalk.TestCase);
+
+smalltalk.addMethod(
+"_isAsync",
+smalltalk.method({
+selector: "isAsync",
+category: 'testing',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+$1=_st(self["@asyncTimeout"])._notNil();
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"isAsync",{}, smalltalk.TestCase)})},
+args: [],
+source: "isAsync\x0a\x09^asyncTimeout notNil",
+messageSends: ["notNil"],
+referencedClasses: []
+}),
+smalltalk.TestCase);
+
 smalltalk.addMethod(
 "_performTest",
 smalltalk.method({
@@ -113,10 +212,11 @@ selector: "performTest",
 category: 'running',
 fn: function (){
 var self=this;
-smalltalk.send(self,"_perform_",[smalltalk.send(self,"_selector",[])]);
-return self},
+return smalltalk.withContext(function($ctx1) { 
+_st(self)._perform_(_st(self)._selector());
+return self}, function($ctx1) {$ctx1.fill(self,"performTest",{}, smalltalk.TestCase)})},
 args: [],
-source: "performTest\x0a\x09self perform: self selector\x0a",
+source: "performTest\x0a\x09asyncTimeout := nil.\x0a\x09self perform: self selector",
 messageSends: ["perform:", "selector"],
 referencedClasses: []
 }),
@@ -129,17 +229,12 @@ selector: "runCase",
 category: 'running',
 fn: function (){
 var self=this;
-smalltalk.send((function(){
-smalltalk.send(self,"_setUp",[]);
-return smalltalk.send(self,"_performTest",[]);
-}),"_ensure_",[(function(){
-return smalltalk.send(self,"_tearDown",[]);
-})]);
-return self},
+return smalltalk.withContext(function($ctx1) { 
+return self}, function($ctx1) {$ctx1.fill(self,"runCase",{}, smalltalk.TestCase)})},
 args: [],
-source: "runCase\x0a\x09[\x09self setUp.\x0a\x09\x09self performTest ] ensure: [\x0a\x09\x09self tearDown.\x0a\x09\x09\x22self cleanUpInstanceVariables\x22 ]\x0a",
-messageSends: ["ensure:", "tearDown", "setUp", "performTest"],
-referencedClasses: []
+source: "runCase\x0a\x09\x22Runs a test case in isolated context, leaking all errors.\x22\x0a\x0a\x09(TestContext testCase: self) start",
+messageSends: ["start", "testCase:"],
+referencedClasses: ["TestContext"]
 }),
 smalltalk.TestCase);
 
@@ -148,10 +243,12 @@ smalltalk.addMethod(
 smalltalk.method({
 selector: "selector",
 category: 'accessing',
-fn: function () {
-    var self = this;
-    return self['@testSelector'];
-},
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+$1=self["@testSelector"];
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"selector",{}, smalltalk.TestCase)})},
 args: [],
 source: "selector\x0a\x09^testSelector",
 messageSends: [],
@@ -164,11 +261,10 @@ smalltalk.addMethod(
 smalltalk.method({
 selector: "setTestSelector:",
 category: 'accessing',
-fn: function (aSelector) {
-    var self = this;
-    self['@testSelector'] = aSelector;
-    return self;
-},
+fn: function (aSelector){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+return self}, function($ctx1) {$ctx1.fill(self,"setTestSelector:",{aSelector:aSelector}, smalltalk.TestCase)})},
 args: ["aSelector"],
 source: "setTestSelector: aSelector\x0a\x09testSelector := aSelector",
 messageSends: [],
@@ -181,10 +277,9 @@ smalltalk.addMethod(
 smalltalk.method({
 selector: "setUp",
 category: 'running',
-fn: function () {
-    var self = this;
-    return self;
-},
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
 args: [],
 source: "setUp",
 messageSends: [],
@@ -197,11 +292,10 @@ smalltalk.addMethod(
 smalltalk.method({
 selector: "should:",
 category: 'testing',
-fn: function (aBlock) {
-    var self = this;
-    smalltalk.send(self, "_assert_", [smalltalk.send(aBlock, "_value", [])]);
-    return self;
-},
+fn: function (aBlock){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+return self}, function($ctx1) {$ctx1.fill(self,"should:",{aBlock:aBlock}, smalltalk.TestCase)})},
 args: ["aBlock"],
 source: "should: aBlock\x0a\x09self assert: aBlock value",
 messageSends: ["assert:", "value"],
@@ -214,11 +308,15 @@ smalltalk.addMethod(
 smalltalk.method({
 selector: "should:raise:",
 category: 'testing',
-fn: function (aBlock, anExceptionClass) {
-    var self = this;
-    smalltalk.send(self, "_assert_", [smalltalk.send(function () {smalltalk.send(aBlock, "_value", []);return false;}, "_on_do_", [anExceptionClass, function (ex) {return true;}])]);
-    return self;
-},
+fn: function (aBlock,anExceptionClass){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+return smalltalk.withContext(function($ctx2) {
+return false;
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}))._on_do_(anExceptionClass,(function(ex){
+return smalltalk.withContext(function($ctx2) {
+}, function($ctx2) {$ctx2.fillBlock({ex:ex},$ctx1)})})));
+return self}, function($ctx1) {$ctx1.fill(self,"should:raise:",{aBlock:aBlock,anExceptionClass:anExceptionClass}, smalltalk.TestCase)})},
 args: ["aBlock", "anExceptionClass"],
 source: "should: aBlock raise: anExceptionClass\x0a\x09self assert: ([aBlock value. false] \x0a\x09\x09on: anExceptionClass \x0a\x09\x09do: [:ex | true])",
 messageSends: ["assert:", "on:do:", "value"],
@@ -231,11 +329,15 @@ smalltalk.addMethod(
 smalltalk.method({
 selector: "shouldnt:raise:",
 category: 'testing',
-fn: function (aBlock, anExceptionClass) {
-    var self = this;
-    smalltalk.send(self, "_assert_", [smalltalk.send(function () {smalltalk.send(aBlock, "_value", []);return true;}, "_on_do_", [anExceptionClass, function (ex) {return false;}])]);
-    return self;
-},
+fn: function (aBlock,anExceptionClass){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+return smalltalk.withContext(function($ctx2) {
+return true;
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}))._on_do_(anExceptionClass,(function(ex){
+return smalltalk.withContext(function($ctx2) {
+}, function($ctx2) {$ctx2.fillBlock({ex:ex},$ctx1)})})));
+return self}, function($ctx1) {$ctx1.fill(self,"shouldnt:raise:",{aBlock:aBlock,anExceptionClass:anExceptionClass}, smalltalk.TestCase)})},
 args: ["aBlock", "anExceptionClass"],
 source: "shouldnt: aBlock raise: anExceptionClass\x0a\x09self assert: ([aBlock value. true] \x0a\x09\x09on: anExceptionClass \x0a\x09\x09do: [:ex | false])",
 messageSends: ["assert:", "on:do:", "value"],
@@ -248,14 +350,13 @@ smalltalk.addMethod(
 smalltalk.method({
 selector: "signalFailure:",
 category: 'private',
-fn: function (aString) {
-    var self = this;
-    var $1, $2;
-    $1 = smalltalk.send(smalltalk.TestFailure || TestFailure, "_new", []);
-    smalltalk.send($1, "_messageText_", [aString]);
-    $2 = smalltalk.send($1, "_signal", []);
-    return self;
-},
+fn: function (aString){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+$1=_st((smalltalk.TestFailure || TestFailure))._new();
+_st($1)._messageText_(aString);
+$2=_st($1)._signal();
+return self}, function($ctx1) {$ctx1.fill(self,"signalFailure:",{aString:aString}, smalltalk.TestCase)})},
 args: ["aString"],
 source: "signalFailure: aString\x0a\x09TestFailure new\x0a\x09\x09messageText: aString;\x0a\x09\x09signal",
 messageSends: ["messageText:", "new", "signal"],
@@ -268,10 +369,9 @@ smalltalk.addMethod(
 smalltalk.method({
 selector: "tearDown",
 category: 'running',
-fn: function () {
-    var self = this;
-    return self;
-},
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
 args: [],
 source: "tearDown",
 messageSends: [],
@@ -279,23 +379,50 @@ referencedClasses: []
 }),
 smalltalk.TestCase);
 
+smalltalk.addMethod(
+"_timeout_",
+smalltalk.method({
+selector: "timeout:",
+category: 'async',
+fn: function (aNumber){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+$1=self["@asyncTimeout"];
+if(($receiver = $1) == nil || $receiver == undefined){
+$1;
+} else {
+_st(self["@asyncTimeout"])._clearTimeout();
+};
+self["@asyncTimeout"]=(0);
+self["@asyncTimeout"]=_st(_st(self)._async_((function(){
+return smalltalk.withContext(function($ctx2) {
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})})))._valueWithTimeout_(aNumber);
+return self}, function($ctx1) {$ctx1.fill(self,"timeout:",{aNumber:aNumber}, smalltalk.TestCase)})},
+args: ["aNumber"],
+source: "timeout: aNumber\x0a\x09\x22Set a grace time timeout in milliseconds to run the test asynchronously\x22\x0a    \x0a\x09asyncTimeout ifNotNil: [ asyncTimeout clearTimeout ].\x0a    \x0a     \x22to allow #async: message send without throwing an error\x22\x0a\x09asyncTimeout := 0.\x0a    \x0a\x09asyncTimeout := (self async: [ \x0a    \x09self assert: false description: 'SUnit grace time exhausted' ])\x0a        \x09valueWithTimeout: aNumber",
+messageSends: ["ifNotNil:", "clearTimeout", "valueWithTimeout:", "async:", "assert:description:"],
+referencedClasses: []
+}),
+smalltalk.TestCase);
+
 
 smalltalk.addMethod(
 "_allTestSelectors",
 smalltalk.method({
 selector: "allTestSelectors",
 category: 'accessing',
-fn: function () {
-    var self = this;
-    var $1;
-    var selectors;
-    selectors = smalltalk.send(self, "_testSelectors", []);
-    $1 = smalltalk.send(self, "_shouldInheritSelectors", []);
-    if (smalltalk.assert($1)) {
-        smalltalk.send(selectors, "_addAll_", [smalltalk.send(smalltalk.send(self, "_superclass", []), "_allTestSelectors", [])]);
-    }
-    return selectors;
-},
+fn: function (){
+var self=this;
+var selectors;
+return smalltalk.withContext(function($ctx1) { 
+selectors=_st(self)._testSelectors();
+$1=_st(self)._shouldInheritSelectors();
+if(smalltalk.assert($1)){
+_st(selectors)._addAll_(_st(_st(self)._superclass())._allTestSelectors());
+};
+$2=selectors;
+return $2;
+}, function($ctx1) {$ctx1.fill(self,"allTestSelectors",{selectors:selectors}, smalltalk.TestCase.klass)})},
 args: [],
 source: "allTestSelectors\x0a\x09| selectors |\x0a\x09selectors := self testSelectors.\x0a\x09self shouldInheritSelectors ifTrue: [\x0a\x09\x09selectors addAll: self superclass allTestSelectors].\x0a\x09^selectors",
 messageSends: ["testSelectors", "ifTrue:", "addAll:", "allTestSelectors", "superclass", "shouldInheritSelectors"],
@@ -308,12 +435,14 @@ smalltalk.addMethod(
 smalltalk.method({
 selector: "buildSuite",
 category: 'accessing',
-fn: function () {
-    var self = this;
-    var $1;
-    $1 = smalltalk.send(smalltalk.send(self, "_allTestSelectors", []), "_collect_", [function (each) {return smalltalk.send(self, "_selector_", [each]);}]);
-    return $1;
-},
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+$1=_st(_st(self)._allTestSelectors())._collect_((function(each){
+return smalltalk.withContext(function($ctx2) {
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})}));
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"buildSuite",{}, smalltalk.TestCase.klass)})},
 args: [],
 source: "buildSuite\x0a\x09^self allTestSelectors collect: [:each | self selector: each]",
 messageSends: ["collect:", "selector:", "allTestSelectors"],
@@ -326,12 +455,12 @@ smalltalk.addMethod(
 smalltalk.method({
 selector: "isAbstract",
 category: 'testing',
-fn: function () {
-    var self = this;
-    var $1;
-    $1 = smalltalk.send(smalltalk.send(self, "_name", []), "__eq", ["TestCase"]);
-    return $1;
-},
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+$1=_st(_st(self)._name()).__eq("TestCase");
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"isAbstract",{}, smalltalk.TestCase.klass)})},
 args: [],
 source: "isAbstract\x0a\x09^ self name = 'TestCase'",
 messageSends: ["=", "name"],
@@ -344,10 +473,12 @@ smalltalk.addMethod(
 smalltalk.method({
 selector: "lookupHierarchyRoot",
 category: 'accessing',
-fn: function () {
-    var self = this;
-    return smalltalk.TestCase || TestCase;
-},
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+$1=(smalltalk.TestCase || TestCase);
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"lookupHierarchyRoot",{}, smalltalk.TestCase.klass)})},
 args: [],
 source: "lookupHierarchyRoot\x0a\x09^TestCase",
 messageSends: [],
@@ -360,15 +491,15 @@ smalltalk.addMethod(
 smalltalk.method({
 selector: "selector:",
 category: 'accessing',
-fn: function (aSelector) {
-    var self = this;
-    var $2, $3, $1;
-    $2 = smalltalk.send(self, "_new", []);
-    smalltalk.send($2, "_setTestSelector_", [aSelector]);
-    $3 = smalltalk.send($2, "_yourself", []);
-    $1 = $3;
-    return $1;
-},
+fn: function (aSelector){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+$2=_st(self)._new();
+_st($2)._setTestSelector_(aSelector);
+$3=_st($2)._yourself();
+$1=$3;
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"selector:",{aSelector:aSelector}, smalltalk.TestCase.klass)})},
 args: ["aSelector"],
 source: "selector: aSelector\x0a\x09^self new\x0a\x09\x09setTestSelector: aSelector;\x0a\x09\x09yourself",
 messageSends: ["setTestSelector:", "new", "yourself"],
@@ -381,12 +512,12 @@ smalltalk.addMethod(
 smalltalk.method({
 selector: "shouldInheritSelectors",
 category: 'testing',
-fn: function () {
-    var self = this;
-    var $1;
-    $1 = smalltalk.send(self, "_~_eq", [smalltalk.send(self, "_lookupHierarchyRoot", [])]);
-    return $1;
-},
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+$1=_st(self).__tild_eq(_st(self)._lookupHierarchyRoot());
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"shouldInheritSelectors",{}, smalltalk.TestCase.klass)})},
 args: [],
 source: "shouldInheritSelectors\x0a\x09^self ~= self lookupHierarchyRoot",
 messageSends: ["~=", "lookupHierarchyRoot"],
@@ -399,12 +530,14 @@ smalltalk.addMethod(
 smalltalk.method({
 selector: "testSelectors",
 category: 'accessing',
-fn: function () {
-    var self = this;
-    var $1;
-    $1 = smalltalk.send(smalltalk.send(smalltalk.send(self, "_methodDictionary", []), "_keys", []), "_select_", [function (each) {return smalltalk.send(each, "_match_", ["^test"]);}]);
-    return $1;
-},
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+$1=_st(_st(_st(self)._methodDictionary())._keys())._select_((function(each){
+return smalltalk.withContext(function($ctx2) {
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1)})}));
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"testSelectors",{}, smalltalk.TestCase.klass)})},
 args: [],
 source: "testSelectors\x0a\x09^self methodDictionary keys select: [:each | each match: '^test']",
 messageSends: ["select:", "match:", "keys", "methodDictionary"],
@@ -413,20 +546,229 @@ referencedClasses: []
 smalltalk.TestCase.klass);
 
 
+smalltalk.addClass('TestContext', smalltalk.Object, ['testCase'], 'SUnit');
+smalltalk.TestContext.comment="TestContext governs running a particular test case.\x0a\x0aIt's main added value is `#execute:` method which runs a block\x0aas a part of test case (restores context, nilling it afterwards,\x0acleaning/calling tearDown as appropriate for sync/async scenario)."
+smalltalk.addMethod(
+"_execute_",
+smalltalk.method({
+selector: "execute:",
+category: 'running',
+fn: function (aBlock){
+var self=this;
+var failed;
+return smalltalk.withContext(function($ctx1) { 
+_st(self["@testCase"])._context_(self);
+$1=(function(){
+return smalltalk.withContext(function($ctx2) {
+failed;
+_st(aBlock)._value();
+failed=false;
+return failed;
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})});
+$2=(function(){
+return smalltalk.withContext(function($ctx2) {
+$3=_st(failed)._and_((function(){
+return smalltalk.withContext(function($ctx3) {
+}, function($ctx3) {$ctx3.fillBlock({},$ctx1)})}));
+if(smalltalk.assert($3)){
+_st(self["@testCase"])._finished();
+};
+$4=_st(self["@testCase"])._isAsync();
+if(! smalltalk.assert($4)){
+return _st(self["@testCase"])._tearDown();
+};
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})});
+_st($1)._ensure_($2);
+return self}, function($ctx1) {$ctx1.fill(self,"execute:",{aBlock:aBlock,failed:failed}, smalltalk.TestContext)})},
+args: ["aBlock"],
+source: "execute: aBlock\x0a\x09| failed |\x0a    \x0a    testCase context: self.\x0a    [ \x0a    \x09failed := true. \x0a        aBlock value. \x0a        failed := false \x0a\x09] \x0a    \x09ensure: [\x0a        \x09testCase context: nil.\x0a            \x0a        \x09(failed and: [ testCase isAsync ]) ifTrue: [ \x0a            \x09testCase finished ].\x0a        \x09testCase isAsync ifFalse: [ \x0a        \x09\x09testCase tearDown ] ]",
+messageSends: ["context:", "ensure:", "ifTrue:", "finished", "and:", "isAsync", "ifFalse:", "tearDown", "value"],
+referencedClasses: []
+}),
+smalltalk.TestContext);
+
+smalltalk.addMethod(
+"_start",
+smalltalk.method({
+selector: "start",
+category: 'running',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+return smalltalk.withContext(function($ctx2) {
+return _st(self["@testCase"])._performTest();
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"start",{}, smalltalk.TestContext)})},
+args: [],
+source: "start\x0a\x09self execute: [ \x0a    \x09testCase setUp. \x0a        testCase performTest ]",
+messageSends: ["execute:", "setUp", "performTest"],
+referencedClasses: []
+}),
+smalltalk.TestContext);
+
+smalltalk.addMethod(
+"_testCase_",
+smalltalk.method({
+selector: "testCase:",
+category: 'accessing',
+fn: function (aTestCase){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+return self}, function($ctx1) {$ctx1.fill(self,"testCase:",{aTestCase:aTestCase}, smalltalk.TestContext)})},
+args: ["aTestCase"],
+source: "testCase: aTestCase\x0a\x09testCase := aTestCase",
+messageSends: [],
+referencedClasses: []
+}),
+smalltalk.TestContext);
+
+
+smalltalk.addMethod(
+"_testCase_",
+smalltalk.method({
+selector: "testCase:",
+category: 'instance creation',
+fn: function (aTestCase){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+$2=_st(self)._new();
+_st($2)._testCase_(aTestCase);
+$3=_st($2)._yourself();
+$1=$3;
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"testCase:",{aTestCase:aTestCase}, smalltalk.TestContext.klass)})},
+args: ["aTestCase"],
+source: "testCase: aTestCase\x0a\x09^self new\x0a        testCase: aTestCase;\x0a        yourself",
+messageSends: ["testCase:", "new", "yourself"],
+referencedClasses: []
+}),
+smalltalk.TestContext.klass);
+
+
+smalltalk.addClass('ReportingTestContext', smalltalk.TestContext, ['finished', 'result'], 'SUnit');
+smalltalk.ReportingTestContext.comment="ReportingTestContext adds `TestResult` reporting\x0ato `TestContext`.\x0a\x0aErrors are caught and save into a `TestResult`,\x0aWhen test case is finished (which can be later for async tests),\x0aa callback block is executed; this is used by a `TestSuiteRunner`."
+smalltalk.addMethod(
+"_execute_",
+smalltalk.method({
+selector: "execute:",
+category: 'running',
+fn: function (aBlock){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+$1=(function(){
+return smalltalk.withContext(function($ctx2) {
+return smalltalk.withContext(function($ctx3) {
+}, function($ctx3) {$ctx3.fillBlock({},$ctx1)})}));
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})});
+$2=(function(){
+return smalltalk.withContext(function($ctx2) {
+if(! smalltalk.assert($3)){
+_st(self["@result"])._increaseRuns();
+return _st(self["@finished"])._value();
+};
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})});
+_st($1)._ensure_($2);
+return self}, function($ctx1) {$ctx1.fill(self,"execute:",{aBlock:aBlock}, smalltalk.ReportingTestContext)})},
+args: ["aBlock"],
+source: "execute: aBlock\x0a    [ \x0a    \x09self withErrorReporting: [ super execute: aBlock ] \x0a\x09]\x0a    \x09ensure: [ \x0a        \x09testCase isAsync ifFalse: [ \x0a            \x09result increaseRuns. finished value ] ]",
+messageSends: ["ensure:", "ifFalse:", "increaseRuns", "value", "isAsync", "withErrorReporting:", "execute:"],
+referencedClasses: []
+}),
+smalltalk.ReportingTestContext);
+
+smalltalk.addMethod(
+"_finished_",
+smalltalk.method({
+selector: "finished:",
+category: 'accessing',
+fn: function (aBlock){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+return self}, function($ctx1) {$ctx1.fill(self,"finished:",{aBlock:aBlock}, smalltalk.ReportingTestContext)})},
+args: ["aBlock"],
+source: "finished: aBlock\x0a\x09finished := aBlock",
+messageSends: [],
+referencedClasses: []
+}),
+smalltalk.ReportingTestContext);
+
+smalltalk.addMethod(
+"_result_",
+smalltalk.method({
+selector: "result:",
+category: 'accessing',
+fn: function (aTestResult){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+return self}, function($ctx1) {$ctx1.fill(self,"result:",{aTestResult:aTestResult}, smalltalk.ReportingTestContext)})},
+args: ["aTestResult"],
+source: "result: aTestResult\x0a\x09result := aTestResult",
+messageSends: [],
+referencedClasses: []
+}),
+smalltalk.ReportingTestContext);
+
+smalltalk.addMethod(
+"_withErrorReporting_",
+smalltalk.method({
+selector: "withErrorReporting:",
+category: 'private',
+fn: function (aBlock){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+return smalltalk.withContext(function($ctx2) {
+return smalltalk.withContext(function($ctx3) {
+}, function($ctx3) {$ctx3.fillBlock({ex:ex},$ctx1)})}));
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}))._on_do_((smalltalk.Error || Error),(function(ex){
+return smalltalk.withContext(function($ctx2) {
+}, function($ctx2) {$ctx2.fillBlock({ex:ex},$ctx1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"withErrorReporting:",{aBlock:aBlock}, smalltalk.ReportingTestContext)})},
+args: ["aBlock"],
+source: "withErrorReporting: aBlock\x0a \x09[ aBlock\x0a\x09\x09on: TestFailure \x0a\x09\x09do: [ :ex | result addFailure: testCase ] \x0a\x09]\x0a    \x09on: Error \x0a        do: [ :ex | result addError: testCase ]",
+messageSends: ["on:do:", "addError:", "addFailure:"],
+referencedClasses: ["Error", "TestFailure"]
+}),
+smalltalk.ReportingTestContext);
+
+
+smalltalk.addMethod(
+"_testCase_result_finished_",
+smalltalk.method({
+selector: "testCase:result:finished:",
+category: 'instance creation',
+fn: function (aTestCase,aTestResult,aBlock){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+$2=smalltalk.TestContext.klass.fn.prototype._testCase_.apply(_st(self), [aTestCase]);
+_st($2)._result_(aTestResult);
+_st($2)._finished_(aBlock);
+$3=_st($2)._yourself();
+$1=$3;
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"testCase:result:finished:",{aTestCase:aTestCase,aTestResult:aTestResult,aBlock:aBlock}, smalltalk.ReportingTestContext.klass)})},
+args: ["aTestCase", "aTestResult", "aBlock"],
+source: "testCase: aTestCase result: aTestResult finished: aBlock\x0a\x09^(super testCase: aTestCase)\x0a        result: aTestResult;\x0a        finished: aBlock;\x0a        yourself",
+messageSends: ["result:", "testCase:", "finished:", "yourself"],
+referencedClasses: []
+}),
+smalltalk.ReportingTestContext.klass);
+
+
 smalltalk.addClass('TestFailure', smalltalk.Error, [], 'SUnit');
+smalltalk.TestFailure.comment="The test framework distinguishes between failures and errors.  \x0aA failure is an event whose possibiity is explicitly anticipated and checked for in an assertion, \x0awhereas an error is an unanticipated problem like a division by 0 or an index out of bounds.  \x0a\x0aTestFailure is raised when the boolean parameter of an #`assert:` or `#deny:` call is the opposite of what the assertion claims."
 
 
 smalltalk.addClass('TestResult', smalltalk.Object, ['timestamp', 'runs', 'errors', 'failures', 'total'], 'SUnit');
+smalltalk.TestResult.comment="A TestResult implements the collecting parameter pattern for running a bunch of tests.  \x0a\x0aA TestResult holds tests that have run, sorted into the result categories of passed, failures and errors.\x0a\x0aTestResult is an interesting object to subclass or substitute. `#runCase:` is the external protocol you need to reproduce"
 smalltalk.addMethod(
 "_addError_",
 smalltalk.method({
 selector: "addError:",
 category: 'accessing',
-fn: function (anError) {
-    var self = this;
-    smalltalk.send(smalltalk.send(self, "_errors", []), "_add_", [anError]);
-    return self;
-},
+fn: function (anError){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+return self}, function($ctx1) {$ctx1.fill(self,"addError:",{anError:anError}, smalltalk.TestResult)})},
 args: ["anError"],
 source: "addError: anError\x0a\x09self errors add: anError",
 messageSends: ["add:", "errors"],
@@ -439,11 +781,10 @@ smalltalk.addMethod(
 smalltalk.method({
 selector: "addFailure:",
 category: 'accessing',
-fn: function (aFailure) {
-    var self = this;
-    smalltalk.send(smalltalk.send(self, "_failures", []), "_add_", [aFailure]);
-    return self;
-},
+fn: function (aFailure){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+return self}, function($ctx1) {$ctx1.fill(self,"addFailure:",{aFailure:aFailure}, smalltalk.TestResult)})},
 args: ["aFailure"],
 source: "addFailure: aFailure\x0a\x09self failures add: aFailure",
 messageSends: ["add:", "failures"],
@@ -456,10 +797,12 @@ smalltalk.addMethod(
 smalltalk.method({
 selector: "errors",
 category: 'accessing',
-fn: function () {
-    var self = this;
-    return self['@errors'];
-},
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+$1=self["@errors"];
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"errors",{}, smalltalk.TestResult)})},
 args: [],
 source: "errors\x0a\x09^errors",
 messageSends: [],
@@ -472,10 +815,12 @@ smalltalk.addMethod(
 smalltalk.method({
 selector: "failures",
 category: 'accessing',
-fn: function () {
-    var self = this;
-    return self['@failures'];
-},
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+$1=self["@failures"];
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"failures",{}, smalltalk.TestResult)})},
 args: [],
 source: "failures\x0a\x09^failures",
 messageSends: [],
@@ -488,11 +833,10 @@ smalltalk.addMethod(
 smalltalk.method({
 selector: "increaseRuns",
 category: 'accessing',
-fn: function () {
-    var self = this;
-    self['@runs'] = smalltalk.send(self['@runs'], "__plus", [1]);
-    return self;
-},
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+return self}, function($ctx1) {$ctx1.fill(self,"increaseRuns",{}, smalltalk.TestResult)})},
 args: [],
 source: "increaseRuns\x0a\x09runs := runs + 1",
 messageSends: ["+"],
@@ -505,16 +849,15 @@ smalltalk.addMethod(
 smalltalk.method({
 selector: "initialize",
 category: 'initialization',
-fn: function () {
-    var self = this;
-    smalltalk.send(self, "_initialize", [], smalltalk.Object);
-    self['@timestamp'] = smalltalk.send(smalltalk.Date || Date, "_now", []);
-    self['@runs'] = 0;
-    self['@errors'] = smalltalk.send(smalltalk.Array || Array, "_new", []);
-    self['@failures'] = smalltalk.send(smalltalk.Array || Array, "_new", []);
-    self['@total'] = 0;
-    return self;
-},
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+self["@timestamp"]=_st((smalltalk.Date || Date))._now();
+self["@runs"]=(0);
+self["@errors"]=_st((smalltalk.Array || Array))._new();
+self["@failures"]=_st((smalltalk.Array || Array))._new();
+self["@total"]=(0);
+return self}, function($ctx1) {$ctx1.fill(self,"initialize",{}, smalltalk.TestResult)})},
 args: [],
 source: "initialize\x0a\x09super initialize.\x0a\x09timestamp := Date now.\x0a\x09runs := 0.\x0a\x09errors := Array new.\x0a\x09failures := Array new.\x0a\x09total := 0",
 messageSends: ["initialize", "now", "new"],
@@ -529,13 +872,13 @@ selector: "nextRunDo:",
 category: 'running',
 fn: function (aBlock){
 var self=this;
-var $2,$1;
-$2=smalltalk.send(smalltalk.send(self,"_runs",[]),"__eq_eq",[smalltalk.send(self,"_total",[])]);
+return smalltalk.withContext(function($ctx1) { 
+$2=_st(_st(self)._runs()).__eq_eq(_st(self)._total());
 if(! smalltalk.assert($2)){
-$1=smalltalk.send(aBlock,"_value_",[smalltalk.send(smalltalk.send(self,"_runs",[]),"__plus",[(1)])]);
+$1=_st(aBlock)._value_(_st(_st(self)._runs()).__plus((1)));
 };
 return $1;
-},
+}, function($ctx1) {$ctx1.fill(self,"nextRunDo:",{aBlock:aBlock}, smalltalk.TestResult)})},
 args: ["aBlock"],
 source: "nextRunDo: aBlock\x0a\x22Runs aBlock with index of next run\x0aor does nothing if no more runs\x22\x0a^self runs == self total\x0a\x09ifFalse: [ aBlock value: self runs + 1 ]",
 messageSends: ["ifFalse:", "value:", "+", "runs", "==", "total"],
@@ -550,17 +893,17 @@ selector: "runCase:",
 category: 'running',
 fn: function (aTestCase){
 var self=this;
-smalltalk.send((function(){
-return smalltalk.send((function(){
-smalltalk.send(self,"_increaseRuns",[]);
-return smalltalk.send(aTestCase,"_runCase",[]);
-}),"_on_do_",[(smalltalk.TestFailure || TestFailure),(function(ex){
-return smalltalk.send(self,"_addFailure_",[aTestCase]);
-})]);
-}),"_on_do_",[(smalltalk.Error || Error),(function(ex){
-return smalltalk.send(self,"_addError_",[aTestCase]);
-})]);
-return self},
+return smalltalk.withContext(function($ctx1) { 
+return smalltalk.withContext(function($ctx2) {
+return smalltalk.withContext(function($ctx3) {
+return _st(aTestCase)._runCase();
+}, function($ctx3) {$ctx3.fillBlock({},$ctx1)})}))._on_do_((smalltalk.TestFailure || TestFailure),(function(ex){
+return smalltalk.withContext(function($ctx3) {
+}, function($ctx3) {$ctx3.fillBlock({ex:ex},$ctx1)})}));
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}))._on_do_((smalltalk.Error || Error),(function(ex){
+return smalltalk.withContext(function($ctx2) {
+}, function($ctx2) {$ctx2.fillBlock({ex:ex},$ctx1)})}));
+return self}, function($ctx1) {$ctx1.fill(self,"runCase:",{aTestCase:aTestCase}, smalltalk.TestResult)})},
 args: ["aTestCase"],
 source: "runCase: aTestCase\x0a\x09[[\x09self increaseRuns.\x0a    \x09aTestCase runCase]\x0a\x09on: TestFailure do: [:ex | self addFailure: aTestCase]]\x0a\x09on: Error do: [:ex | self addError: aTestCase]\x0a",
 messageSends: ["on:do:", "addError:", "addFailure:", "increaseRuns", "runCase"],
@@ -573,10 +916,12 @@ smalltalk.addMethod(
 smalltalk.method({
 selector: "runs",
 category: 'accessing',
-fn: function () {
-    var self = this;
-    return self['@runs'];
-},
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+$1=self["@runs"];
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"runs",{}, smalltalk.TestResult)})},
 args: [],
 source: "runs\x0a\x09^runs",
 messageSends: [],
@@ -589,22 +934,23 @@ smalltalk.addMethod(
 smalltalk.method({
 selector: "status",
 category: 'accessing',
-fn: function () {
-    var self = this;
-    var $2, $3, $1;
-    $2 = smalltalk.send(smalltalk.send(self, "_errors", []), "_isEmpty", []);
-    if (smalltalk.assert($2)) {
-        $3 = smalltalk.send(smalltalk.send(self, "_failures", []), "_isEmpty", []);
-        if (smalltalk.assert($3)) {
-            $1 = "success";
-        } else {
-            $1 = "failure";
-        }
-    } else {
-        $1 = "error";
-    }
-    return $1;
-},
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+$2=_st(_st(self)._errors())._isEmpty();
+$3=(function(){
+return smalltalk.withContext(function($ctx2) {
+if(smalltalk.assert($4)){
+return "success";
+} else {
+return "failure";
+};
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})});
+$1=_st($2)._ifTrue_ifFalse_($3,(function(){
+return smalltalk.withContext(function($ctx2) {
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"status",{}, smalltalk.TestResult)})},
 args: [],
 source: "status\x0a\x09^self errors isEmpty \x0a\x09\x09ifTrue: [\x0a\x09\x09\x09self failures isEmpty \x0a\x09\x09\x09\x09ifTrue: ['success']\x0a\x09\x09\x09\x09ifFalse: ['failure']]\x0a\x09\x09ifFalse: ['error']",
 messageSends: ["ifTrue:ifFalse:", "isEmpty", "failures", "errors"],
@@ -617,10 +963,12 @@ smalltalk.addMethod(
 smalltalk.method({
 selector: "timestamp",
 category: 'accessing',
-fn: function () {
-    var self = this;
-    return self['@timestamp'];
-},
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+$1=self["@timestamp"];
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"timestamp",{}, smalltalk.TestResult)})},
 args: [],
 source: "timestamp\x0a\x09^timestamp",
 messageSends: [],
@@ -633,10 +981,12 @@ smalltalk.addMethod(
 smalltalk.method({
 selector: "total",
 category: 'accessing',
-fn: function () {
-    var self = this;
-    return self['@total'];
-},
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+$1=self["@total"];
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"total",{}, smalltalk.TestResult)})},
 args: [],
 source: "total\x0a\x09^total",
 messageSends: [],
@@ -649,11 +999,10 @@ smalltalk.addMethod(
 smalltalk.method({
 selector: "total:",
 category: 'accessing',
-fn: function (aNumber) {
-    var self = this;
-    self['@total'] = aNumber;
-    return self;
-},
+fn: function (aNumber){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+return self}, function($ctx1) {$ctx1.fill(self,"total:",{aNumber:aNumber}, smalltalk.TestResult)})},
 args: ["aNumber"],
 source: "total: aNumber\x0a\x09total := aNumber",
 messageSends: [],
@@ -663,7 +1012,7 @@ smalltalk.TestResult);
 
 
 
-smalltalk.addClass('TestSuiteRunner', smalltalk.Object, ['suite', 'result', 'announcer'], 'SUnit');
+smalltalk.addClass('TestSuiteRunner', smalltalk.Object, ['suite', 'result', 'announcer', 'runNextTest'], 'SUnit');
 smalltalk.addMethod(
 "_announcer",
 smalltalk.method({
@@ -671,8 +1020,10 @@ selector: "announcer",
 category: 'accessing',
 fn: function (){
 var self=this;
-return self["@announcer"];
-},
+return smalltalk.withContext(function($ctx1) { 
+$1=self["@announcer"];
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"announcer",{}, smalltalk.TestSuiteRunner)})},
 args: [],
 source: "announcer\x0a\x09^announcer",
 messageSends: [],
@@ -680,6 +1031,26 @@ referencedClasses: []
 }),
 smalltalk.TestSuiteRunner);
 
+smalltalk.addMethod(
+"_contextOf_",
+smalltalk.method({
+selector: "contextOf:",
+category: 'private',
+fn: function (anInteger){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+$1=_st((smalltalk.ReportingTestContext || ReportingTestContext))._testCase_result_finished_(_st(self["@suite"])._at_(anInteger),self["@result"],(function(){
+return smalltalk.withContext(function($ctx2) {
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1)})}));
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"contextOf:",{anInteger:anInteger}, smalltalk.TestSuiteRunner)})},
+args: ["anInteger"],
+source: "contextOf: anInteger\x0a   \x09^ReportingTestContext testCase: (suite at: anInteger) result: result finished: [ self resume ]",
+messageSends: ["testCase:result:finished:", "at:", "resume"],
+referencedClasses: ["ReportingTestContext"]
+}),
+smalltalk.TestSuiteRunner);
+
 smalltalk.addMethod(
 "_initialize",
 smalltalk.method({
@@ -687,13 +1058,23 @@ selector: "initialize",
 category: 'initialization',
 fn: function (){
 var self=this;
-smalltalk.send(self,"_initialize",[],smalltalk.Object);
-self["@announcer"]=smalltalk.send((smalltalk.Announcer || Announcer),"_new",[]);
-self["@result"]=smalltalk.send((smalltalk.TestResult || TestResult),"_new",[]);
-return self},
+return smalltalk.withContext(function($ctx1) { 
+smalltalk.Object.fn.prototype._initialize.apply(_st(self), []);
+self["@announcer"]=_st((smalltalk.Announcer || Announcer))._new();
+self["@result"]=_st((smalltalk.TestResult || TestResult))._new();
+self["@runNextTest"]=(function(){
+var runs;
+return smalltalk.withContext(function($ctx2) {
+runs;
+$1=_st(runs).__lt(_st(self["@result"])._total());
+if(smalltalk.assert($1)){
+return _st(_st(self)._contextOf_(_st(runs).__plus((1))))._start();
+};
+}, function($ctx2) {$ctx2.fillBlock({runs:runs},$ctx1)})});
+return self}, function($ctx1) {$ctx1.fill(self,"initialize",{}, smalltalk.TestSuiteRunner)})},
 args: [],
-source: "initialize\x0a\x09super initialize.\x0a\x09announcer := Announcer new.\x0a    result := TestResult new",
-messageSends: ["initialize", "new"],
+source: "initialize\x0a\x09super initialize.\x0a\x09announcer := Announcer new.\x0a    result := TestResult new.\x0a    runNextTest := [ | runs | runs := result runs. runs < result total ifTrue: [ (self contextOf: runs + 1) start ]].",
+messageSends: ["initialize", "new", "runs", "ifTrue:", "start", "contextOf:", "+", "<", "total"],
 referencedClasses: ["Announcer", "TestResult"]
 }),
 smalltalk.TestSuiteRunner);
@@ -705,8 +1086,10 @@ selector: "result",
 category: 'accessing',
 fn: function (){
 var self=this;
-return self["@result"];
-},
+return smalltalk.withContext(function($ctx1) { 
+$1=self["@result"];
+return $1;
+}, function($ctx1) {$ctx1.fill(self,"result",{}, smalltalk.TestSuiteRunner)})},
 args: [],
 source: "result\x0a\x09^result",
 messageSends: [],
@@ -714,6 +1097,23 @@ referencedClasses: []
 }),
 smalltalk.TestSuiteRunner);
 
+smalltalk.addMethod(
+"_resume",
+smalltalk.method({
+selector: "resume",
+category: 'actions',
+fn: function (){
+var self=this;
+return smalltalk.withContext(function($ctx1) { 
+_st(self["@announcer"])._announce_(_st(_st((smalltalk.ResultAnnouncement || ResultAnnouncement))._new())._result_(self["@result"]));
+return self}, function($ctx1) {$ctx1.fill(self,"resume",{}, smalltalk.TestSuiteRunner)})},
+args: [],
+source: "resume\x0a\x09runNextTest fork.\x0a    announcer announce: (ResultAnnouncement new result: result)",
+messageSends: ["fork", "announce:", "result:", "new"],
+referencedClasses: ["ResultAnnouncement"]
+}),
+smalltalk.TestSuiteRunner);
+
 smalltalk.addMethod(
 "_run",
 smalltalk.method({
@@ -721,25 +1121,13 @@ selector: "run",
 category: 'actions',
 fn: function (){
 var self=this;
-var worker;
-smalltalk.send(self["@result"],"_total_",[smalltalk.send(self["@suite"],"_size",[])]);
-smalltalk.send(self["@announcer"],"_announce_",[smalltalk.send(smalltalk.send((smalltalk.ResultAnnouncement || ResultAnnouncement),"_new",[]),"_result_",[self["@result"]])]);
-worker=(function(){
-return smalltalk.send(self["@result"],"_nextRunDo_",[(function(index){
-return smalltalk.send((function(){
-return smalltalk.send(self["@result"],"_runCase_",[smalltalk.send(self["@suite"],"_at_",[index])]);
-}),"_ensure_",[(function(){
-smalltalk.send(worker,"_fork",[]);
-return smalltalk.send(self["@announcer"],"_announce_",[smalltalk.send(smalltalk.send((smalltalk.ResultAnnouncement || ResultAnnouncement),"_new",[]),"_result_",[self["@result"]])]);
-})]);
-})]);
-});
-smalltalk.send(worker,"_fork",[]);
-return self},
+return smalltalk.withContext(function($ctx1) { 
+_st(self)._resume();
+return self}, function($ctx1) {$ctx1.fill(self,"run",{}, smalltalk.TestSuiteRunner)})},
 args: [],
-source: "run\x0a\x09| worker |\x0a\x09result total: suite size.\x0a    announcer announce: (ResultAnnouncement new result: result).\x0a    worker := [ result nextRunDo: [ :index |\x0a\x09\x09[ result runCase: (suite at: index) ]\x0a\x09\x09ensure: [ worker fork.\x0a        \x09announcer announce: (ResultAnnouncement new result: result) ]]].\x0a\x09worker fork",
-messageSends: ["total:", "size", "announce:", "result:", "new", "nextRunDo:", "ensure:", "fork", "runCase:", "at:"],
-referencedClasses: ["ResultAnnouncement"]
+source: "run\x0a\x09result total: suite size.\x0a\x09self resume",
+messageSends: ["total:", "size", "resume"],
+referencedClasses: []
 }),
 smalltalk.TestSuiteRunner);
 
@@ -750,8 +1138,8 @@ selector: "suite:",
 category: 'accessing',
 fn: function (aCollection){
 var self=this;
-self["@suite"]=aCollection;
-return self},
+return smalltalk.withContext(function($ctx1) { 
+return self}, function($ctx1) {$ctx1.fill(self,"suite:",{aCollection:aCollection}, smalltalk.TestSuiteRunner)})},
 args: ["aCollection"],
 source: "suite: aCollection\x0a\x09suite := aCollection",
 messageSends: [],
@@ -767,8 +1155,8 @@ selector: "new",
 category: 'instance creation',
 fn: function (){
 var self=this;
-smalltalk.send(self,"_shouldNotImplement",[]);
-return self},
+return smalltalk.withContext(function($ctx1) { 
+return self}, function($ctx1) {$ctx1.fill(self,"new",{}, smalltalk.TestSuiteRunner.klass)})},
 args: [],
 source: "new\x0a\x09self shouldNotImplement",
 messageSends: ["shouldNotImplement"],
@@ -783,10 +1171,10 @@ selector: "on:",
 category: 'instance creation',
 fn: function (aCollection){
 var self=this;
-var $1;
-$1=smalltalk.send(smalltalk.send(self,"_new",[],smalltalk.Object.klass),"_suite_",[aCollection]);
+return smalltalk.withContext(function($ctx1) { 
+$1=_st(smalltalk.Object.klass.fn.prototype._new.apply(_st(self), []))._suite_(aCollection);
 return $1;
-},
+}, function($ctx1) {$ctx1.fill(self,"on:",{aCollection:aCollection}, smalltalk.TestSuiteRunner.klass)})},
 args: ["aCollection"],
 source: "on: aCollection\x0a\x09^super new suite: aCollection",
 messageSends: ["suite:", "new"],