implab/implabjs-core Commit - r77:04efbdad7679

more tests

cin -

r77:04efbdad7679 default

parent child

Context file:

r77:04efbdad7679

Collapse all files

history.md +1 -1

             - `di` - dependency injection container
             - `log` - log4 style logging system
             - `text` - simple and fast text templating and formatting
-            - `Uuid` - uuid generation traits
  No newline at end of file
+            - `Uuid` - uuid generation traits

src/main/ts/safe.ts +2 -4

             }
             export function delay(timeMs: number, ct = Cancellation.none) {
+                ct.throwIfRequested();
                 return new Promise((resolve, reject) => {
-                    if (ct.isRequested()) {
-                        ct.register(reject);
-                    } else {
                     const h = ct.register(e => {
                         clearTimeout(id);
                         reject(e);
                         h.destroy();
                         resolve();
                     }, timeMs);
                 });
             }

src/test/ts/CancellationTests.ts +1 -2

             import * as tape from "tape";
             import { Cancellation } from "@implab/core/Cancellation";
-            import { ICancellation } from "@implab/core/interfaces";
+            import { delay } from "@implab/core/safe";
-            import { delay } from "./TestTraits";
             tape("standalone cancellation", async t => {

src/test/ts/ObservableTests.ts +1 -1

             import { TraceSource, DebugLevel } from "@implab/core/log/TraceSource";
             import * as tape from "tape";
-            import { TapeWriter, delay } from "./TestTraits";
             import { Observable } from "@implab/core/Observable";
             import { IObservable } from "@implab/core/interfaces";
+            import { delay } from "@implab/core/safe";
             const trace = TraceSource.get("ObservableTests");

src/test/ts/SafeTests.ts +23 -10

             import tape = require("tape");
-            import { delay } from "./TestTraits";
             import { Cancellation } from "@implab/core/Cancellation";
-            import { first, isPromise } from "@implab/core/safe";
+            import { first, isPromise, firstWhere, delay, nowait } from "@implab/core/safe";
             tape("await delay test", async t => {
                 // schedule delay
                     t.pass("the delay is cancelled");
                 }
-                let died = false;
+                t.throws(() => {
                     // try schedule delay after the cancellation is requested
-                res = delay(0, ct).then(x => true, () => died = true);
+                    nowait(delay(0, ct));
+                }, "Should throw if cancelled before start");
-                t.false(died, "The delay should be scheduled even if the cancellation is requested");
-                await res;
-                t.true(died, "the delay should fail when cancelled");
                 t.end();
             });
                 // synchronous tests
                 t.equals(first(sequence), "a", "Should return the first element");
+                t.equals(firstWhere(sequence, x => x === "b"), "b", "Should get the second element");
                 let v: string;
                 let e: Error;
                 first(sequence, x => v = x);
                 t.equal(v, "a", "The callback should be called for the first element");
+                firstWhere(sequence, x => x === "b", x => v = x);
+                t.equal(v, "b", "The callback should be called for the second element");
                 t.throws(() => {
                     first(empty);
                 }, "Should throw when the sequence is empty");
                 t.throws(() => {
+                    firstWhere(empty, x => x === "b");
+                }, "Should throw when the sequence is empty");
+                t.throws(() => {
                     first(empty, x => v = x);
                 }, "Should throw when the sequence is empty");
+                t.throws(() => {
+                    firstWhere(empty, x => x === "b", x => v = x);
+                }, "Should throw when the sequence is empty");
+                t.throws(() => {
+                    firstWhere(sequence, x => x === "z");
+                }, "Should throw when the element isn't found");
+                t.throws(() => {
+                    firstWhere(sequence, x => x === "z", x => v = x);
+                }, "Should throw when the element isn't found");
                 first(empty, null, x => e = x);
                 t.true(e, "The errorback should be called for the empty sequence");

src/test/ts/TestTraits.ts 0 -23

@@ -39,29 +39,6 export class TapeWriter implements IDest
39	}	39	}
40	}	40	}
41		41
42	export async function delay(timeout: number, ct: ICancellation = Cancellation.none) {
43	let un: IDestroyable;
44
45	try {
46	await new Promise((resolve, reject) => {
47	if (ct.isRequested()) {
48	un = ct.register(reject);
49	} else {
50	const ht = setTimeout(() => {
51	resolve();
52	}, timeout);
53
54	un = ct.register(e => {
55	clearTimeout(ht);
56	reject(e);
57	});
58	}
59	});
60	} finally {
61	destroy(un);
62	}
63	}
64
65	export function test(name: string, cb: (t: tape.Test) => any) {	42	export function test(name: string, cb: (t: tape.Test) => any) {
66	tape(name, async t => {	43	tape(name, async t => {
67	const writer = new TapeWriter(t);	44	const writer = new TapeWriter(t);

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages