|
@@ -3017,6 +3017,22 @@ return false;
|
|
|
}; }),
|
|
|
$globals.TIsInGroup);
|
|
|
|
|
|
+$core.addMethod(
|
|
|
+$core.method({
|
|
|
+selector: "isThenable",
|
|
|
+protocol: "testing",
|
|
|
+args: [],
|
|
|
+source: "isThenable\x0a\x09^ false",
|
|
|
+referencedClasses: [],
|
|
|
+pragmas: [],
|
|
|
+messageSends: []
|
|
|
+}, function ($methodClass){ return function (){
|
|
|
+var self=this,$self=this;
|
|
|
+return false;
|
|
|
+
|
|
|
+}; }),
|
|
|
+$globals.TIsInGroup);
|
|
|
+
|
|
|
|
|
|
$core.addTrait("TSubclassable", "Kernel-Helpers");
|
|
|
$core.addMethod(
|
|
@@ -23754,6 +23770,31 @@ return self;
|
|
|
}; }),
|
|
|
$globals.Promise.a$cls);
|
|
|
|
|
|
+$core.addMethod(
|
|
|
+$core.method({
|
|
|
+selector: "delayMilliseconds:",
|
|
|
+protocol: "instance creation",
|
|
|
+args: ["aNumber"],
|
|
|
+source: "delayMilliseconds: aNumber\x0a\x09^ self new: [ :model | [ model value: nil ] valueWithTimeout: aNumber ]",
|
|
|
+referencedClasses: [],
|
|
|
+pragmas: [],
|
|
|
+messageSends: ["new:", "valueWithTimeout:", "value:"]
|
|
|
+}, function ($methodClass){ return function (aNumber){
|
|
|
+var self=this,$self=this;
|
|
|
+return $core.withContext(function($ctx1) {
|
|
|
+return $self._new_((function(model){
|
|
|
+return $core.withContext(function($ctx2) {
|
|
|
+return $recv((function(){
|
|
|
+return $core.withContext(function($ctx3) {
|
|
|
+return $recv(model)._value_(nil);
|
|
|
+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,2)});
|
|
|
+}))._valueWithTimeout_(aNumber);
|
|
|
+}, function($ctx2) {$ctx2.fillBlock({model:model},$ctx1,1)});
|
|
|
+}));
|
|
|
+}, function($ctx1) {$ctx1.fill(self,"delayMilliseconds:",{aNumber:aNumber})});
|
|
|
+}; }),
|
|
|
+$globals.Promise.a$cls);
|
|
|
+
|
|
|
$core.addMethod(
|
|
|
$core.method({
|
|
|
selector: "forBlock:",
|
|
@@ -23866,6 +23907,22 @@ return self;
|
|
|
}; }),
|
|
|
$globals.TThenable);
|
|
|
|
|
|
+$core.addMethod(
|
|
|
+$core.method({
|
|
|
+selector: "isThenable",
|
|
|
+protocol: "testing",
|
|
|
+args: [],
|
|
|
+source: "isThenable\x0a\x09^ true",
|
|
|
+referencedClasses: [],
|
|
|
+pragmas: [],
|
|
|
+messageSends: []
|
|
|
+}, function ($methodClass){ return function (){
|
|
|
+var self=this,$self=this;
|
|
|
+return true;
|
|
|
+
|
|
|
+}; }),
|
|
|
+$globals.TThenable);
|
|
|
+
|
|
|
$core.addMethod(
|
|
|
$core.method({
|
|
|
selector: "on:do:",
|
|
@@ -24283,6 +24340,23 @@ return $recv(aValuable)._value_($self.jsObject);
|
|
|
}; }),
|
|
|
$globals.JSObjectProxy);
|
|
|
|
|
|
+$core.addMethod(
|
|
|
+$core.method({
|
|
|
+selector: "isThenable",
|
|
|
+protocol: "testing",
|
|
|
+args: [],
|
|
|
+source: "isThenable\x0a\x09^ NativeFunction isNativeFunction: (self at: #then)",
|
|
|
+referencedClasses: ["NativeFunction"],
|
|
|
+pragmas: [],
|
|
|
+messageSends: ["isNativeFunction:", "at:"]
|
|
|
+}, function ($methodClass){ return function (){
|
|
|
+var self=this,$self=this;
|
|
|
+return $core.withContext(function($ctx1) {
|
|
|
+return $recv($globals.NativeFunction)._isNativeFunction_($self._at_("then"));
|
|
|
+}, function($ctx1) {$ctx1.fill(self,"isThenable",{})});
|
|
|
+}; }),
|
|
|
+$globals.JSObjectProxy);
|
|
|
+
|
|
|
$core.addMethod(
|
|
|
$core.method({
|
|
|
selector: "jsObject",
|
|
@@ -24430,14 +24504,14 @@ $core.method({
|
|
|
selector: "then:",
|
|
|
protocol: "promises",
|
|
|
args: ["aBlockOrArray"],
|
|
|
-source: "then: aBlockOrArray\x0a(NativeFunction isNativeFunction: (self at: #then))\x0a\x09ifTrue: [ ^ (TThenable >> #then:) sendTo: jsObject arguments: {aBlockOrArray} ]\x0a\x09ifFalse: [ ^ super then: aBlockOrArray ]",
|
|
|
-referencedClasses: ["NativeFunction", "TThenable"],
|
|
|
+source: "then: aBlockOrArray\x0aself isThenable\x0a\x09ifTrue: [ ^ (TThenable >> #then:) sendTo: jsObject arguments: {aBlockOrArray} ]\x0a\x09ifFalse: [ ^ super then: aBlockOrArray ]",
|
|
|
+referencedClasses: ["TThenable"],
|
|
|
pragmas: [],
|
|
|
-messageSends: ["ifTrue:ifFalse:", "isNativeFunction:", "at:", "sendTo:arguments:", ">>", "then:"]
|
|
|
+messageSends: ["ifTrue:ifFalse:", "isThenable", "sendTo:arguments:", ">>", "then:"]
|
|
|
}, function ($methodClass){ return function (aBlockOrArray){
|
|
|
var self=this,$self=this;
|
|
|
return $core.withContext(function($ctx1) {
|
|
|
-if($core.assert($recv($globals.NativeFunction)._isNativeFunction_($self._at_("then")))){
|
|
|
+if($core.assert($self._isThenable())){
|
|
|
return $recv($recv($globals.TThenable).__gt_gt("then:"))._sendTo_arguments_($self.jsObject,[aBlockOrArray]);
|
|
|
} else {
|
|
|
return [(
|
|
@@ -27056,13 +27130,13 @@ $core.method({
|
|
|
selector: "version",
|
|
|
protocol: "accessing",
|
|
|
args: [],
|
|
|
-source: "version\x0a\x09\x22Answer the version string of Amber\x22\x0a\x09\x0a\x09^ '0.29.2'",
|
|
|
+source: "version\x0a\x09\x22Answer the version string of Amber\x22\x0a\x09\x0a\x09^ '0.29.3'",
|
|
|
referencedClasses: [],
|
|
|
pragmas: [],
|
|
|
messageSends: []
|
|
|
}, function ($methodClass){ return function (){
|
|
|
var self=this,$self=this;
|
|
|
-return "0.29.2";
|
|
|
+return "0.29.3";
|
|
|
|
|
|
}; }),
|
|
|
$globals.SmalltalkImage);
|
|
@@ -54550,15 +54624,15 @@ $core.method({
|
|
|
selector: "debugCase",
|
|
|
protocol: "running",
|
|
|
args: [],
|
|
|
-source: "debugCase\x0a\x09\x22Runs a test case in isolated context, debugging all errors.\x22\x0a\x0a\x09(DebugTestContext testCase: self) start",
|
|
|
-referencedClasses: ["DebugTestContext"],
|
|
|
+source: "debugCase\x0a\x09self deprecatedAPI: 'Use #runCase instead.'.\x0a\x09^ self runCase",
|
|
|
+referencedClasses: [],
|
|
|
pragmas: [],
|
|
|
-messageSends: ["start", "testCase:"]
|
|
|
+messageSends: ["deprecatedAPI:", "runCase"]
|
|
|
}, function ($methodClass){ return function (){
|
|
|
var self=this,$self=this;
|
|
|
return $core.withContext(function($ctx1) {
|
|
|
-$recv($recv($globals.DebugTestContext)._testCase_(self))._start();
|
|
|
-return self;
|
|
|
+$self._deprecatedAPI_("Use #runCase instead.");
|
|
|
+return $self._runCase();
|
|
|
}, function($ctx1) {$ctx1.fill(self,"debugCase",{})});
|
|
|
}; }),
|
|
|
$globals.TestCase);
|
|
@@ -54606,14 +54680,21 @@ $core.method({
|
|
|
selector: "finished",
|
|
|
protocol: "async",
|
|
|
args: [],
|
|
|
-source: "finished\x0a\x09self errorIfNotAsync: '#finished'.\x0a\x09asyncTimeout := nil",
|
|
|
+source: "finished\x0a\x09self errorIfNotAsync: '#finished'.\x0a\x09asyncTimeout ifNotNil: [ asyncTimeout clearTimeout ].\x0a\x09asyncTimeout := nil",
|
|
|
referencedClasses: [],
|
|
|
pragmas: [],
|
|
|
-messageSends: ["errorIfNotAsync:"]
|
|
|
+messageSends: ["errorIfNotAsync:", "ifNotNil:", "clearTimeout"]
|
|
|
}, function ($methodClass){ return function (){
|
|
|
var self=this,$self=this;
|
|
|
return $core.withContext(function($ctx1) {
|
|
|
+var $1;
|
|
|
$self._errorIfNotAsync_("#finished");
|
|
|
+$1=$self.asyncTimeout;
|
|
|
+if($1 == null || $1.a$nil){
|
|
|
+$1;
|
|
|
+} else {
|
|
|
+$recv($self.asyncTimeout)._clearTimeout();
|
|
|
+}
|
|
|
$self.asyncTimeout=nil;
|
|
|
return self;
|
|
|
}, function($ctx1) {$ctx1.fill(self,"finished",{})});
|
|
@@ -54642,7 +54723,7 @@ $core.method({
|
|
|
selector: "performTest",
|
|
|
protocol: "running",
|
|
|
args: [],
|
|
|
-source: "performTest\x0a\x09asyncTimeout := nil.\x0a\x09self perform: self selector",
|
|
|
+source: "performTest\x0a\x09asyncTimeout := nil.\x0a\x09^ self perform: self selector",
|
|
|
referencedClasses: [],
|
|
|
pragmas: [],
|
|
|
messageSends: ["perform:", "selector"]
|
|
@@ -54650,8 +54731,7 @@ messageSends: ["perform:", "selector"]
|
|
|
var self=this,$self=this;
|
|
|
return $core.withContext(function($ctx1) {
|
|
|
$self.asyncTimeout=nil;
|
|
|
-$self._perform_($self._selector());
|
|
|
-return self;
|
|
|
+return $self._perform_($self._selector());
|
|
|
}, function($ctx1) {$ctx1.fill(self,"performTest",{})});
|
|
|
}; }),
|
|
|
$globals.TestCase);
|
|
@@ -55039,45 +55119,81 @@ $core.method({
|
|
|
selector: "execute:",
|
|
|
protocol: "running",
|
|
|
args: ["aBlock"],
|
|
|
-source: "execute: aBlock\x0a\x09| failed |\x0a\x09\x0a\x09testCase context: self.\x0a\x09[\x0a\x09\x09failed := true.\x0a\x09\x09aBlock value.\x0a\x09\x09failed := false\x0a\x09]\x0a\x09\x09ensure: [\x0a\x09\x09\x09testCase context: nil.\x0a\x09\x09\x09\x0a\x09\x09\x09(failed and: [ testCase isAsync ]) ifTrue: [\x0a\x09\x09\x09\x09testCase finished ].\x0a\x09\x09\x09testCase isAsync ifFalse: [\x0a\x09\x09\x09\x09testCase tearDown ] ]",
|
|
|
+source: "execute: aBlock\x0a\x09| failed result |\x0a\x09\x0a\x09testCase context: self.\x0a\x09[\x0a\x09\x09failed := true.\x0a\x09\x09result := aBlock value.\x0a\x09\x09testCase isAsync ifFalse: [\x0a\x09\x09\x09testCase assert: result isThenable not description: testCase asString, ' returned promise without sending #timeout:' ].\x0a\x09\x09failed := false\x0a\x09]\x0a\x09\x09ensure: [\x0a\x09\x09\x09\x22testCase context: nil.\x22\x0a\x09\x09\x09\x0a\x09\x09\x09(failed and: [ testCase isAsync ]) ifTrue: [ testCase finished ].\x0a\x09\x09\x09testCase isAsync\x0a\x09\x09\x09\x09ifFalse: [ testCase tearDown ]\x0a\x09\x09\x09\x09ifTrue: [ result isThenable ifTrue: [\x0a\x09\x09\x09\x09\x09result\x0a\x09\x09\x09\x09\x09\x09then: [ testCase isAsync ifTrue: [ self execute: [ testCase finished ] ] ]\x0a\x09\x09\x09\x09\x09\x09catch: [ :error | testCase isAsync ifTrue: [ self execute: [ error signal ] ] ] ] ] ]",
|
|
|
referencedClasses: [],
|
|
|
pragmas: [],
|
|
|
-messageSends: ["context:", "ensure:", "value", "ifTrue:", "and:", "isAsync", "finished", "ifFalse:", "tearDown"]
|
|
|
+messageSends: ["context:", "ensure:", "value", "ifFalse:", "isAsync", "assert:description:", "not", "isThenable", ",", "asString", "ifTrue:", "and:", "finished", "ifFalse:ifTrue:", "tearDown", "then:catch:", "execute:", "signal"]
|
|
|
}, function ($methodClass){ return function (aBlock){
|
|
|
var self=this,$self=this;
|
|
|
-var failed;
|
|
|
+var failed,result;
|
|
|
return $core.withContext(function($ctx1) {
|
|
|
var $1;
|
|
|
-[$recv($self.testCase)._context_(self)
|
|
|
-,$ctx1.sendIdx["context:"]=1
|
|
|
-][0];
|
|
|
+$recv($self.testCase)._context_(self);
|
|
|
$recv((function(){
|
|
|
return $core.withContext(function($ctx2) {
|
|
|
failed=true;
|
|
|
-$recv(aBlock)._value();
|
|
|
+result=$recv(aBlock)._value();
|
|
|
+if(!$core.assert([$recv($self.testCase)._isAsync()
|
|
|
+,$ctx2.sendIdx["isAsync"]=1
|
|
|
+][0])){
|
|
|
+$recv($self.testCase)._assert_description_($recv([$recv(result)._isThenable()
|
|
|
+,$ctx2.sendIdx["isThenable"]=1
|
|
|
+][0])._not(),$recv($recv($self.testCase)._asString()).__comma(" returned promise without sending #timeout:"));
|
|
|
+}
|
|
|
failed=false;
|
|
|
return failed;
|
|
|
}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
|
|
|
}))._ensure_((function(){
|
|
|
return $core.withContext(function($ctx2) {
|
|
|
-$recv($self.testCase)._context_(nil);
|
|
|
if($core.assert(failed)){
|
|
|
$1=[$recv($self.testCase)._isAsync()
|
|
|
-,$ctx2.sendIdx["isAsync"]=1
|
|
|
+,$ctx2.sendIdx["isAsync"]=2
|
|
|
][0];
|
|
|
} else {
|
|
|
$1=false;
|
|
|
}
|
|
|
if($core.assert($1)){
|
|
|
-$recv($self.testCase)._finished();
|
|
|
+[$recv($self.testCase)._finished()
|
|
|
+,$ctx2.sendIdx["finished"]=1
|
|
|
+][0];
|
|
|
}
|
|
|
-if(!$core.assert($recv($self.testCase)._isAsync())){
|
|
|
+if($core.assert([$recv($self.testCase)._isAsync()
|
|
|
+,$ctx2.sendIdx["isAsync"]=3
|
|
|
+][0])){
|
|
|
+if($core.assert($recv(result)._isThenable())){
|
|
|
+return $recv(result)._then_catch_((function(){
|
|
|
+return $core.withContext(function($ctx3) {
|
|
|
+if($core.assert([$recv($self.testCase)._isAsync()
|
|
|
+,$ctx3.sendIdx["isAsync"]=4
|
|
|
+][0])){
|
|
|
+return [$self._execute_((function(){
|
|
|
+return $core.withContext(function($ctx4) {
|
|
|
+return $recv($self.testCase)._finished();
|
|
|
+}, function($ctx4) {$ctx4.fillBlock({},$ctx3,11)});
|
|
|
+}))
|
|
|
+,$ctx3.sendIdx["execute:"]=1
|
|
|
+][0];
|
|
|
+}
|
|
|
+}, function($ctx3) {$ctx3.fillBlock({},$ctx2,9)});
|
|
|
+}),(function(error){
|
|
|
+return $core.withContext(function($ctx3) {
|
|
|
+if($core.assert($recv($self.testCase)._isAsync())){
|
|
|
+return $self._execute_((function(){
|
|
|
+return $core.withContext(function($ctx4) {
|
|
|
+return $recv(error)._signal();
|
|
|
+}, function($ctx4) {$ctx4.fillBlock({},$ctx3,14)});
|
|
|
+}));
|
|
|
+}
|
|
|
+}, function($ctx3) {$ctx3.fillBlock({error:error},$ctx2,12)});
|
|
|
+}));
|
|
|
+}
|
|
|
+} else {
|
|
|
return $recv($self.testCase)._tearDown();
|
|
|
}
|
|
|
-}, function($ctx2) {$ctx2.fillBlock({},$ctx1,2)});
|
|
|
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,3)});
|
|
|
}));
|
|
|
return self;
|
|
|
-}, function($ctx1) {$ctx1.fill(self,"execute:",{aBlock:aBlock,failed:failed})});
|
|
|
+}, function($ctx1) {$ctx1.fill(self,"execute:",{aBlock:aBlock,failed:failed,result:result})});
|
|
|
}; }),
|
|
|
$globals.TestContext);
|
|
|
|
|
@@ -55143,84 +55259,6 @@ return $recv($1)._yourself();
|
|
|
$globals.TestContext.a$cls);
|
|
|
|
|
|
|
|
|
-$core.addClass("DebugTestContext", $globals.TestContext, "SUnit");
|
|
|
-$core.setSlots($globals.DebugTestContext, ["finished", "result"]);
|
|
|
-$globals.DebugTestContext.comment="I add error debugging to `TestContext`.\x0a\x0aErrors are caught and explicitly passed to `ErrorHandler`.\x0aI am used in `TestCase >> debugCase`.";
|
|
|
-$core.addMethod(
|
|
|
-$core.method({
|
|
|
-selector: "execute:",
|
|
|
-protocol: "running",
|
|
|
-args: ["aBlock"],
|
|
|
-source: "execute: aBlock\x0a\x09self withErrorDebugging: [ super execute: aBlock ]",
|
|
|
-referencedClasses: [],
|
|
|
-pragmas: [],
|
|
|
-messageSends: ["withErrorDebugging:", "execute:"]
|
|
|
-}, function ($methodClass){ return function (aBlock){
|
|
|
-var self=this,$self=this;
|
|
|
-return $core.withContext(function($ctx1) {
|
|
|
-$self._withErrorDebugging_((function(){
|
|
|
-return $core.withContext(function($ctx2) {
|
|
|
-return [(
|
|
|
-$ctx2.supercall = true,
|
|
|
-($methodClass.superclass||$boot.nilAsClass).fn.prototype._execute_.call($self,aBlock))
|
|
|
-,$ctx2.supercall = false
|
|
|
-][0];
|
|
|
-}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
|
|
|
-}));
|
|
|
-return self;
|
|
|
-}, function($ctx1) {$ctx1.fill(self,"execute:",{aBlock:aBlock})});
|
|
|
-}; }),
|
|
|
-$globals.DebugTestContext);
|
|
|
-
|
|
|
-$core.addMethod(
|
|
|
-$core.method({
|
|
|
-selector: "withErrorDebugging:",
|
|
|
-protocol: "private",
|
|
|
-args: ["aBlock"],
|
|
|
-source: "withErrorDebugging: aBlock\x0a\x09aBlock\x0a\x09\x09on: Error\x0a\x09\x09do: [ :ex | ErrorHandler handleError: ex ]",
|
|
|
-referencedClasses: ["Error", "ErrorHandler"],
|
|
|
-pragmas: [],
|
|
|
-messageSends: ["on:do:", "handleError:"]
|
|
|
-}, function ($methodClass){ return function (aBlock){
|
|
|
-var self=this,$self=this;
|
|
|
-return $core.withContext(function($ctx1) {
|
|
|
-$recv(aBlock)._on_do_($globals.Error,(function(ex){
|
|
|
-return $core.withContext(function($ctx2) {
|
|
|
-return $recv($globals.ErrorHandler)._handleError_(ex);
|
|
|
-}, function($ctx2) {$ctx2.fillBlock({ex:ex},$ctx1,1)});
|
|
|
-}));
|
|
|
-return self;
|
|
|
-}, function($ctx1) {$ctx1.fill(self,"withErrorDebugging:",{aBlock:aBlock})});
|
|
|
-}; }),
|
|
|
-$globals.DebugTestContext);
|
|
|
-
|
|
|
-
|
|
|
-$core.addMethod(
|
|
|
-$core.method({
|
|
|
-selector: "testCase:result:finished:",
|
|
|
-protocol: "instance creation",
|
|
|
-args: ["aTestCase", "aTestResult", "aBlock"],
|
|
|
-source: "testCase: aTestCase result: aTestResult finished: aBlock\x0a\x09^ (super testCase: aTestCase)\x0a\x09\x09result: aTestResult;\x0a\x09\x09finished: aBlock;\x0a\x09\x09yourself",
|
|
|
-referencedClasses: [],
|
|
|
-pragmas: [],
|
|
|
-messageSends: ["result:", "testCase:", "finished:", "yourself"]
|
|
|
-}, function ($methodClass){ return function (aTestCase,aTestResult,aBlock){
|
|
|
-var self=this,$self=this;
|
|
|
-return $core.withContext(function($ctx1) {
|
|
|
-var $1;
|
|
|
-$1=[(
|
|
|
-$ctx1.supercall = true,
|
|
|
-($methodClass.superclass||$boot.nilAsClass).fn.prototype._testCase_.call($self,aTestCase))
|
|
|
-,$ctx1.supercall = false
|
|
|
-][0];
|
|
|
-$recv($1)._result_(aTestResult);
|
|
|
-$recv($1)._finished_(aBlock);
|
|
|
-return $recv($1)._yourself();
|
|
|
-}, function($ctx1) {$ctx1.fill(self,"testCase:result:finished:",{aTestCase:aTestCase,aTestResult:aTestResult,aBlock:aBlock})});
|
|
|
-}; }),
|
|
|
-$globals.DebugTestContext.a$cls);
|
|
|
-
|
|
|
-
|
|
|
$core.addClass("ReportingTestContext", $globals.TestContext, "SUnit");
|
|
|
$core.setSlots($globals.ReportingTestContext, ["finished", "result"]);
|
|
|
$globals.ReportingTestContext.comment="I add `TestResult` reporting to `TestContext`.\x0a\x0aErrors are caught and save into a `TestResult`,\x0aWhen test case is finished (which can be later for async tests), a callback block is executed; this is used by a `TestSuiteRunner`.";
|
|
@@ -71808,14 +71846,15 @@ $core.method({
|
|
|
selector: "testAsyncErrorsAndFailures",
|
|
|
protocol: "tests",
|
|
|
args: [],
|
|
|
-source: "testAsyncErrorsAndFailures\x0a\x09| suite runner result assertBlock |\x0a\x09suite := #('fakeError' 'fakeErrorFailingInTearDown' 'fakeFailure' 'testPass') collect: [ :each | self class selector: each ].\x0a\x09runner := TestSuiteRunner on: suite.\x0a\x09self timeout: 200.\x0a\x09result := runner result.\x0a\x09assertBlock := self async: [\x0a\x09\x09self assert: (self selectorSetOf: result errors) equals: #('fakeError') asSet.\x0a\x09\x09self assert: (self selectorSetOf: result failures) equals: #('fakeErrorFailingInTearDown' 'fakeFailure') asSet.\x0a\x09\x09self finished\x0a\x09].\x0a\x09runner announcer on: ResultAnnouncement do: [ :ann |\x0a\x09\x09ann result == result ifTrue: [ result runs = result total ifTrue: assertBlock ] ].\x0a\x09runner run",
|
|
|
+source: "testAsyncErrorsAndFailures\x0a\x09| suite runner result assertBlock |\x0a\x09suite := #(fakeError fakeErrorFailingInTearDown fakeFailure testPass) collect: [ :each | self class selector: each ].\x0a\x09runner := TestSuiteRunner on: suite.\x0a\x09self timeout: 200.\x0a\x09result := runner result.\x0a\x09assertBlock := self async: [\x0a\x09\x09self assert: (self selectorSetOf: result errors) equals: #(fakeError) asSet.\x0a\x09\x09self assert: (self selectorSetOf: result failures) equals: #(fakeErrorFailingInTearDown fakeFailure) asSet.\x0a\x09\x09self finished\x0a\x09].\x0a\x09runner announcer on: ResultAnnouncement do: [ :ann |\x0a\x09\x09(ann result == result and: [ result runs = result total ]) ifTrue: assertBlock ].\x0a\x09runner run",
|
|
|
referencedClasses: ["TestSuiteRunner", "ResultAnnouncement"],
|
|
|
pragmas: [],
|
|
|
-messageSends: ["collect:", "selector:", "class", "on:", "timeout:", "result", "async:", "assert:equals:", "selectorSetOf:", "errors", "asSet", "failures", "finished", "on:do:", "announcer", "ifTrue:", "==", "=", "runs", "total", "run"]
|
|
|
+messageSends: ["collect:", "selector:", "class", "on:", "timeout:", "result", "async:", "assert:equals:", "selectorSetOf:", "errors", "asSet", "failures", "finished", "on:do:", "announcer", "ifTrue:", "and:", "==", "=", "runs", "total", "run"]
|
|
|
}, function ($methodClass){ return function (){
|
|
|
var self=this,$self=this;
|
|
|
var suite,runner,result,assertBlock;
|
|
|
return $core.withContext(function($ctx1) {
|
|
|
+var $1;
|
|
|
suite=["fakeError", "fakeErrorFailingInTearDown", "fakeFailure", "testPass"]._collect_((function(each){
|
|
|
return $core.withContext(function($ctx2) {
|
|
|
return $recv($self._class())._selector_(each);
|
|
@@ -71842,8 +71881,11 @@ return $self._finished();
|
|
|
$recv($recv(runner)._announcer())._on_do_($globals.ResultAnnouncement,(function(ann){
|
|
|
return $core.withContext(function($ctx2) {
|
|
|
if($core.assert($recv($recv(ann)._result()).__eq_eq(result))){
|
|
|
-return $recv($recv($recv(result)._runs()).__eq($recv(result)._total()))._ifTrue_(assertBlock);
|
|
|
+$1=$recv($recv(result)._runs()).__eq($recv(result)._total());
|
|
|
+} else {
|
|
|
+$1=false;
|
|
|
}
|
|
|
+return $recv($1)._ifTrue_(assertBlock);
|
|
|
}, function($ctx2) {$ctx2.fillBlock({ann:ann},$ctx1,3)});
|
|
|
}));
|
|
|
$recv(runner)._run();
|
|
@@ -71977,14 +72019,15 @@ $core.method({
|
|
|
selector: "testTimeouts",
|
|
|
protocol: "tests",
|
|
|
args: [],
|
|
|
-source: "testTimeouts\x0a\x09| suite runner result assertBlock |\x0a\x09suite := #('fakeTimeout' 'fakeMultipleTimeoutFailing' 'fakeMultipleTimeoutPassing' 'testPass') collect: [ :each | self class selector: each ].\x0a\x09runner := TestSuiteRunner on: suite.\x0a\x09self timeout: 200.\x0a\x09result := runner result.\x0a\x09assertBlock := self async: [\x0a\x09\x09self assert: (self selectorSetOf: result errors) equals: Set new.\x0a\x09\x09self assert: (self selectorSetOf: result failures) equals: #('fakeMultipleTimeoutFailing' 'fakeTimeout') asSet.\x0a\x09\x09self finished\x0a\x09].\x0a\x09runner announcer on: ResultAnnouncement do: [ :ann |\x0a\x09\x09ann result == result ifTrue: [ result runs = result total ifTrue: assertBlock ] ].\x0a\x09runner run",
|
|
|
+source: "testTimeouts\x0a\x09| suite runner result assertBlock |\x0a\x09suite := #(fakeTimeout fakeMultipleTimeoutFailing fakeMultipleTimeoutPassing testPass) collect: [ :each | self class selector: each ].\x0a\x09runner := TestSuiteRunner on: suite.\x0a\x09self timeout: 200.\x0a\x09result := runner result.\x0a\x09assertBlock := self async: [\x0a\x09\x09self assert: (self selectorSetOf: result errors) equals: Set new.\x0a\x09\x09self assert: (self selectorSetOf: result failures) equals: #(fakeMultipleTimeoutFailing fakeTimeout) asSet.\x0a\x09\x09self finished\x0a\x09].\x0a\x09runner announcer on: ResultAnnouncement do: [ :ann |\x0a\x09\x09(ann result == result and: [ result runs = result total ]) ifTrue: assertBlock ].\x0a\x09runner run",
|
|
|
referencedClasses: ["TestSuiteRunner", "Set", "ResultAnnouncement"],
|
|
|
pragmas: [],
|
|
|
-messageSends: ["collect:", "selector:", "class", "on:", "timeout:", "result", "async:", "assert:equals:", "selectorSetOf:", "errors", "new", "failures", "asSet", "finished", "on:do:", "announcer", "ifTrue:", "==", "=", "runs", "total", "run"]
|
|
|
+messageSends: ["collect:", "selector:", "class", "on:", "timeout:", "result", "async:", "assert:equals:", "selectorSetOf:", "errors", "new", "failures", "asSet", "finished", "on:do:", "announcer", "ifTrue:", "and:", "==", "=", "runs", "total", "run"]
|
|
|
}, function ($methodClass){ return function (){
|
|
|
var self=this,$self=this;
|
|
|
var suite,runner,result,assertBlock;
|
|
|
return $core.withContext(function($ctx1) {
|
|
|
+var $1;
|
|
|
suite=["fakeTimeout", "fakeMultipleTimeoutFailing", "fakeMultipleTimeoutPassing", "testPass"]._collect_((function(each){
|
|
|
return $core.withContext(function($ctx2) {
|
|
|
return $recv($self._class())._selector_(each);
|
|
@@ -72009,8 +72052,11 @@ return $self._finished();
|
|
|
$recv($recv(runner)._announcer())._on_do_($globals.ResultAnnouncement,(function(ann){
|
|
|
return $core.withContext(function($ctx2) {
|
|
|
if($core.assert($recv($recv(ann)._result()).__eq_eq(result))){
|
|
|
-return $recv($recv($recv(result)._runs()).__eq($recv(result)._total()))._ifTrue_(assertBlock);
|
|
|
+$1=$recv($recv(result)._runs()).__eq($recv(result)._total());
|
|
|
+} else {
|
|
|
+$1=false;
|
|
|
}
|
|
|
+return $recv($1)._ifTrue_(assertBlock);
|
|
|
}, function($ctx2) {$ctx2.fillBlock({ann:ann},$ctx1,3)});
|
|
|
}));
|
|
|
$recv(runner)._run();
|
|
@@ -72067,6 +72113,410 @@ return self;
|
|
|
$globals.SUnitAsyncTest);
|
|
|
|
|
|
|
|
|
+
|
|
|
+$core.addClass("SUnitPromiseTest", $globals.TestCase, "SUnit-Tests");
|
|
|
+$core.setSlots($globals.SUnitPromiseTest, ["flag"]);
|
|
|
+$core.addMethod(
|
|
|
+$core.method({
|
|
|
+selector: "fakeError",
|
|
|
+protocol: "helpers",
|
|
|
+args: [],
|
|
|
+source: "fakeError\x0a\x09flag := 'bad'.\x0a\x09self timeout: 30.\x0a\x09flag := Promise delayMilliseconds: 20.\x0a\x09^ flag then: [ flag := 'ok'. self error: 'Intentional' ]",
|
|
|
+referencedClasses: ["Promise"],
|
|
|
+pragmas: [],
|
|
|
+messageSends: ["timeout:", "delayMilliseconds:", "then:", "error:"]
|
|
|
+}, function ($methodClass){ return function (){
|
|
|
+var self=this,$self=this;
|
|
|
+return $core.withContext(function($ctx1) {
|
|
|
+$self.flag="bad";
|
|
|
+$self._timeout_((30));
|
|
|
+$self.flag=$recv($globals.Promise)._delayMilliseconds_((20));
|
|
|
+return $recv($self.flag)._then_((function(){
|
|
|
+return $core.withContext(function($ctx2) {
|
|
|
+$self.flag="ok";
|
|
|
+return $self._error_("Intentional");
|
|
|
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
|
|
|
+}));
|
|
|
+}, function($ctx1) {$ctx1.fill(self,"fakeError",{})});
|
|
|
+}; }),
|
|
|
+$globals.SUnitPromiseTest);
|
|
|
+
|
|
|
+$core.addMethod(
|
|
|
+$core.method({
|
|
|
+selector: "fakeErrorFailingInTearDown",
|
|
|
+protocol: "helpers",
|
|
|
+args: [],
|
|
|
+source: "fakeErrorFailingInTearDown\x0a\x09flag := 'bad'.\x0a\x09self timeout: 30.\x0a\x09flag := Promise delayMilliseconds: 20.\x0a\x09^ flag then: [ self error: 'Intentional' ]",
|
|
|
+referencedClasses: ["Promise"],
|
|
|
+pragmas: [],
|
|
|
+messageSends: ["timeout:", "delayMilliseconds:", "then:", "error:"]
|
|
|
+}, function ($methodClass){ return function (){
|
|
|
+var self=this,$self=this;
|
|
|
+return $core.withContext(function($ctx1) {
|
|
|
+$self.flag="bad";
|
|
|
+$self._timeout_((30));
|
|
|
+$self.flag=$recv($globals.Promise)._delayMilliseconds_((20));
|
|
|
+return $recv($self.flag)._then_((function(){
|
|
|
+return $core.withContext(function($ctx2) {
|
|
|
+return $self._error_("Intentional");
|
|
|
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
|
|
|
+}));
|
|
|
+}, function($ctx1) {$ctx1.fill(self,"fakeErrorFailingInTearDown",{})});
|
|
|
+}; }),
|
|
|
+$globals.SUnitPromiseTest);
|
|
|
+
|
|
|
+$core.addMethod(
|
|
|
+$core.method({
|
|
|
+selector: "fakeFailure",
|
|
|
+protocol: "helpers",
|
|
|
+args: [],
|
|
|
+source: "fakeFailure\x0a\x09flag := 'bad'.\x0a\x09self timeout: 30.\x0a\x09flag := Promise delayMilliseconds: 20.\x0a\x09^ flag then: [ flag := 'ok'. self assert: false ]",
|
|
|
+referencedClasses: ["Promise"],
|
|
|
+pragmas: [],
|
|
|
+messageSends: ["timeout:", "delayMilliseconds:", "then:", "assert:"]
|
|
|
+}, function ($methodClass){ return function (){
|
|
|
+var self=this,$self=this;
|
|
|
+return $core.withContext(function($ctx1) {
|
|
|
+$self.flag="bad";
|
|
|
+$self._timeout_((30));
|
|
|
+$self.flag=$recv($globals.Promise)._delayMilliseconds_((20));
|
|
|
+return $recv($self.flag)._then_((function(){
|
|
|
+return $core.withContext(function($ctx2) {
|
|
|
+$self.flag="ok";
|
|
|
+return $self._assert_(false);
|
|
|
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
|
|
|
+}));
|
|
|
+}, function($ctx1) {$ctx1.fill(self,"fakeFailure",{})});
|
|
|
+}; }),
|
|
|
+$globals.SUnitPromiseTest);
|
|
|
+
|
|
|
+$core.addMethod(
|
|
|
+$core.method({
|
|
|
+selector: "fakeMultipleTimeoutFailing",
|
|
|
+protocol: "helpers",
|
|
|
+args: [],
|
|
|
+source: "fakeMultipleTimeoutFailing\x0a\x09self timeout: 100.\x0a\x09^ (Promise delayMilliseconds: 20) then: [ self timeout: 20. Promise delayMilliseconds: 30 ]",
|
|
|
+referencedClasses: ["Promise"],
|
|
|
+pragmas: [],
|
|
|
+messageSends: ["timeout:", "then:", "delayMilliseconds:"]
|
|
|
+}, function ($methodClass){ return function (){
|
|
|
+var self=this,$self=this;
|
|
|
+return $core.withContext(function($ctx1) {
|
|
|
+[$self._timeout_((100))
|
|
|
+,$ctx1.sendIdx["timeout:"]=1
|
|
|
+][0];
|
|
|
+return $recv([$recv($globals.Promise)._delayMilliseconds_((20))
|
|
|
+,$ctx1.sendIdx["delayMilliseconds:"]=1
|
|
|
+][0])._then_((function(){
|
|
|
+return $core.withContext(function($ctx2) {
|
|
|
+$self._timeout_((20));
|
|
|
+return $recv($globals.Promise)._delayMilliseconds_((30));
|
|
|
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
|
|
|
+}));
|
|
|
+}, function($ctx1) {$ctx1.fill(self,"fakeMultipleTimeoutFailing",{})});
|
|
|
+}; }),
|
|
|
+$globals.SUnitPromiseTest);
|
|
|
+
|
|
|
+$core.addMethod(
|
|
|
+$core.method({
|
|
|
+selector: "fakeMultipleTimeoutPassing",
|
|
|
+protocol: "helpers",
|
|
|
+args: [],
|
|
|
+source: "fakeMultipleTimeoutPassing\x0a\x09self timeout: 20.\x0a\x09^ (Promise delayMilliseconds: 10) then: [ self timeout: 40. Promise delayMilliseconds: 20 ]",
|
|
|
+referencedClasses: ["Promise"],
|
|
|
+pragmas: [],
|
|
|
+messageSends: ["timeout:", "then:", "delayMilliseconds:"]
|
|
|
+}, function ($methodClass){ return function (){
|
|
|
+var self=this,$self=this;
|
|
|
+return $core.withContext(function($ctx1) {
|
|
|
+[$self._timeout_((20))
|
|
|
+,$ctx1.sendIdx["timeout:"]=1
|
|
|
+][0];
|
|
|
+return $recv([$recv($globals.Promise)._delayMilliseconds_((10))
|
|
|
+,$ctx1.sendIdx["delayMilliseconds:"]=1
|
|
|
+][0])._then_((function(){
|
|
|
+return $core.withContext(function($ctx2) {
|
|
|
+$self._timeout_((40));
|
|
|
+return $recv($globals.Promise)._delayMilliseconds_((20));
|
|
|
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
|
|
|
+}));
|
|
|
+}, function($ctx1) {$ctx1.fill(self,"fakeMultipleTimeoutPassing",{})});
|
|
|
+}; }),
|
|
|
+$globals.SUnitPromiseTest);
|
|
|
+
|
|
|
+$core.addMethod(
|
|
|
+$core.method({
|
|
|
+selector: "fakePromiseWithoutTimeout",
|
|
|
+protocol: "helpers",
|
|
|
+args: [],
|
|
|
+source: "fakePromiseWithoutTimeout\x0a\x09^ Promise delayMilliseconds: 10",
|
|
|
+referencedClasses: ["Promise"],
|
|
|
+pragmas: [],
|
|
|
+messageSends: ["delayMilliseconds:"]
|
|
|
+}, function ($methodClass){ return function (){
|
|
|
+var self=this,$self=this;
|
|
|
+return $core.withContext(function($ctx1) {
|
|
|
+return $recv($globals.Promise)._delayMilliseconds_((10));
|
|
|
+}, function($ctx1) {$ctx1.fill(self,"fakePromiseWithoutTimeout",{})});
|
|
|
+}; }),
|
|
|
+$globals.SUnitPromiseTest);
|
|
|
+
|
|
|
+$core.addMethod(
|
|
|
+$core.method({
|
|
|
+selector: "fakeTimeout",
|
|
|
+protocol: "helpers",
|
|
|
+args: [],
|
|
|
+source: "fakeTimeout\x0a\x09self timeout: 10.\x0a\x09^ Promise delayMilliseconds: 20",
|
|
|
+referencedClasses: ["Promise"],
|
|
|
+pragmas: [],
|
|
|
+messageSends: ["timeout:", "delayMilliseconds:"]
|
|
|
+}, function ($methodClass){ return function (){
|
|
|
+var self=this,$self=this;
|
|
|
+return $core.withContext(function($ctx1) {
|
|
|
+$self._timeout_((10));
|
|
|
+return $recv($globals.Promise)._delayMilliseconds_((20));
|
|
|
+}, function($ctx1) {$ctx1.fill(self,"fakeTimeout",{})});
|
|
|
+}; }),
|
|
|
+$globals.SUnitPromiseTest);
|
|
|
+
|
|
|
+$core.addMethod(
|
|
|
+$core.method({
|
|
|
+selector: "fakeTimeoutSendOnly",
|
|
|
+protocol: "helpers",
|
|
|
+args: [],
|
|
|
+source: "fakeTimeoutSendOnly\x0a\x09self timeout: 10",
|
|
|
+referencedClasses: [],
|
|
|
+pragmas: [],
|
|
|
+messageSends: ["timeout:"]
|
|
|
+}, function ($methodClass){ return function (){
|
|
|
+var self=this,$self=this;
|
|
|
+return $core.withContext(function($ctx1) {
|
|
|
+$self._timeout_((10));
|
|
|
+return self;
|
|
|
+}, function($ctx1) {$ctx1.fill(self,"fakeTimeoutSendOnly",{})});
|
|
|
+}; }),
|
|
|
+$globals.SUnitPromiseTest);
|
|
|
+
|
|
|
+$core.addMethod(
|
|
|
+$core.method({
|
|
|
+selector: "selectorSetOf:",
|
|
|
+protocol: "private",
|
|
|
+args: ["aCollection"],
|
|
|
+source: "selectorSetOf: aCollection\x0a\x09^ (aCollection collect: [ :each | each selector ]) asSet",
|
|
|
+referencedClasses: [],
|
|
|
+pragmas: [],
|
|
|
+messageSends: ["asSet", "collect:", "selector"]
|
|
|
+}, function ($methodClass){ return function (aCollection){
|
|
|
+var self=this,$self=this;
|
|
|
+return $core.withContext(function($ctx1) {
|
|
|
+return $recv($recv(aCollection)._collect_((function(each){
|
|
|
+return $core.withContext(function($ctx2) {
|
|
|
+return $recv(each)._selector();
|
|
|
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)});
|
|
|
+})))._asSet();
|
|
|
+}, function($ctx1) {$ctx1.fill(self,"selectorSetOf:",{aCollection:aCollection})});
|
|
|
+}; }),
|
|
|
+$globals.SUnitPromiseTest);
|
|
|
+
|
|
|
+$core.addMethod(
|
|
|
+$core.method({
|
|
|
+selector: "setUp",
|
|
|
+protocol: "running",
|
|
|
+args: [],
|
|
|
+source: "setUp\x0a\x09flag := 'ok'",
|
|
|
+referencedClasses: [],
|
|
|
+pragmas: [],
|
|
|
+messageSends: []
|
|
|
+}, function ($methodClass){ return function (){
|
|
|
+var self=this,$self=this;
|
|
|
+$self.flag="ok";
|
|
|
+return self;
|
|
|
+
|
|
|
+}; }),
|
|
|
+$globals.SUnitPromiseTest);
|
|
|
+
|
|
|
+$core.addMethod(
|
|
|
+$core.method({
|
|
|
+selector: "tearDown",
|
|
|
+protocol: "running",
|
|
|
+args: [],
|
|
|
+source: "tearDown\x0a\x09self assert: 'ok' equals: flag",
|
|
|
+referencedClasses: [],
|
|
|
+pragmas: [],
|
|
|
+messageSends: ["assert:equals:"]
|
|
|
+}, function ($methodClass){ return function (){
|
|
|
+var self=this,$self=this;
|
|
|
+return $core.withContext(function($ctx1) {
|
|
|
+$self._assert_equals_("ok",$self.flag);
|
|
|
+return self;
|
|
|
+}, function($ctx1) {$ctx1.fill(self,"tearDown",{})});
|
|
|
+}; }),
|
|
|
+$globals.SUnitPromiseTest);
|
|
|
+
|
|
|
+$core.addMethod(
|
|
|
+$core.method({
|
|
|
+selector: "testIsAsyncReturnsCorrectValues",
|
|
|
+protocol: "tests",
|
|
|
+args: [],
|
|
|
+source: "testIsAsyncReturnsCorrectValues\x0a\x09self deny: self isAsync.\x0a\x09self timeout: 0.\x0a\x09self assert: self isAsync.\x0a\x09\x22self finished.\x0a\x09self deny: self isAsync\x22\x0a\x09^ Promise new",
|
|
|
+referencedClasses: ["Promise"],
|
|
|
+pragmas: [],
|
|
|
+messageSends: ["deny:", "isAsync", "timeout:", "assert:", "new"]
|
|
|
+}, function ($methodClass){ return function (){
|
|
|
+var self=this,$self=this;
|
|
|
+return $core.withContext(function($ctx1) {
|
|
|
+$self._deny_([$self._isAsync()
|
|
|
+,$ctx1.sendIdx["isAsync"]=1
|
|
|
+][0]);
|
|
|
+$self._timeout_((0));
|
|
|
+$self._assert_($self._isAsync());
|
|
|
+return $recv($globals.Promise)._new();
|
|
|
+}, function($ctx1) {$ctx1.fill(self,"testIsAsyncReturnsCorrectValues",{})});
|
|
|
+}; }),
|
|
|
+$globals.SUnitPromiseTest);
|
|
|
+
|
|
|
+$core.addMethod(
|
|
|
+$core.method({
|
|
|
+selector: "testPass",
|
|
|
+protocol: "tests",
|
|
|
+args: [],
|
|
|
+source: "testPass\x0a\x09flag := 'bad'.\x0a\x09self timeout: 10.\x0a\x09flag := Promise delayMilliseconds: 5.\x0a\x09^ flag then: [ self assert: true. flag := 'ok' ]",
|
|
|
+referencedClasses: ["Promise"],
|
|
|
+pragmas: [],
|
|
|
+messageSends: ["timeout:", "delayMilliseconds:", "then:", "assert:"]
|
|
|
+}, function ($methodClass){ return function (){
|
|
|
+var self=this,$self=this;
|
|
|
+return $core.withContext(function($ctx1) {
|
|
|
+$self.flag="bad";
|
|
|
+$self._timeout_((10));
|
|
|
+$self.flag=$recv($globals.Promise)._delayMilliseconds_((5));
|
|
|
+return $recv($self.flag)._then_((function(){
|
|
|
+return $core.withContext(function($ctx2) {
|
|
|
+$self._assert_(true);
|
|
|
+$self.flag="ok";
|
|
|
+return $self.flag;
|
|
|
+}, function($ctx2) {$ctx2.fillBlock({},$ctx1,1)});
|
|
|
+}));
|
|
|
+}, function($ctx1) {$ctx1.fill(self,"testPass",{})});
|
|
|
+}; }),
|
|
|
+$globals.SUnitPromiseTest);
|
|
|
+
|
|
|
+$core.addMethod(
|
|
|
+$core.method({
|
|
|
+selector: "testPromiseErrorsAndFailures",
|
|
|
+protocol: "tests",
|
|
|
+args: [],
|
|
|
+source: "testPromiseErrorsAndFailures\x0a\x09| suite runner result |\x0a\x09suite := #(fakeError fakeErrorFailingInTearDown fakeFailure testPass) collect: [ :each | self class selector: each ].\x0a\x09runner := TestSuiteRunner on: suite.\x0a\x09self timeout: 200.\x0a\x09result := runner result.\x0a\x09^ Promise new: [ :model |\x0a\x09\x09runner announcer on: ResultAnnouncement do: [ :ann |\x0a\x09\x09\x09(ann result == result and: [ result runs = result total ]) ifTrue: [\x0a\x09\x09\x09\x09self assert: (self selectorSetOf: result errors) equals: #(fakeError) asSet.\x0a\x09\x09\x09\x09self assert: (self selectorSetOf: result failures) equals: #(fakeErrorFailingInTearDown fakeFailure) asSet.\x0a\x09\x09\x09\x09model value: nil ] ].\x0a\x09\x09runner run ]",
|
|
|
+referencedClasses: ["TestSuiteRunner", "Promise", "ResultAnnouncement"],
|
|
|
+pragmas: [],
|
|
|
+messageSends: ["collect:", "selector:", "class", "on:", "timeout:", "result", "new:", "on:do:", "announcer", "ifTrue:", "and:", "==", "=", "runs", "total", "assert:equals:", "selectorSetOf:", "errors", "asSet", "failures", "value:", "run"]
|
|
|
+}, function ($methodClass){ return function (){
|
|
|
+var self=this,$self=this;
|
|
|
+var suite,runner,result;
|
|
|
+return $core.withContext(function($ctx1) {
|
|
|
+var $1;
|
|
|
+suite=["fakeError", "fakeErrorFailingInTearDown", "fakeFailure", "testPass"]._collect_((function(each){
|
|
|
+return $core.withContext(function($ctx2) {
|
|
|
+return $recv($self._class())._selector_(each);
|
|
|
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)});
|
|
|
+}));
|
|
|
+runner=$recv($globals.TestSuiteRunner)._on_(suite);
|
|
|
+$self._timeout_((200));
|
|
|
+result=[$recv(runner)._result()
|
|
|
+,$ctx1.sendIdx["result"]=1
|
|
|
+][0];
|
|
|
+return $recv($globals.Promise)._new_((function(model){
|
|
|
+return $core.withContext(function($ctx2) {
|
|
|
+$recv($recv(runner)._announcer())._on_do_($globals.ResultAnnouncement,(function(ann){
|
|
|
+return $core.withContext(function($ctx3) {
|
|
|
+if($core.assert($recv($recv(ann)._result()).__eq_eq(result))){
|
|
|
+$1=$recv($recv(result)._runs()).__eq($recv(result)._total());
|
|
|
+} else {
|
|
|
+$1=false;
|
|
|
+}
|
|
|
+if($core.assert($1)){
|
|
|
+[$self._assert_equals_([$self._selectorSetOf_($recv(result)._errors())
|
|
|
+,$ctx3.sendIdx["selectorSetOf:"]=1
|
|
|
+][0],[["fakeError"]._asSet()
|
|
|
+,$ctx3.sendIdx["asSet"]=1
|
|
|
+][0])
|
|
|
+,$ctx3.sendIdx["assert:equals:"]=1
|
|
|
+][0];
|
|
|
+$self._assert_equals_($self._selectorSetOf_($recv(result)._failures()),["fakeErrorFailingInTearDown", "fakeFailure"]._asSet());
|
|
|
+return $recv(model)._value_(nil);
|
|
|
+}
|
|
|
+}, function($ctx3) {$ctx3.fillBlock({ann:ann},$ctx2,3)});
|
|
|
+}));
|
|
|
+return $recv(runner)._run();
|
|
|
+}, function($ctx2) {$ctx2.fillBlock({model:model},$ctx1,2)});
|
|
|
+}));
|
|
|
+}, function($ctx1) {$ctx1.fill(self,"testPromiseErrorsAndFailures",{suite:suite,runner:runner,result:result})});
|
|
|
+}; }),
|
|
|
+$globals.SUnitPromiseTest);
|
|
|
+
|
|
|
+$core.addMethod(
|
|
|
+$core.method({
|
|
|
+selector: "testTimeouts",
|
|
|
+protocol: "tests",
|
|
|
+args: [],
|
|
|
+source: "testTimeouts\x0a\x09| suite runner result |\x0a\x09suite := #(fakeTimeout fakeMultipleTimeoutFailing fakeMultipleTimeoutPassing fakeTimeoutSendOnly fakePromiseWithoutTimeout testPass) collect: [ :each | self class selector: each ].\x0a\x09runner := TestSuiteRunner on: suite.\x0a\x09self timeout: 200.\x0a\x09result := runner result.\x0a\x09^ Promise new: [ :model |\x0a\x09\x09runner announcer on: ResultAnnouncement do: [ :ann |\x0a\x09\x09\x09console log: ann; log: ann result runs.\x0a\x09\x09\x09(ann result == result and: [ result runs = result total ]) ifTrue: [\x0a\x09\x09\x09\x09self assert: (self selectorSetOf: result errors) equals: #() asSet.\x0a\x09\x09\x09\x09self assert: (self selectorSetOf: result failures) equals: #(fakeMultipleTimeoutFailing fakeTimeout fakeTimeoutSendOnly fakePromiseWithoutTimeout) asSet.\x0a\x09\x09\x09\x09model value: nil ] ].\x0a\x09\x09runner run ]",
|
|
|
+referencedClasses: ["TestSuiteRunner", "Promise", "ResultAnnouncement"],
|
|
|
+pragmas: [],
|
|
|
+messageSends: ["collect:", "selector:", "class", "on:", "timeout:", "result", "new:", "on:do:", "announcer", "log:", "runs", "ifTrue:", "and:", "==", "=", "total", "assert:equals:", "selectorSetOf:", "errors", "asSet", "failures", "value:", "run"]
|
|
|
+}, function ($methodClass){ return function (){
|
|
|
+var self=this,$self=this;
|
|
|
+var suite,runner,result;
|
|
|
+return $core.withContext(function($ctx1) {
|
|
|
+var $1,$2;
|
|
|
+suite=["fakeTimeout", "fakeMultipleTimeoutFailing", "fakeMultipleTimeoutPassing", "fakeTimeoutSendOnly", "fakePromiseWithoutTimeout", "testPass"]._collect_((function(each){
|
|
|
+return $core.withContext(function($ctx2) {
|
|
|
+return $recv($self._class())._selector_(each);
|
|
|
+}, function($ctx2) {$ctx2.fillBlock({each:each},$ctx1,1)});
|
|
|
+}));
|
|
|
+runner=$recv($globals.TestSuiteRunner)._on_(suite);
|
|
|
+$self._timeout_((200));
|
|
|
+result=[$recv(runner)._result()
|
|
|
+,$ctx1.sendIdx["result"]=1
|
|
|
+][0];
|
|
|
+return $recv($globals.Promise)._new_((function(model){
|
|
|
+return $core.withContext(function($ctx2) {
|
|
|
+$recv($recv(runner)._announcer())._on_do_($globals.ResultAnnouncement,(function(ann){
|
|
|
+return $core.withContext(function($ctx3) {
|
|
|
+$1=console;
|
|
|
+[$recv($1)._log_(ann)
|
|
|
+,$ctx3.sendIdx["log:"]=1
|
|
|
+][0];
|
|
|
+$recv($1)._log_([$recv([$recv(ann)._result()
|
|
|
+,$ctx3.sendIdx["result"]=2
|
|
|
+][0])._runs()
|
|
|
+,$ctx3.sendIdx["runs"]=1
|
|
|
+][0]);
|
|
|
+if($core.assert($recv($recv(ann)._result()).__eq_eq(result))){
|
|
|
+$2=$recv($recv(result)._runs()).__eq($recv(result)._total());
|
|
|
+} else {
|
|
|
+$2=false;
|
|
|
+}
|
|
|
+if($core.assert($2)){
|
|
|
+[$self._assert_equals_([$self._selectorSetOf_($recv(result)._errors())
|
|
|
+,$ctx3.sendIdx["selectorSetOf:"]=1
|
|
|
+][0],[[]._asSet()
|
|
|
+,$ctx3.sendIdx["asSet"]=1
|
|
|
+][0])
|
|
|
+,$ctx3.sendIdx["assert:equals:"]=1
|
|
|
+][0];
|
|
|
+$self._assert_equals_($self._selectorSetOf_($recv(result)._failures()),["fakeMultipleTimeoutFailing", "fakeTimeout", "fakeTimeoutSendOnly", "fakePromiseWithoutTimeout"]._asSet());
|
|
|
+return $recv(model)._value_(nil);
|
|
|
+}
|
|
|
+}, function($ctx3) {$ctx3.fillBlock({ann:ann},$ctx2,3)});
|
|
|
+}));
|
|
|
+return $recv(runner)._run();
|
|
|
+}, function($ctx2) {$ctx2.fillBlock({model:model},$ctx1,2)});
|
|
|
+}));
|
|
|
+}, function($ctx1) {$ctx1.fill(self,"testTimeouts",{suite:suite,runner:runner,result:result})});
|
|
|
+}; }),
|
|
|
+$globals.SUnitPromiseTest);
|
|
|
+
|
|
|
+
|
|
|
});
|
|
|
|
|
|
define('amber/devel',[
|
|
@@ -72164,6 +72614,43 @@ return global;
|
|
|
}; }),
|
|
|
$globals.NodePlatform);
|
|
|
|
|
|
+$core.addMethod(
|
|
|
+$core.method({
|
|
|
+selector: "initialize",
|
|
|
+protocol: "initialization",
|
|
|
+args: [],
|
|
|
+source: "initialize\x0a\x09process\x0a\x09\x09on: 'uncaughtException'\x0a\x09\x09do: [ :err | ErrorHandler handleError: err. process exit: 1 ];\x0a\x09\x09on: 'unhandledRejection'\x0a\x09\x09do: [ :err | ErrorHandler handleError: err. process exit: 2 ]",
|
|
|
+referencedClasses: ["ErrorHandler"],
|
|
|
+pragmas: [],
|
|
|
+messageSends: ["on:do:", "handleError:", "exit:"]
|
|
|
+}, function ($methodClass){ return function (){
|
|
|
+var self=this,$self=this;
|
|
|
+return $core.withContext(function($ctx1) {
|
|
|
+var $1;
|
|
|
+$1=process;
|
|
|
+[$recv($1)._on_do_("uncaughtException",(function(err){
|
|
|
+return $core.withContext(function($ctx2) {
|
|
|
+[$recv($globals.ErrorHandler)._handleError_(err)
|
|
|
+,$ctx2.sendIdx["handleError:"]=1
|
|
|
+][0];
|
|
|
+return [$recv(process)._exit_((1))
|
|
|
+,$ctx2.sendIdx["exit:"]=1
|
|
|
+][0];
|
|
|
+}, function($ctx2) {$ctx2.fillBlock({err:err},$ctx1,1)});
|
|
|
+}))
|
|
|
+,$ctx1.sendIdx["on:do:"]=1
|
|
|
+][0];
|
|
|
+$recv($1)._on_do_("unhandledRejection",(function(err){
|
|
|
+return $core.withContext(function($ctx2) {
|
|
|
+$recv($globals.ErrorHandler)._handleError_(err);
|
|
|
+return $recv(process)._exit_((2));
|
|
|
+}, function($ctx2) {$ctx2.fillBlock({err:err},$ctx1,2)});
|
|
|
+}));
|
|
|
+return self;
|
|
|
+}, function($ctx1) {$ctx1.fill(self,"initialize",{})});
|
|
|
+}; }),
|
|
|
+$globals.NodePlatform);
|
|
|
+
|
|
|
$core.addMethod(
|
|
|
$core.method({
|
|
|
selector: "newXhr",
|