746 lines
25 KiB
JavaScript
746 lines
25 KiB
JavaScript
|
(function (root, factory) {
|
||
|
|
if (typeof define === 'function' && define.amd)
|
||
|
|
define(['exports', 'kotlin'], factory);
|
||
|
|
else if (typeof exports === 'object')
|
||
|
|
factory(module.exports, require('kotlin'));
|
||
|
|
else {
|
||
|
|
if (typeof kotlin === 'undefined') {
|
||
|
|
throw new Error("Error loading module 'kotlin-test'. Its dependency 'kotlin' was not found. Please, check whether 'kotlin' is loaded prior to 'kotlin-test'.");
|
||
|
|
}
|
||
|
|
root['kotlin-test'] = factory(typeof this['kotlin-test'] === 'undefined' ? {} : this['kotlin-test'], kotlin);
|
||
|
|
}
|
||
|
|
}(this, function (_, Kotlin) {
|
||
|
|
'use strict';
|
||
|
|
var $$importsForInline$$ = _.$$importsForInline$$ || (_.$$importsForInline$$ = {});
|
||
|
|
var ensureNotNull = Kotlin.ensureNotNull;
|
||
|
|
var defineInlineFunction = Kotlin.defineInlineFunction;
|
||
|
|
var wrapFunction = Kotlin.wrapFunction;
|
||
|
|
var toString = Kotlin.toString;
|
||
|
|
var equals = Kotlin.equals;
|
||
|
|
var Kind_INTERFACE = Kotlin.Kind.INTERFACE;
|
||
|
|
var Any = Object;
|
||
|
|
var throwCCE = Kotlin.throwCCE;
|
||
|
|
var AssertionError_init = Kotlin.kotlin.AssertionError_init;
|
||
|
|
var AssertionError_init_0 = Kotlin.kotlin.AssertionError_init_pdl1vj$;
|
||
|
|
var Kind_OBJECT = Kotlin.Kind.OBJECT;
|
||
|
|
var Kind_CLASS = Kotlin.Kind.CLASS;
|
||
|
|
var Annotation = Kotlin.kotlin.Annotation;
|
||
|
|
var Unit = Kotlin.kotlin.Unit;
|
||
|
|
var println = Kotlin.kotlin.io.println_s8jyv4$;
|
||
|
|
var Throwable = Error;
|
||
|
|
var IllegalArgumentException_init = Kotlin.kotlin.IllegalArgumentException_init_pdl1vj$;
|
||
|
|
var getCallableRef = Kotlin.getCallableRef;
|
||
|
|
var to = Kotlin.kotlin.to_ujzrz7$;
|
||
|
|
var mapOf = Kotlin.kotlin.collections.mapOf_qfcya0$;
|
||
|
|
function get_asserter() {
|
||
|
|
return _asserter != null ? _asserter : lookupAsserter();
|
||
|
|
}
|
||
|
|
var _asserter;
|
||
|
|
function assertTrue(message, block) {
|
||
|
|
if (message === void 0)
|
||
|
|
message = null;
|
||
|
|
assertTrue_0(block(), message);
|
||
|
|
}
|
||
|
|
function assertTrue_0(actual, message) {
|
||
|
|
if (message === void 0)
|
||
|
|
message = null;
|
||
|
|
return get_asserter().assertTrue_4mavae$(message != null ? message : 'Expected value to be true.', actual);
|
||
|
|
}
|
||
|
|
function assertFalse(message, block) {
|
||
|
|
if (message === void 0)
|
||
|
|
message = null;
|
||
|
|
assertFalse_0(block(), message);
|
||
|
|
}
|
||
|
|
function assertFalse_0(actual, message) {
|
||
|
|
if (message === void 0)
|
||
|
|
message = null;
|
||
|
|
return get_asserter().assertTrue_4mavae$(message != null ? message : 'Expected value to be false.', !actual);
|
||
|
|
}
|
||
|
|
function assertEquals(expected, actual, message) {
|
||
|
|
if (message === void 0)
|
||
|
|
message = null;
|
||
|
|
get_asserter().assertEquals_lzc6tz$(message, expected, actual);
|
||
|
|
}
|
||
|
|
function assertNotEquals(illegal, actual, message) {
|
||
|
|
if (message === void 0)
|
||
|
|
message = null;
|
||
|
|
get_asserter().assertNotEquals_lzc6tz$(message, illegal, actual);
|
||
|
|
}
|
||
|
|
function assertSame(expected, actual, message) {
|
||
|
|
if (message === void 0)
|
||
|
|
message = null;
|
||
|
|
get_asserter().assertSame_lzc6tz$(message, expected, actual);
|
||
|
|
}
|
||
|
|
function assertNotSame(illegal, actual, message) {
|
||
|
|
if (message === void 0)
|
||
|
|
message = null;
|
||
|
|
get_asserter().assertNotSame_lzc6tz$(message, illegal, actual);
|
||
|
|
}
|
||
|
|
function assertNotNull(actual, message) {
|
||
|
|
if (message === void 0)
|
||
|
|
message = null;
|
||
|
|
get_asserter().assertNotNull_67rc9h$(message, actual);
|
||
|
|
return ensureNotNull(actual);
|
||
|
|
}
|
||
|
|
function assertNotNull_0(actual, message, block) {
|
||
|
|
if (message === void 0)
|
||
|
|
message = null;
|
||
|
|
get_asserter().assertNotNull_67rc9h$(message, actual);
|
||
|
|
if (actual != null) {
|
||
|
|
block(actual);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function assertNull(actual, message) {
|
||
|
|
if (message === void 0)
|
||
|
|
message = null;
|
||
|
|
get_asserter().assertNull_67rc9h$(message, actual);
|
||
|
|
}
|
||
|
|
function fail(message) {
|
||
|
|
if (message === void 0)
|
||
|
|
message = null;
|
||
|
|
get_asserter().fail_pdl1vj$(message);
|
||
|
|
}
|
||
|
|
function expect(expected, block) {
|
||
|
|
assertEquals(expected, block());
|
||
|
|
}
|
||
|
|
function expect_0(expected, message, block) {
|
||
|
|
assertEquals(expected, block(), message);
|
||
|
|
}
|
||
|
|
var assertFails = defineInlineFunction('kotlin-test.kotlin.test.assertFails_o14v8n$', wrapFunction(function () {
|
||
|
|
var checkResultIsFailure = _.kotlin.test.checkResultIsFailure_8v9b5x$;
|
||
|
|
var Result = Kotlin.kotlin.Result;
|
||
|
|
var Throwable = Error;
|
||
|
|
var createFailure = Kotlin.kotlin.createFailure_tcv7n7$;
|
||
|
|
return function (block) {
|
||
|
|
var tmp$;
|
||
|
|
try {
|
||
|
|
tmp$ = new Result(block());
|
||
|
|
}
|
||
|
|
catch (e) {
|
||
|
|
if (Kotlin.isType(e, Throwable)) {
|
||
|
|
tmp$ = new Result(createFailure(e));
|
||
|
|
}
|
||
|
|
else
|
||
|
|
throw e;
|
||
|
|
}
|
||
|
|
return checkResultIsFailure(null, tmp$);
|
||
|
|
};
|
||
|
|
}));
|
||
|
|
var assertFails_0 = defineInlineFunction('kotlin-test.kotlin.test.assertFails_9bodf6$', wrapFunction(function () {
|
||
|
|
var checkResultIsFailure = _.kotlin.test.checkResultIsFailure_8v9b5x$;
|
||
|
|
var Result = Kotlin.kotlin.Result;
|
||
|
|
var Throwable = Error;
|
||
|
|
var createFailure = Kotlin.kotlin.createFailure_tcv7n7$;
|
||
|
|
return function (message, block) {
|
||
|
|
var tmp$;
|
||
|
|
try {
|
||
|
|
tmp$ = new Result(block());
|
||
|
|
}
|
||
|
|
catch (e) {
|
||
|
|
if (Kotlin.isType(e, Throwable)) {
|
||
|
|
tmp$ = new Result(createFailure(e));
|
||
|
|
}
|
||
|
|
else
|
||
|
|
throw e;
|
||
|
|
}
|
||
|
|
return checkResultIsFailure(message, tmp$);
|
||
|
|
};
|
||
|
|
}));
|
||
|
|
function checkResultIsFailure(message, blockResult) {
|
||
|
|
var tmp$, tmp$_0;
|
||
|
|
var exception = blockResult.exceptionOrNull();
|
||
|
|
if (exception == null) {
|
||
|
|
(tmp$ = blockResult.value) == null || Kotlin.isType(tmp$, Any) || throwCCE();
|
||
|
|
tmp$_0 = get_asserter().fail_pdl1vj$(messagePrefix(message) + 'Expected an exception to be thrown, but was completed successfully.');
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
return exception;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
var assertFailsWith = defineInlineFunction('kotlin-test.kotlin.test.assertFailsWith_cnau6l$', wrapFunction(function () {
|
||
|
|
var getKClass = Kotlin.getKClass;
|
||
|
|
var checkResultIsFailure = _.kotlin.test.checkResultIsFailure_3e4uyv$;
|
||
|
|
var Result = Kotlin.kotlin.Result;
|
||
|
|
var Throwable = Error;
|
||
|
|
var createFailure = Kotlin.kotlin.createFailure_tcv7n7$;
|
||
|
|
return function (T_0, isT, message, block) {
|
||
|
|
if (message === void 0)
|
||
|
|
message = null;
|
||
|
|
var exceptionClass = getKClass(T_0);
|
||
|
|
var tmp$;
|
||
|
|
try {
|
||
|
|
tmp$ = new Result(block());
|
||
|
|
}
|
||
|
|
catch (e) {
|
||
|
|
if (Kotlin.isType(e, Throwable)) {
|
||
|
|
tmp$ = new Result(createFailure(e));
|
||
|
|
}
|
||
|
|
else
|
||
|
|
throw e;
|
||
|
|
}
|
||
|
|
return checkResultIsFailure(exceptionClass, message, tmp$);
|
||
|
|
};
|
||
|
|
}));
|
||
|
|
var assertFailsWith_0 = defineInlineFunction('kotlin-test.kotlin.test.assertFailsWith_jbbixx$', wrapFunction(function () {
|
||
|
|
var checkResultIsFailure = _.kotlin.test.checkResultIsFailure_3e4uyv$;
|
||
|
|
var Result = Kotlin.kotlin.Result;
|
||
|
|
var Throwable = Error;
|
||
|
|
var createFailure = Kotlin.kotlin.createFailure_tcv7n7$;
|
||
|
|
return function (exceptionClass, block) {
|
||
|
|
var tmp$;
|
||
|
|
try {
|
||
|
|
tmp$ = new Result(block());
|
||
|
|
}
|
||
|
|
catch (e) {
|
||
|
|
if (Kotlin.isType(e, Throwable)) {
|
||
|
|
tmp$ = new Result(createFailure(e));
|
||
|
|
}
|
||
|
|
else
|
||
|
|
throw e;
|
||
|
|
}
|
||
|
|
return checkResultIsFailure(exceptionClass, null, tmp$);
|
||
|
|
};
|
||
|
|
}));
|
||
|
|
var assertFailsWith_1 = defineInlineFunction('kotlin-test.kotlin.test.assertFailsWith_l9oqa2$', wrapFunction(function () {
|
||
|
|
var checkResultIsFailure = _.kotlin.test.checkResultIsFailure_3e4uyv$;
|
||
|
|
var Result = Kotlin.kotlin.Result;
|
||
|
|
var Throwable = Error;
|
||
|
|
var createFailure = Kotlin.kotlin.createFailure_tcv7n7$;
|
||
|
|
return function (exceptionClass, message, block) {
|
||
|
|
var tmp$;
|
||
|
|
try {
|
||
|
|
tmp$ = new Result(block());
|
||
|
|
}
|
||
|
|
catch (e) {
|
||
|
|
if (Kotlin.isType(e, Throwable)) {
|
||
|
|
tmp$ = new Result(createFailure(e));
|
||
|
|
}
|
||
|
|
else
|
||
|
|
throw e;
|
||
|
|
}
|
||
|
|
return checkResultIsFailure(exceptionClass, message, tmp$);
|
||
|
|
};
|
||
|
|
}));
|
||
|
|
function Asserter() {
|
||
|
|
}
|
||
|
|
Asserter.prototype.assertTrue_o10pc4$ = function (lazyMessage, actual) {
|
||
|
|
if (!actual) {
|
||
|
|
this.fail_pdl1vj$(lazyMessage());
|
||
|
|
}
|
||
|
|
};
|
||
|
|
function Asserter$assertTrue$lambda(closure$message) {
|
||
|
|
return function () {
|
||
|
|
return closure$message;
|
||
|
|
};
|
||
|
|
}
|
||
|
|
Asserter.prototype.assertTrue_4mavae$ = function (message, actual) {
|
||
|
|
this.assertTrue_o10pc4$(Asserter$assertTrue$lambda(message), actual);
|
||
|
|
};
|
||
|
|
function Asserter$assertEquals$lambda(closure$message, closure$expected, closure$actual) {
|
||
|
|
return function () {
|
||
|
|
return messagePrefix(closure$message) + ('Expected <' + toString(closure$expected) + '>, actual <' + toString(closure$actual) + '>.');
|
||
|
|
};
|
||
|
|
}
|
||
|
|
Asserter.prototype.assertEquals_lzc6tz$ = function (message, expected, actual) {
|
||
|
|
this.assertTrue_o10pc4$(Asserter$assertEquals$lambda(message, expected, actual), equals(actual, expected));
|
||
|
|
};
|
||
|
|
function Asserter$assertNotEquals$lambda(closure$message, closure$actual) {
|
||
|
|
return function () {
|
||
|
|
return messagePrefix(closure$message) + ('Illegal value: <' + toString(closure$actual) + '>.');
|
||
|
|
};
|
||
|
|
}
|
||
|
|
Asserter.prototype.assertNotEquals_lzc6tz$ = function (message, illegal, actual) {
|
||
|
|
this.assertTrue_o10pc4$(Asserter$assertNotEquals$lambda(message, actual), !equals(actual, illegal));
|
||
|
|
};
|
||
|
|
function Asserter$assertSame$lambda(closure$message, closure$expected, closure$actual) {
|
||
|
|
return function () {
|
||
|
|
return messagePrefix(closure$message) + ('Expected <' + toString(closure$expected) + '>, actual <' + toString(closure$actual) + '> is not same.');
|
||
|
|
};
|
||
|
|
}
|
||
|
|
Asserter.prototype.assertSame_lzc6tz$ = function (message, expected, actual) {
|
||
|
|
this.assertTrue_o10pc4$(Asserter$assertSame$lambda(message, expected, actual), actual === expected);
|
||
|
|
};
|
||
|
|
function Asserter$assertNotSame$lambda(closure$message, closure$actual) {
|
||
|
|
return function () {
|
||
|
|
return messagePrefix(closure$message) + ('Expected not same as <' + toString(closure$actual) + '>.');
|
||
|
|
};
|
||
|
|
}
|
||
|
|
Asserter.prototype.assertNotSame_lzc6tz$ = function (message, illegal, actual) {
|
||
|
|
this.assertTrue_o10pc4$(Asserter$assertNotSame$lambda(message, actual), actual !== illegal);
|
||
|
|
};
|
||
|
|
function Asserter$assertNull$lambda(closure$message, closure$actual) {
|
||
|
|
return function () {
|
||
|
|
return messagePrefix(closure$message) + ('Expected value to be null, but was: <' + toString(closure$actual) + '>.');
|
||
|
|
};
|
||
|
|
}
|
||
|
|
Asserter.prototype.assertNull_67rc9h$ = function (message, actual) {
|
||
|
|
this.assertTrue_o10pc4$(Asserter$assertNull$lambda(message, actual), actual == null);
|
||
|
|
};
|
||
|
|
function Asserter$assertNotNull$lambda(closure$message) {
|
||
|
|
return function () {
|
||
|
|
return messagePrefix(closure$message) + 'Expected value to be not null.';
|
||
|
|
};
|
||
|
|
}
|
||
|
|
Asserter.prototype.assertNotNull_67rc9h$ = function (message, actual) {
|
||
|
|
this.assertTrue_o10pc4$(Asserter$assertNotNull$lambda(message), actual != null);
|
||
|
|
};
|
||
|
|
Asserter.$metadata$ = {
|
||
|
|
kind: Kind_INTERFACE,
|
||
|
|
simpleName: 'Asserter',
|
||
|
|
interfaces: []
|
||
|
|
};
|
||
|
|
function AsserterContributor() {
|
||
|
|
}
|
||
|
|
AsserterContributor.$metadata$ = {
|
||
|
|
kind: Kind_INTERFACE,
|
||
|
|
simpleName: 'AsserterContributor',
|
||
|
|
interfaces: []
|
||
|
|
};
|
||
|
|
function DefaultAsserter() {
|
||
|
|
DefaultAsserter_instance = this;
|
||
|
|
}
|
||
|
|
DefaultAsserter.prototype.fail_pdl1vj$ = function (message) {
|
||
|
|
if (message == null)
|
||
|
|
throw AssertionError_init();
|
||
|
|
else
|
||
|
|
throw AssertionError_init_0(message);
|
||
|
|
};
|
||
|
|
DefaultAsserter.$metadata$ = {
|
||
|
|
kind: Kind_OBJECT,
|
||
|
|
simpleName: 'DefaultAsserter',
|
||
|
|
interfaces: [Asserter]
|
||
|
|
};
|
||
|
|
var DefaultAsserter_instance = null;
|
||
|
|
function DefaultAsserter_getInstance() {
|
||
|
|
if (DefaultAsserter_instance === null) {
|
||
|
|
new DefaultAsserter();
|
||
|
|
}
|
||
|
|
return DefaultAsserter_instance;
|
||
|
|
}
|
||
|
|
function DefaultAsserter_0() {
|
||
|
|
return DefaultAsserter_getInstance();
|
||
|
|
}
|
||
|
|
function messagePrefix(message) {
|
||
|
|
return message == null ? '' : toString(message) + '. ';
|
||
|
|
}
|
||
|
|
function overrideAsserter(value) {
|
||
|
|
var $receiver = _asserter;
|
||
|
|
_asserter = value;
|
||
|
|
return $receiver;
|
||
|
|
}
|
||
|
|
function setAdapter(adapter) {
|
||
|
|
setAdapter_0(adapter);
|
||
|
|
}
|
||
|
|
function Test() {
|
||
|
|
}
|
||
|
|
Test.$metadata$ = {
|
||
|
|
kind: Kind_CLASS,
|
||
|
|
simpleName: 'Test',
|
||
|
|
interfaces: [Annotation]
|
||
|
|
};
|
||
|
|
function Ignore() {
|
||
|
|
}
|
||
|
|
Ignore.$metadata$ = {
|
||
|
|
kind: Kind_CLASS,
|
||
|
|
simpleName: 'Ignore',
|
||
|
|
interfaces: [Annotation]
|
||
|
|
};
|
||
|
|
function BeforeTest() {
|
||
|
|
}
|
||
|
|
BeforeTest.$metadata$ = {
|
||
|
|
kind: Kind_CLASS,
|
||
|
|
simpleName: 'BeforeTest',
|
||
|
|
interfaces: [Annotation]
|
||
|
|
};
|
||
|
|
function AfterTest() {
|
||
|
|
}
|
||
|
|
AfterTest.$metadata$ = {
|
||
|
|
kind: Kind_CLASS,
|
||
|
|
simpleName: 'AfterTest',
|
||
|
|
interfaces: [Annotation]
|
||
|
|
};
|
||
|
|
function assertHook$lambda(f) {
|
||
|
|
return Unit;
|
||
|
|
}
|
||
|
|
var assertHook;
|
||
|
|
function DefaultJsAsserter() {
|
||
|
|
DefaultJsAsserter_instance = this;
|
||
|
|
this.e_0 = undefined;
|
||
|
|
this.a_0 = undefined;
|
||
|
|
}
|
||
|
|
DefaultJsAsserter.prototype.assertEquals_lzc6tz$ = function (message, expected, actual) {
|
||
|
|
this.e_0 = expected;
|
||
|
|
this.a_0 = actual;
|
||
|
|
Asserter.prototype.assertEquals_lzc6tz$.call(this, message, expected, actual);
|
||
|
|
};
|
||
|
|
DefaultJsAsserter.prototype.assertNotEquals_lzc6tz$ = function (message, illegal, actual) {
|
||
|
|
this.e_0 = illegal;
|
||
|
|
this.a_0 = actual;
|
||
|
|
Asserter.prototype.assertNotEquals_lzc6tz$.call(this, message, illegal, actual);
|
||
|
|
};
|
||
|
|
DefaultJsAsserter.prototype.assertSame_lzc6tz$ = function (message, expected, actual) {
|
||
|
|
this.e_0 = expected;
|
||
|
|
this.a_0 = actual;
|
||
|
|
Asserter.prototype.assertSame_lzc6tz$.call(this, message, expected, actual);
|
||
|
|
};
|
||
|
|
DefaultJsAsserter.prototype.assertNotSame_lzc6tz$ = function (message, illegal, actual) {
|
||
|
|
this.e_0 = illegal;
|
||
|
|
this.a_0 = actual;
|
||
|
|
Asserter.prototype.assertNotSame_lzc6tz$.call(this, message, illegal, actual);
|
||
|
|
};
|
||
|
|
DefaultJsAsserter.prototype.assertNull_67rc9h$ = function (message, actual) {
|
||
|
|
this.a_0 = actual;
|
||
|
|
Asserter.prototype.assertNull_67rc9h$.call(this, message, actual);
|
||
|
|
};
|
||
|
|
DefaultJsAsserter.prototype.assertNotNull_67rc9h$ = function (message, actual) {
|
||
|
|
this.a_0 = actual;
|
||
|
|
Asserter.prototype.assertNotNull_67rc9h$.call(this, message, actual);
|
||
|
|
};
|
||
|
|
DefaultJsAsserter.prototype.assertTrue_o10pc4$ = function (lazyMessage, actual) {
|
||
|
|
if (!actual) {
|
||
|
|
this.failWithMessage_0(lazyMessage);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
this.invokeHook_0(true, lazyMessage);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
function DefaultJsAsserter$assertTrue$lambda(closure$message) {
|
||
|
|
return function () {
|
||
|
|
return closure$message;
|
||
|
|
};
|
||
|
|
}
|
||
|
|
DefaultJsAsserter.prototype.assertTrue_4mavae$ = function (message, actual) {
|
||
|
|
this.assertTrue_o10pc4$(DefaultJsAsserter$assertTrue$lambda(message), actual);
|
||
|
|
};
|
||
|
|
function DefaultJsAsserter$fail$lambda(closure$message) {
|
||
|
|
return function () {
|
||
|
|
return closure$message;
|
||
|
|
};
|
||
|
|
}
|
||
|
|
DefaultJsAsserter.prototype.fail_pdl1vj$ = function (message) {
|
||
|
|
this.failWithMessage_0(DefaultJsAsserter$fail$lambda(message));
|
||
|
|
};
|
||
|
|
function DefaultJsAsserter$failWithMessage$lambda(closure$message) {
|
||
|
|
return function () {
|
||
|
|
return closure$message;
|
||
|
|
};
|
||
|
|
}
|
||
|
|
DefaultJsAsserter.prototype.failWithMessage_0 = function (lazyMessage) {
|
||
|
|
var message = lazyMessage();
|
||
|
|
this.invokeHook_0(false, DefaultJsAsserter$failWithMessage$lambda(message));
|
||
|
|
if (message == null)
|
||
|
|
throw AssertionError_init();
|
||
|
|
else
|
||
|
|
throw AssertionError_init_0(message);
|
||
|
|
};
|
||
|
|
function DefaultJsAsserter$invokeHook$ObjectLiteral(closure$result, closure$lazyMessage) {
|
||
|
|
this.result_13foyd$_0 = closure$result;
|
||
|
|
this.expected_q67qvk$_0 = DefaultJsAsserter_getInstance().e_0;
|
||
|
|
this.actual_wkq0m2$_0 = DefaultJsAsserter_getInstance().a_0;
|
||
|
|
this.lazyMessage_wfmiv$_0 = closure$lazyMessage;
|
||
|
|
}
|
||
|
|
Object.defineProperty(DefaultJsAsserter$invokeHook$ObjectLiteral.prototype, 'result', {
|
||
|
|
get: function () {
|
||
|
|
return this.result_13foyd$_0;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
Object.defineProperty(DefaultJsAsserter$invokeHook$ObjectLiteral.prototype, 'expected', {
|
||
|
|
get: function () {
|
||
|
|
return this.expected_q67qvk$_0;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
Object.defineProperty(DefaultJsAsserter$invokeHook$ObjectLiteral.prototype, 'actual', {
|
||
|
|
get: function () {
|
||
|
|
return this.actual_wkq0m2$_0;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
Object.defineProperty(DefaultJsAsserter$invokeHook$ObjectLiteral.prototype, 'lazyMessage', {
|
||
|
|
get: function () {
|
||
|
|
return this.lazyMessage_wfmiv$_0;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
DefaultJsAsserter$invokeHook$ObjectLiteral.$metadata$ = {
|
||
|
|
kind: Kind_CLASS,
|
||
|
|
interfaces: []
|
||
|
|
};
|
||
|
|
DefaultJsAsserter.prototype.invokeHook_0 = function (result, lazyMessage) {
|
||
|
|
try {
|
||
|
|
assertHook(new DefaultJsAsserter$invokeHook$ObjectLiteral(result, lazyMessage));
|
||
|
|
}
|
||
|
|
finally {
|
||
|
|
this.e_0 = undefined;
|
||
|
|
this.a_0 = undefined;
|
||
|
|
}
|
||
|
|
};
|
||
|
|
DefaultJsAsserter.$metadata$ = {
|
||
|
|
kind: Kind_OBJECT,
|
||
|
|
simpleName: 'DefaultJsAsserter',
|
||
|
|
interfaces: [Asserter]
|
||
|
|
};
|
||
|
|
var DefaultJsAsserter_instance = null;
|
||
|
|
function DefaultJsAsserter_getInstance() {
|
||
|
|
if (DefaultJsAsserter_instance === null) {
|
||
|
|
new DefaultJsAsserter();
|
||
|
|
}
|
||
|
|
return DefaultJsAsserter_instance;
|
||
|
|
}
|
||
|
|
function todo(block) {
|
||
|
|
println('TODO at ' + toString(block));
|
||
|
|
}
|
||
|
|
function checkResultIsFailure_0(exceptionClass, message, blockResult) {
|
||
|
|
var tmp$, tmp$_0;
|
||
|
|
var exception = blockResult.exceptionOrNull();
|
||
|
|
if (exception == null) {
|
||
|
|
(tmp$ = blockResult.value) == null || Kotlin.isType(tmp$, Any) || throwCCE();
|
||
|
|
tmp$_0 = get_asserter().fail_pdl1vj$(messagePrefix(message) + ('Expected an exception of ' + exceptionClass + ' to be thrown, but was completed successfully.'));
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
var tmp$_1;
|
||
|
|
if (exceptionClass.isInstance_s8jyv4$(exception)) {
|
||
|
|
return Kotlin.isType(tmp$_1 = exception, Throwable) ? tmp$_1 : throwCCE();
|
||
|
|
}
|
||
|
|
tmp$_0 = get_asserter().fail_pdl1vj$(messagePrefix(message) + ('Expected an exception of ' + exceptionClass + ' to be thrown, but was ' + exception));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function lookupAsserter() {
|
||
|
|
return DefaultJsAsserter_getInstance();
|
||
|
|
}
|
||
|
|
function setAdapter_0(adapter) {
|
||
|
|
var tmp$;
|
||
|
|
if (typeof adapter === 'string') {
|
||
|
|
var tmp$_0;
|
||
|
|
if ((tmp$ = NAME_TO_ADAPTER.get_11rb$(adapter)) != null) {
|
||
|
|
setAdapter_0(tmp$());
|
||
|
|
tmp$_0 = Unit;
|
||
|
|
}
|
||
|
|
else
|
||
|
|
tmp$_0 = null;
|
||
|
|
if (tmp$_0 == null)
|
||
|
|
throw IllegalArgumentException_init("Unsupported test framework adapter: '" + adapter.toString() + "'");
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
currentAdapter = adapter;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
function setAssertHook(hook) {
|
||
|
|
assertHook = hook;
|
||
|
|
}
|
||
|
|
function suite(name, ignored, suiteFn) {
|
||
|
|
adapter().suite(name, ignored, suiteFn);
|
||
|
|
}
|
||
|
|
function test(name, ignored, testFn) {
|
||
|
|
adapter().test(name, ignored, testFn);
|
||
|
|
}
|
||
|
|
var currentAdapter;
|
||
|
|
function adapter() {
|
||
|
|
var result = currentAdapter != null ? currentAdapter : detectAdapter();
|
||
|
|
currentAdapter = result;
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
function detectAdapter() {
|
||
|
|
if (isQUnit())
|
||
|
|
return new QUnitAdapter();
|
||
|
|
else if (isJasmine())
|
||
|
|
return new JasmineLikeAdapter();
|
||
|
|
else
|
||
|
|
return new BareAdapter();
|
||
|
|
}
|
||
|
|
var NAME_TO_ADAPTER;
|
||
|
|
function BareAdapter() {
|
||
|
|
}
|
||
|
|
BareAdapter.prototype.suite = function (name, ignored, suiteFn) {
|
||
|
|
if (!ignored) {
|
||
|
|
suiteFn();
|
||
|
|
}
|
||
|
|
};
|
||
|
|
BareAdapter.prototype.test = function (name, ignored, testFn) {
|
||
|
|
if (!ignored) {
|
||
|
|
testFn();
|
||
|
|
}
|
||
|
|
};
|
||
|
|
BareAdapter.$metadata$ = {
|
||
|
|
kind: Kind_CLASS,
|
||
|
|
simpleName: 'BareAdapter',
|
||
|
|
interfaces: []
|
||
|
|
};
|
||
|
|
function isQUnit() {
|
||
|
|
return typeof QUnit !== 'undefined';
|
||
|
|
}
|
||
|
|
function isJasmine() {
|
||
|
|
return typeof describe === 'function' && typeof it === 'function';
|
||
|
|
}
|
||
|
|
function JasmineLikeAdapter() {
|
||
|
|
}
|
||
|
|
JasmineLikeAdapter.prototype.suite = function (name, ignored, suiteFn) {
|
||
|
|
if (ignored) {
|
||
|
|
xdescribe(name, suiteFn);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
describe(name, suiteFn);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
JasmineLikeAdapter.prototype.test = function (name, ignored, testFn) {
|
||
|
|
if (ignored) {
|
||
|
|
xit(name, testFn);
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
it(name, testFn);
|
||
|
|
}
|
||
|
|
};
|
||
|
|
JasmineLikeAdapter.$metadata$ = {
|
||
|
|
kind: Kind_CLASS,
|
||
|
|
simpleName: 'JasmineLikeAdapter',
|
||
|
|
interfaces: []
|
||
|
|
};
|
||
|
|
function QUnitAdapter() {
|
||
|
|
this.ignoredSuite = false;
|
||
|
|
}
|
||
|
|
QUnitAdapter.prototype.suite = function (name, ignored, suiteFn) {
|
||
|
|
var prevIgnore = this.ignoredSuite;
|
||
|
|
this.ignoredSuite = this.ignoredSuite | ignored;
|
||
|
|
QUnit.module(name, suiteFn);
|
||
|
|
this.ignoredSuite = prevIgnore;
|
||
|
|
};
|
||
|
|
QUnitAdapter.prototype.test = function (name, ignored, testFn) {
|
||
|
|
if (ignored | this.ignoredSuite) {
|
||
|
|
QUnit.skip(name, this.wrapTest_0(testFn));
|
||
|
|
}
|
||
|
|
else {
|
||
|
|
QUnit.test(name, this.wrapTest_0(testFn));
|
||
|
|
}
|
||
|
|
};
|
||
|
|
function QUnitAdapter$wrapTest$lambda$lambda(closure$assertionsHappened, closure$assert) {
|
||
|
|
return function (testResult) {
|
||
|
|
closure$assertionsHappened.v = true;
|
||
|
|
closure$assert.ok(testResult.result, testResult.lazyMessage());
|
||
|
|
return Unit;
|
||
|
|
};
|
||
|
|
}
|
||
|
|
function QUnitAdapter$wrapTest$lambda(closure$testFn) {
|
||
|
|
return function (assert) {
|
||
|
|
var assertionsHappened = {v: false};
|
||
|
|
assertHook = QUnitAdapter$wrapTest$lambda$lambda(assertionsHappened, assert);
|
||
|
|
var possiblePromise = closure$testFn();
|
||
|
|
if (!assertionsHappened.v) {
|
||
|
|
assertTrue_0(true, 'A test with no assertions is considered successful');
|
||
|
|
}
|
||
|
|
return possiblePromise;
|
||
|
|
};
|
||
|
|
}
|
||
|
|
QUnitAdapter.prototype.wrapTest_0 = function (testFn) {
|
||
|
|
return QUnitAdapter$wrapTest$lambda(testFn);
|
||
|
|
};
|
||
|
|
QUnitAdapter.$metadata$ = {
|
||
|
|
kind: Kind_CLASS,
|
||
|
|
simpleName: 'QUnitAdapter',
|
||
|
|
interfaces: []
|
||
|
|
};
|
||
|
|
var package$kotlin = _.kotlin || (_.kotlin = {});
|
||
|
|
var package$test = package$kotlin.test || (package$kotlin.test = {});
|
||
|
|
Object.defineProperty(package$test, 'asserter', {
|
||
|
|
get: get_asserter
|
||
|
|
});
|
||
|
|
Object.defineProperty(package$test, '_asserter_8be2vx$', {
|
||
|
|
get: function () {
|
||
|
|
return _asserter;
|
||
|
|
},
|
||
|
|
set: function (value) {
|
||
|
|
_asserter = value;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
package$test.assertTrue_i7pyzi$ = assertTrue;
|
||
|
|
package$test.assertTrue_ifx8ge$ = assertTrue_0;
|
||
|
|
package$test.assertFalse_i7pyzi$ = assertFalse;
|
||
|
|
package$test.assertFalse_ifx8ge$ = assertFalse_0;
|
||
|
|
package$test.assertEquals_3m0tl5$ = assertEquals;
|
||
|
|
package$test.assertNotEquals_3m0tl5$ = assertNotEquals;
|
||
|
|
package$test.assertSame_3m0tl5$ = assertSame;
|
||
|
|
package$test.assertNotSame_3m0tl5$ = assertNotSame;
|
||
|
|
package$test.assertNotNull_tkjle6$ = assertNotNull;
|
||
|
|
package$test.assertNotNull_k6pbc4$ = assertNotNull_0;
|
||
|
|
package$test.assertNull_dzvdf1$ = assertNull;
|
||
|
|
package$test.fail_pdl1vj$ = fail;
|
||
|
|
package$test.expect_e96eyq$ = expect;
|
||
|
|
package$test.expect_rr7wld$ = expect_0;
|
||
|
|
package$test.checkResultIsFailure_8v9b5x$ = checkResultIsFailure;
|
||
|
|
$$importsForInline$$['kotlin-test'] = _;
|
||
|
|
package$test.checkResultIsFailure_3e4uyv$ = checkResultIsFailure_0;
|
||
|
|
package$test.Asserter = Asserter;
|
||
|
|
package$test.AsserterContributor = AsserterContributor;
|
||
|
|
Object.defineProperty(package$test, 'DefaultAsserter', {
|
||
|
|
get: DefaultAsserter_getInstance
|
||
|
|
});
|
||
|
|
package$test.DefaultAsserterConstructor = DefaultAsserter_0;
|
||
|
|
package$test.messagePrefix_7efafy$ = messagePrefix;
|
||
|
|
package$test.overrideAsserter_wbnzx$ = overrideAsserter;
|
||
|
|
_.setAdapter = setAdapter;
|
||
|
|
package$test.Test = Test;
|
||
|
|
package$test.Ignore = Ignore;
|
||
|
|
package$test.BeforeTest = BeforeTest;
|
||
|
|
package$test.AfterTest = AfterTest;
|
||
|
|
Object.defineProperty(package$test, 'assertHook_8be2vx$', {
|
||
|
|
get: function () {
|
||
|
|
return assertHook;
|
||
|
|
},
|
||
|
|
set: function (value) {
|
||
|
|
assertHook = value;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
Object.defineProperty(package$test, 'DefaultJsAsserter', {
|
||
|
|
get: DefaultJsAsserter_getInstance
|
||
|
|
});
|
||
|
|
package$test.todo_o14v8n$ = todo;
|
||
|
|
package$test.lookupAsserter_8be2vx$ = lookupAsserter;
|
||
|
|
package$test.setAdapter_kcmwxo$ = setAdapter_0;
|
||
|
|
package$test.setAssertHook_4duqou$ = setAssertHook;
|
||
|
|
package$test.suite = suite;
|
||
|
|
package$test.test = test;
|
||
|
|
Object.defineProperty(package$test, 'currentAdapter_8be2vx$', {
|
||
|
|
get: function () {
|
||
|
|
return currentAdapter;
|
||
|
|
},
|
||
|
|
set: function (value) {
|
||
|
|
currentAdapter = value;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
package$test.adapter_8be2vx$ = adapter;
|
||
|
|
package$test.detectAdapter_8be2vx$ = detectAdapter;
|
||
|
|
Object.defineProperty(package$test, 'NAME_TO_ADAPTER_8be2vx$', {
|
||
|
|
get: function () {
|
||
|
|
return NAME_TO_ADAPTER;
|
||
|
|
}
|
||
|
|
});
|
||
|
|
var package$adapters = package$test.adapters || (package$test.adapters = {});
|
||
|
|
package$adapters.BareAdapter = BareAdapter;
|
||
|
|
package$adapters.isQUnit_8be2vx$ = isQUnit;
|
||
|
|
package$adapters.isJasmine_8be2vx$ = isJasmine;
|
||
|
|
package$adapters.JasmineLikeAdapter = JasmineLikeAdapter;
|
||
|
|
package$adapters.QUnitAdapter = QUnitAdapter;
|
||
|
|
DefaultAsserter.prototype.assertTrue_o10pc4$ = Asserter.prototype.assertTrue_o10pc4$;
|
||
|
|
DefaultAsserter.prototype.assertTrue_4mavae$ = Asserter.prototype.assertTrue_4mavae$;
|
||
|
|
DefaultAsserter.prototype.assertEquals_lzc6tz$ = Asserter.prototype.assertEquals_lzc6tz$;
|
||
|
|
DefaultAsserter.prototype.assertNotEquals_lzc6tz$ = Asserter.prototype.assertNotEquals_lzc6tz$;
|
||
|
|
DefaultAsserter.prototype.assertSame_lzc6tz$ = Asserter.prototype.assertSame_lzc6tz$;
|
||
|
|
DefaultAsserter.prototype.assertNotSame_lzc6tz$ = Asserter.prototype.assertNotSame_lzc6tz$;
|
||
|
|
DefaultAsserter.prototype.assertNull_67rc9h$ = Asserter.prototype.assertNull_67rc9h$;
|
||
|
|
DefaultAsserter.prototype.assertNotNull_67rc9h$ = Asserter.prototype.assertNotNull_67rc9h$;
|
||
|
|
_asserter = null;
|
||
|
|
assertHook = assertHook$lambda;
|
||
|
|
currentAdapter = null;
|
||
|
|
NAME_TO_ADAPTER = mapOf([to('qunit', getCallableRef('QUnitAdapter', function () {
|
||
|
|
return new QUnitAdapter();
|
||
|
|
})), to('jasmine', getCallableRef('JasmineLikeAdapter', function () {
|
||
|
|
return new JasmineLikeAdapter();
|
||
|
|
})), to('mocha', getCallableRef('JasmineLikeAdapter', function () {
|
||
|
|
return new JasmineLikeAdapter();
|
||
|
|
})), to('jest', getCallableRef('JasmineLikeAdapter', function () {
|
||
|
|
return new JasmineLikeAdapter();
|
||
|
|
})), to('auto', getCallableRef('detectAdapter', function () {
|
||
|
|
return detectAdapter();
|
||
|
|
}))]);
|
||
|
|
Kotlin.defineModule('kotlin-test', _);
|
||
|
|
return _;
|
||
|
|
}));
|
||
|
|
|
||
|
|
//# sourceMappingURL=kotlin-test.js.map
|