Apply new testing tools

src/MainUI.spec.ts

@@ -1,9 +1,5 @@
 /// <reference path="ui/TestGame.ts" />
 
-if (typeof window != "undefined") {
-    (<any>window).describe = (<any>window).describe || function () { };
-}
-
 module TK.SpaceTac.UI.Specs {
     class FakeStorage {
         data: any = {}
@@ -15,31 +11,31 @@ module TK.SpaceTac.UI.Specs {
         }
     }
 
-    describe("MainUI", () => {
+    testing("MainUI", test => {
         let testgame = setupEmptyView();
 
-        it("saves games in local browser storage", function () {
+        test.case("saves games in local browser storage", check => {
             let ui = testgame.ui;
             ui.storage = <any>new FakeStorage();
 
             let result = ui.loadGame("spacetac-test-save");
-            expect(result).toBe(false);
+            check.equals(result, false);
 
             ui.session.startNewGame();
             let systems = ui.session.universe.stars.length;
             let links = ui.session.universe.starlinks.length;
 
             result = ui.saveGame("spacetac-test-save");
-            expect(result).toBe(true);
+            check.equals(result, true);
             expect(ui.storage.getItem("spacetac-test-save")).toBeTruthy();
 
             ui.session = new GameSession();
-            expect(ui.session.universe.stars.length).not.toBe(systems);
+            check.notsame(ui.session.universe.stars.length, systems);
 
             result = ui.loadGame("spacetac-test-save");
-            expect(result).toBe(true);
-            expect(ui.session.universe.stars.length).toBe(systems);
-            expect(ui.session.universe.starlinks.length).toBe(links);
+            check.equals(result, true);
+            check.same(ui.session.universe.stars.length, systems);
+            check.same(ui.session.universe.starlinks.length, links);
         });
     });
 }

src/common

@@ -1 +1 @@
-Subproject commit 586788a4685a5b9a5cc8f4882f48f18c91997dc3
+Subproject commit f867187f0da83bbd4c4eb9d8221982a2b6e6e027

src/core/ArenaLocation.spec.ts

@@ -1,20 +1,20 @@
 module TK.SpaceTac.Specs {
-    describe("ArenaLocation", () => {
-        it("gets distance and angle between two locations", function () {
-            expect(arenaDistance({ x: 0, y: 0 }, { x: 1, y: 1 })).toBeCloseTo(Math.sqrt(2), 8);
-            expect(arenaAngle({ x: 0, y: 0 }, { x: 1, y: 1 })).toBeCloseTo(Math.PI / 4, 8);
+    testing("ArenaLocation", test => {
+        test.case("gets distance and angle between two locations", check => {
+            check.nears(arenaDistance({ x: 0, y: 0 }, { x: 1, y: 1 }), Math.sqrt(2));
+            check.nears(arenaAngle({ x: 0, y: 0 }, { x: 1, y: 1 }), Math.PI / 4);
         })
 
-        it("gets an angular distance", function () {
-            expect(angularDistance(0.5, 1.5)).toBe(1.0);
-            expect(angularDistance(0.5, 1.5 + Math.PI * 6)).toBeCloseTo(1.0, 0.000001);
-            expect(angularDistance(0.5, -0.5)).toBe(-1.0);
-            expect(angularDistance(0.5, -0.3 - Math.PI * 4)).toBeCloseTo(-0.8, 0.000001);
+        test.case("gets an angular distance", check => {
+            check.equals(angularDistance(0.5, 1.5), 1.0);
+            check.nears(angularDistance(0.5, 1.5 + Math.PI * 6), 1.0);
+            check.same(angularDistance(0.5, -0.5), -1.0);
+            check.nears(angularDistance(0.5, -0.3 - Math.PI * 4), -0.8);
         })
 
-        it("converts between degrees and radians", function () {
-            expect(degrees(Math.PI / 2)).toBeCloseTo(90, 0.000001);
-            expect(radians(45)).toBeCloseTo(Math.PI / 4, 0.000001);
+        test.case("converts between degrees and radians", check => {
+            check.nears(degrees(Math.PI / 2), 90);
+            check.nears(radians(45), Math.PI / 4);
         });
     });
 }

src/core/Battle.spec.ts

@@ -1,6 +1,6 @@
 module TK.SpaceTac {
-    describe("Battle", function () {
-        it("defines play order by initiative throws", function () {
+    testing("Battle", test => {
+        test.case("defines play order by initiative throws", check => {
             var fleet1 = new Fleet();
             var fleet2 = new Fleet();
 
@@ -16,16 +16,16 @@ module TK.SpaceTac {
             ship5.setAttribute("maneuvrability", 2);
 
             var battle = new Battle(fleet1, fleet2);
-            expect(battle.play_order.length).toBe(0);
+            check.equals(battle.play_order.length, 0);
 
             var gen = new SkewedRandomGenerator([1.0, 0.1, 1.0, 0.2, 0.6]);
             battle.throwInitiative(gen);
 
-            expect(battle.play_order.length).toBe(5);
-            expect(battle.play_order).toEqual([ship1, ship4, ship5, ship3, ship2]);
+            check.equals(battle.play_order.length, 5);
+            check.equals(battle.play_order, [ship1, ship4, ship5, ship3, ship2]);
         });
 
-        it("places ships on lines, facing the arena center", function () {
+        test.case("places ships on lines, facing the arena center", check => {
             var fleet1 = new Fleet();
             var fleet2 = new Fleet();
 
@@ -38,28 +38,28 @@ module TK.SpaceTac {
             var battle = new Battle(fleet1, fleet2, 1000, 500);
             battle.placeShips();
 
-            expect(ship1.arena_x).toBeCloseTo(250, 0.0001);
-            expect(ship1.arena_y).toBeCloseTo(150, 0.0001);
-            expect(ship1.arena_angle).toBeCloseTo(0, 0.0001);
+            check.nears(ship1.arena_x, 250);
+            check.nears(ship1.arena_y, 150);
+            check.nears(ship1.arena_angle, 0);
 
-            expect(ship2.arena_x).toBeCloseTo(250, 0.0001);
-            expect(ship2.arena_y).toBeCloseTo(250, 0.0001);
-            expect(ship2.arena_angle).toBeCloseTo(0, 0.0001);
+            check.nears(ship2.arena_x, 250);
+            check.nears(ship2.arena_y, 250);
+            check.nears(ship2.arena_angle, 0);
 
-            expect(ship3.arena_x).toBeCloseTo(250, 0.0001);
-            expect(ship3.arena_y).toBeCloseTo(350, 0.0001);
-            expect(ship3.arena_angle).toBeCloseTo(0, 0.0001);
+            check.nears(ship3.arena_x, 250);
+            check.nears(ship3.arena_y, 350);
+            check.nears(ship3.arena_angle, 0);
 
-            expect(ship4.arena_x).toBeCloseTo(750, 0.0001);
-            expect(ship4.arena_y).toBeCloseTo(300, 0.0001);
-            expect(ship4.arena_angle).toBeCloseTo(Math.PI, 0.0001);
+            check.nears(ship4.arena_x, 750);
+            check.nears(ship4.arena_y, 300);
+            check.nears(ship4.arena_angle, Math.PI);
 
-            expect(ship5.arena_x).toBeCloseTo(750, 0.0001);
-            expect(ship5.arena_y).toBeCloseTo(200, 0.0001);
-            expect(ship5.arena_angle).toBeCloseTo(Math.PI, 0.0001);
+            check.nears(ship5.arena_x, 750);
+            check.nears(ship5.arena_y, 200);
+            check.nears(ship5.arena_angle, Math.PI);
         });
 
-        it("advances to next ship in play order", function () {
+        test.case("advances to next ship in play order", check => {
             var fleet1 = new Fleet();
             var fleet2 = new Fleet();
 
@@ -70,40 +70,40 @@ module TK.SpaceTac {
             var battle = new Battle(fleet1, fleet2);
 
             // Check empty play_order case
-            expect(battle.playing_ship).toBeNull();
+            check.equals(battle.playing_ship, null);
             battle.advanceToNextShip();
-            expect(battle.playing_ship).toBeNull();
+            check.equals(battle.playing_ship, null);
 
             // Force play order
             iforeach(battle.iships(), ship => ship.setAttribute("maneuvrability", 1));
             var gen = new SkewedRandomGenerator([0.1, 0.2, 0.0]);
             battle.throwInitiative(gen);
-            expect(battle.playing_ship).toBeNull();
+            check.equals(battle.playing_ship, null);
 
             battle.advanceToNextShip();
-            expect(battle.playing_ship).toBe(ship2);
+            check.same(battle.playing_ship, ship2);
 
             battle.advanceToNextShip();
-            expect(battle.playing_ship).toBe(ship1);
+            check.same(battle.playing_ship, ship1);
 
             battle.advanceToNextShip();
-            expect(battle.playing_ship).toBe(ship3);
+            check.same(battle.playing_ship, ship3);
 
             battle.advanceToNextShip();
-            expect(battle.playing_ship).toBe(ship2);
+            check.same(battle.playing_ship, ship2);
 
             // A dead ship is skipped
             ship1.setDead();
             battle.advanceToNextShip();
-            expect(battle.playing_ship).toBe(ship3);
+            check.same(battle.playing_ship, ship3);
 
             // Playing ship dies
             ship3.setDead();
             battle.advanceToNextShip();
-            expect(battle.playing_ship).toBe(ship2);
+            check.same(battle.playing_ship, ship2);
         });
 
-        it("calls startTurn on ships", function () {
+        test.case("calls startTurn on ships", check => {
             var fleet1 = new Fleet();
             var fleet2 = new Fleet();
 
@@ -134,7 +134,7 @@ module TK.SpaceTac {
             expect(ship1.startTurn).toHaveBeenCalledWith();
         });
 
-        it("detects victory condition and logs a final EndBattleEvent", function () {
+        test.case("detects victory condition and logs a final EndBattleEvent", check => {
             var fleet1 = new Fleet();
             var fleet2 = new Fleet();
 
@@ -145,7 +145,7 @@ module TK.SpaceTac {
             var battle = new Battle(fleet1, fleet2);
 
             battle.start();
-            expect(battle.ended).toBe(false);
+            check.equals(battle.ended, false);
 
             ship1.setDead();
             ship2.setDead();
@@ -153,14 +153,14 @@ module TK.SpaceTac {
             battle.log.clear();
             battle.advanceToNextShip();
 
-            expect(battle.ended).toBe(true);
-            expect(battle.log.events.length).toBe(1);
-            expect(battle.log.events[0].code).toBe("endbattle");
-            expect((<EndBattleEvent>battle.log.events[0]).outcome.winner).not.toBeNull();
-            expect((<EndBattleEvent>battle.log.events[0]).outcome.winner).toBe(fleet2);
+            check.equals(battle.ended, true);
+            check.equals(battle.log.events.length, 1);
+            check.equals(battle.log.events[0].code, "endbattle");
+            check.notequals((<EndBattleEvent>battle.log.events[0]).outcome.winner, null);
+            check.same((<EndBattleEvent>battle.log.events[0]).outcome.winner, fleet2);
         });
 
-        it("wear down equipment at the end of battle", function () {
+        test.case("wear down equipment at the end of battle", check => {
             let fleet1 = new Fleet();
             let ship1a = fleet1.addShip();
             let equ1a = TestTools.addWeapon(ship1a);
@@ -174,27 +174,27 @@ module TK.SpaceTac {
             let battle = new Battle(fleet1, fleet2);
             battle.start();
 
-            expect(equ1a.wear).toBe(0);
-            expect(equ1b.wear).toBe(0);
-            expect(equ2a.wear).toBe(0);
-            expect(eng2a.wear).toBe(0);
+            check.equals(equ1a.wear, 0);
+            check.equals(equ1b.wear, 0);
+            check.equals(equ2a.wear, 0);
+            check.equals(eng2a.wear, 0);
 
             range(8).forEach(() => battle.advanceToNextShip());
 
-            expect(equ1a.wear).toBe(0);
-            expect(equ1b.wear).toBe(0);
-            expect(equ2a.wear).toBe(0);
-            expect(eng2a.wear).toBe(0);
+            check.equals(equ1a.wear, 0);
+            check.equals(equ1b.wear, 0);
+            check.equals(equ2a.wear, 0);
+            check.equals(eng2a.wear, 0);
 
             battle.endBattle(null);
 
-            expect(equ1a.wear).toBe(3);
-            expect(equ1b.wear).toBe(3);
-            expect(equ2a.wear).toBe(3);
-            expect(eng2a.wear).toBe(3);
+            check.equals(equ1a.wear, 3);
+            check.equals(equ1b.wear, 3);
+            check.equals(equ2a.wear, 3);
+            check.equals(eng2a.wear, 3);
         });
 
-        it("handles a draw in end battle", function () {
+        test.case("handles a draw in end battle", check => {
             var fleet1 = new Fleet();
             var fleet2 = new Fleet();
 
@@ -205,7 +205,7 @@ module TK.SpaceTac {
             var battle = new Battle(fleet1, fleet2);
 
             battle.start();
-            expect(battle.ended).toBe(false);
+            check.equals(battle.ended, false);
 
             ship1.setDead();
             ship2.setDead();
@@ -214,13 +214,13 @@ module TK.SpaceTac {
             battle.log.clear();
             battle.advanceToNextShip();
 
-            expect(battle.ended).toBe(true);
-            expect(battle.log.events.length).toBe(1);
-            expect(battle.log.events[0].code).toBe("endbattle");
-            expect((<EndBattleEvent>battle.log.events[0]).outcome.winner).toBeNull();
+            check.equals(battle.ended, true);
+            check.equals(battle.log.events.length, 1);
+            check.equals(battle.log.events[0].code, "endbattle");
+            check.equals((<EndBattleEvent>battle.log.events[0]).outcome.winner, null);
         });
 
-        it("collects ships present in a circle", function () {
+        test.case("collects ships present in a circle", check => {
             var fleet1 = new Fleet();
             var ship1 = new Ship(fleet1, "F1S1");
             ship1.setArenaPosition(0, 0);
@@ -235,96 +235,96 @@ module TK.SpaceTac {
             battle.throwInitiative(new SkewedRandomGenerator([5, 4, 3, 2]));
 
             var result = battle.collectShipsInCircle(Target.newFromLocation(5, 8), 3);
-            expect(result).toEqual([ship2, ship3]);
+            check.equals(result, [ship2, ship3]);
         });
 
-        it("adds and remove drones", function () {
+        test.case("adds and remove drones", check => {
             let battle = new Battle();
             let ship = new Ship();
             let drone = new Drone(ship);
 
-            expect(battle.drones).toEqual([]);
-            expect(battle.log.events).toEqual([]);
+            check.equals(battle.drones, []);
+            check.equals(battle.log.events, []);
 
             battle.addDrone(drone);
 
-            expect(battle.drones).toEqual([drone]);
-            expect(battle.log.events).toEqual([new DroneDeployedEvent(drone)]);
+            check.equals(battle.drones, [drone]);
+            check.equals(battle.log.events, [new DroneDeployedEvent(drone)]);
 
             battle.addDrone(drone);
 
-            expect(battle.drones).toEqual([drone]);
-            expect(battle.log.events).toEqual([new DroneDeployedEvent(drone)]);
+            check.equals(battle.drones, [drone]);
+            check.equals(battle.log.events, [new DroneDeployedEvent(drone)]);
 
             battle.removeDrone(drone);
 
-            expect(battle.drones).toEqual([]);
-            expect(battle.log.events).toEqual([new DroneDeployedEvent(drone), new DroneDestroyedEvent(drone)]);
+            check.equals(battle.drones, []);
+            check.equals(battle.log.events, [new DroneDeployedEvent(drone), new DroneDestroyedEvent(drone)]);
 
             battle.removeDrone(drone);
 
-            expect(battle.drones).toEqual([]);
-            expect(battle.log.events).toEqual([new DroneDeployedEvent(drone), new DroneDestroyedEvent(drone)]);
+            check.equals(battle.drones, []);
+            check.equals(battle.log.events, [new DroneDeployedEvent(drone), new DroneDestroyedEvent(drone)]);
 
             // check initial log fill
             battle.drones = [drone];
             let expected = new DroneDeployedEvent(drone);
             expected.initial = true;
-            expect(battle.getBootstrapEvents()).toEqual([expected]);
+            check.equals(battle.getBootstrapEvents(), [expected]);
         });
 
-        it("checks if a player is able to play", function () {
+        test.case("checks if a player is able to play", check => {
             let battle = new Battle();
             let player = new Player();
 
-            expect(battle.canPlay(player)).toBe(false);
+            check.equals(battle.canPlay(player), false);
 
             let ship = new Ship();
             TestTools.setShipPlaying(battle, ship);
 
-            expect(battle.canPlay(player)).toBe(false);
+            check.equals(battle.canPlay(player), false);
 
             ship.fleet.player = player;
 
-            expect(battle.canPlay(player)).toBe(true);
+            check.equals(battle.canPlay(player), true);
         });
 
-        it("gets the number of turns before a specific ship plays", function () {
+        test.case("gets the number of turns before a specific ship plays", check => {
             let battle = new Battle();
             spyOn(battle, "checkEndBattle").and.returnValue(false);
             battle.play_order = [new Ship(), new Ship(), new Ship()];
             battle.advanceToNextShip();
 
-            expect(battle.playing_ship).toBe(battle.play_order[0]);
-            expect(battle.getPlayOrder(battle.play_order[0])).toBe(0);
-            expect(battle.getPlayOrder(battle.play_order[1])).toBe(1);
-            expect(battle.getPlayOrder(battle.play_order[2])).toBe(2);
+            check.same(battle.playing_ship, battle.play_order[0]);
+            check.equals(battle.getPlayOrder(battle.play_order[0]), 0);
+            check.equals(battle.getPlayOrder(battle.play_order[1]), 1);
+            check.equals(battle.getPlayOrder(battle.play_order[2]), 2);
 
             battle.advanceToNextShip();
 
-            expect(battle.playing_ship).toBe(battle.play_order[1]);
-            expect(battle.getPlayOrder(battle.play_order[0])).toBe(2);
-            expect(battle.getPlayOrder(battle.play_order[1])).toBe(0);
-            expect(battle.getPlayOrder(battle.play_order[2])).toBe(1);
+            check.same(battle.playing_ship, battle.play_order[1]);
+            check.equals(battle.getPlayOrder(battle.play_order[0]), 2);
+            check.equals(battle.getPlayOrder(battle.play_order[1]), 0);
+            check.equals(battle.getPlayOrder(battle.play_order[2]), 1);
 
             battle.advanceToNextShip();
 
-            expect(battle.getPlayOrder(battle.play_order[0])).toBe(1);
-            expect(battle.getPlayOrder(battle.play_order[1])).toBe(2);
-            expect(battle.getPlayOrder(battle.play_order[2])).toBe(0);
+            check.equals(battle.getPlayOrder(battle.play_order[0]), 1);
+            check.equals(battle.getPlayOrder(battle.play_order[1]), 2);
+            check.equals(battle.getPlayOrder(battle.play_order[2]), 0);
 
             battle.advanceToNextShip();
 
-            expect(battle.getPlayOrder(battle.play_order[0])).toBe(0);
-            expect(battle.getPlayOrder(battle.play_order[1])).toBe(1);
-            expect(battle.getPlayOrder(battle.play_order[2])).toBe(2);
+            check.equals(battle.getPlayOrder(battle.play_order[0]), 0);
+            check.equals(battle.getPlayOrder(battle.play_order[1]), 1);
+            check.equals(battle.getPlayOrder(battle.play_order[2]), 2);
         });
 
-        it("lists area effects", function () {
+        test.case("lists area effects", check => {
             let battle = new Battle();
             let ship = battle.fleets[0].addShip();
 
-            expect(imaterialize(battle.iAreaEffects(100, 50))).toEqual([]);
+            check.equals(imaterialize(battle.iAreaEffects(100, 50)), []);
 
             let drone1 = new Drone(ship);
             drone1.x = 120;
@@ -339,7 +339,7 @@ module TK.SpaceTac {
             drone2.effects = [new DamageEffect(14)];
             battle.addDrone(drone2);
 
-            expect(imaterialize(battle.iAreaEffects(100, 50))).toEqual([
+            check.equals(imaterialize(battle.iAreaEffects(100, 50)), [
                 new DamageEffect(12)
             ]);
 
@@ -353,12 +353,12 @@ module TK.SpaceTac {
             eq3.action = new ToggleAction(eq3, 0, 100, [new AttributeEffect("maneuvrability", 3)]);
             (<ToggleAction>eq3.action).activated = true;
 
-            expect(imaterialize(battle.iAreaEffects(100, 50))).toEqual([
+            check.equals(imaterialize(battle.iAreaEffects(100, 50)), [
                 new DamageEffect(12), new AttributeEffect("maneuvrability", 1)
             ]);
         });
 
-        it("is serializable", function () {
+        test.case("is serializable", check => {
             let battle = Battle.newQuickRandom();
             battle.ai_playing = true;
 
@@ -367,9 +367,9 @@ module TK.SpaceTac {
 
             let loaded = serializer.unserialize(data);
 
-            expect(loaded.ai_playing).toBe(false);
+            check.equals(loaded.ai_playing, false);
             battle.ai_playing = false;
-            expect(loaded).toEqual(battle);
+            check.equals(loaded, battle);
         });
     });
 }

src/core/BattleCheats.spec.ts

@@ -1,34 +1,34 @@
 module TK.SpaceTac.Specs {
-    describe("BattleCheats", function () {
-        it("wins a battle", function () {
+    testing("BattleCheats", test => {
+        test.case("wins a battle", check => {
             let battle = Battle.newQuickRandom();
 
             battle.cheats.win();
-            expect(battle.ended).toBe(true, "ended");
-            expect(battle.outcome.winner).toBe(battle.fleets[0], "winner");
-            expect(battle.log.events.filter(event => event instanceof DeathEvent).map(event => event.ship)).toEqual(battle.fleets[1].ships, "all mark dead");
-            expect(any(battle.fleets[1].ships, ship => !ship.alive)).toBe(false, "all restored");
+            check.same(battle.ended, true, "ended");
+            check.same(battle.outcome.winner, battle.fleets[0], "winner");
+            check.equals(battle.log.events.filter(event => event instanceof DeathEvent).map(event => event.ship), battle.fleets[1].ships, "all mark dead");
+            check.same(any(battle.fleets[1].ships, ship => !ship.alive), false, "all restored");
         })
 
-        it("loses a battle", function () {
+        test.case("loses a battle", check => {
             let battle = Battle.newQuickRandom();
 
             battle.cheats.lose();
-            expect(battle.ended).toBe(true, "ended");
-            expect(battle.outcome.winner).toBe(battle.fleets[1], "winner");
-            expect(battle.log.events.filter(event => event instanceof DeathEvent).map(event => event.ship)).toEqual(battle.fleets[0].ships, "all mark dead");
-            expect(any(battle.fleets[0].ships, ship => !ship.alive)).toBe(false, "all restored");
+            check.same(battle.ended, true, "ended");
+            check.same(battle.outcome.winner, battle.fleets[1], "winner");
+            check.equals(battle.log.events.filter(event => event instanceof DeathEvent).map(event => event.ship), battle.fleets[0].ships, "all mark dead");
+            check.same(any(battle.fleets[0].ships, ship => !ship.alive), false, "all restored");
         })
 
-        it("adds an equipment", function () {
+        test.case("adds an equipment", check => {
             let battle = new Battle();
             let ship = new Ship();
             TestTools.setShipPlaying(battle, ship);
             ship.upgradeSkill("skill_materials");
 
-            expect(ship.listEquipment()).toEqual([]);
+            check.equals(ship.listEquipment(), []);
             battle.cheats.equip("Iron Hull");
-            expect(ship.listEquipment()).toEqual([<any>jasmine.objectContaining({ name: "Iron Hull", level: 1 })]);
+            check.equals(ship.listEquipment(), [<any>jasmine.objectContaining({ name: "Iron Hull", level: 1 })]);
         })
     })
 }

src/core/BattleLog.spec.ts

@@ -1,46 +1,47 @@
 /// <reference path="events/BaseBattleEvent.ts"/>
 
 module TK.SpaceTac {
-    // Check a single game log event
-    function checkEvent(got: BaseBattleEvent, ship: Ship, code: string,
-        target_ship: Ship | null = null, target_x: number | null = null, target_y: number | null = null): void {
-        if (target_ship) {
-            if (target_x === null) {
-                target_x = target_ship.arena_x;
+    testing("BattleLog", test => {
+        // Check a single game log event
+        function checkEvent(got: BaseBattleEvent, ship: Ship, code: string,
+            target_ship: Ship | null = null, target_x: number | null = null, target_y: number | null = null): void {
+            if (target_ship) {
+                if (target_x === null) {
+                    target_x = target_ship.arena_x;
+                }
+                if (target_y === null) {
+                    target_y = target_ship.arena_y;
+                }
             }
-            if (target_y === null) {
-                target_y = target_ship.arena_y;
+
+            let check = test.check;
+            check.same(got.ship, ship);
+            check.equals(got.code, code);
+            if (got.target) {
+                check.same(got.target.ship, target_ship);
+                if (target_x === null) {
+                    check.equals(got.target.x, null);
+                } else {
+                    check.nears(got.target.x, target_x);
+                }
+                if (target_y === null) {
+                    check.equals(got.target.y, null);
+                } else {
+                    check.nears(got.target.y, target_y);
+                }
+            } else if (target_ship || target_x || target_y) {
+                check.fail("Got no target");
             }
         }
 
-        expect(got.ship).toBe(ship);
-        expect(got.code).toEqual(code);
-        if (got.target) {
-            expect(got.target.ship).toBe(target_ship);
-            if (target_x === null) {
-                expect(got.target.x).toBeNull();
-            } else {
-                expect(got.target.x).toBeCloseTo(target_x, 0.000001);
+        // Fake event
+        class FakeEvent extends BaseBattleEvent {
+            constructor() {
+                super("fake", new Ship());
             }
-            if (target_y === null) {
-                expect(got.target.y).toBeNull();
-            } else {
-                expect(got.target.y).toBeCloseTo(target_y, 0.000001);
-            }
-        } else if (target_ship || target_x || target_y) {
-            fail("Got no target");
         }
-    }
 
-    // Fake event
-    class FakeEvent extends BaseBattleEvent {
-        constructor() {
-            super("fake", new Ship());
-        }
-    }
-
-    describe("BattleLog", function () {
-        it("forwards events to subscribers, until unsubscribe", function () {
+        test.case("forwards events to subscribers, until unsubscribe", check => {
             var log = new BattleLog();
             var received: BaseBattleEvent[] = [];
             var fake = new FakeEvent();
@@ -50,33 +51,33 @@ module TK.SpaceTac {
             });
 
             log.add(fake);
-            expect(received).toEqual([fake]);
+            check.equals(received, [fake]);
 
             log.add(fake);
-            expect(received).toEqual([fake, fake]);
+            check.equals(received, [fake, fake]);
 
             log.unsubscribe(sub);
             log.add(fake);
-            expect(received).toEqual([fake, fake]);
+            check.equals(received, [fake, fake]);
         });
 
-        it("logs ship change events", function () {
+        test.case("logs ship change events", check => {
             var battle = Battle.newQuickRandom();
             battle.log.clear();
             battle.log.addFilter("value");
-            expect(battle.log.events.length).toBe(0);
+            check.equals(battle.log.events.length, 0);
 
             battle.advanceToNextShip();
-            expect(battle.log.events.length).toBe(1);
+            check.equals(battle.log.events.length, 1);
             checkEvent(battle.log.events[0], battle.play_order[0], "ship_change", battle.play_order[1]);
         });
 
-        it("can receive simulated initial state events", function () {
+        test.case("can receive simulated initial state events", check => {
             let battle = Battle.newQuickRandom(true, 1, 4);
             let playing = nn(battle.playing_ship);
 
             let result = battle.getBootstrapEvents();
-            expect(result.length).toBe(17);
+            check.equals(result.length, 17);
             for (var i = 0; i < 8; i++) {
                 checkEvent(result[i], battle.play_order[i], "move", null,
                     battle.play_order[i].arena_x, battle.play_order[i].arena_y);
@@ -87,16 +88,16 @@ module TK.SpaceTac {
             checkEvent(result[16], playing, "ship_change", playing);
         });
 
-        it("stop accepting events once the battle is ended", function () {
+        test.case("stop accepting events once the battle is ended", check => {
             let log = new BattleLog();
 
             log.add(new ValueChangeEvent(new Ship(), new ShipValue("test"), 1));
             log.add(new EndBattleEvent(new BattleOutcome(null)));
             log.add(new ShipChangeEvent(new Ship(), new Ship()));
 
-            expect(log.events.length).toBe(2);
-            expect(log.events[0] instanceof ValueChangeEvent).toBe(true);
-            expect(log.events[1] instanceof EndBattleEvent).toBe(true);
+            check.equals(log.events.length, 2);
+            check.equals(log.events[0] instanceof ValueChangeEvent, true);
+            check.equals(log.events[1] instanceof EndBattleEvent, true);
         });
     });
 }

src/core/BattleOutcome.spec.ts

@@ -1,6 +1,6 @@
 module TK.SpaceTac.Specs {
-    describe("BattleOutcome", () => {
-        it("generates loot from defeated ships", () => {
+    testing("BattleOutcome", test => {
+        test.case("generates loot from defeated ships", check => {
             var fleet1 = new Fleet();
             fleet1.addShip(new Ship());
             var fleet2 = new Fleet();
@@ -44,19 +44,19 @@ module TK.SpaceTac.Specs {
 
             outcome.createLoot(battle, random);
 
-            expect(outcome.loot.length).toBe(3);
-            expect(outcome.loot[0].name).toBe("0a");
-            expect(outcome.loot[1].name).toBe("Nuclear Reactor");
-            expect(outcome.loot[1].level).toBe(4);
-            expect(outcome.loot[1].quality).toBe(EquipmentQuality.COMMON);
-            expect(outcome.loot[1].requirements).toEqual({ "skill_photons": 7 });
-            expect(outcome.loot[2].name).toBe("Nuclear Reactor");
-            expect(outcome.loot[2].level).toBe(6);
-            expect(outcome.loot[2].quality).toBe(EquipmentQuality.PREMIUM);
-            expect(outcome.loot[2].requirements).toEqual({ "skill_photons": 9 });
+            check.equals(outcome.loot.length, 3);
+            check.equals(outcome.loot[0].name, "0a");
+            check.equals(outcome.loot[1].name, "Nuclear Reactor");
+            check.equals(outcome.loot[1].level, 4);
+            check.same(outcome.loot[1].quality, EquipmentQuality.COMMON);
+            check.equals(outcome.loot[1].requirements, { "skill_photons": 7 });
+            check.equals(outcome.loot[2].name, "Nuclear Reactor");
+            check.equals(outcome.loot[2].level, 6);
+            check.same(outcome.loot[2].quality, EquipmentQuality.PREMIUM);
+            check.equals(outcome.loot[2].requirements, { "skill_photons": 9 });
         });
 
-        it("grants experience", function () {
+        test.case("grants experience", check => {
             let fleet1 = new Fleet();
             let ship1a = fleet1.addShip(new Ship());
             ship1a.level.forceLevel(3);
@@ -67,26 +67,26 @@ module TK.SpaceTac.Specs {
             ship2a.level.forceLevel(6);
             let ship2b = fleet2.addShip(new Ship());
             ship2b.level.forceLevel(8);
-            expect(ship1a.level.getExperience()).toEqual(300);
-            expect(ship1b.level.getExperience()).toEqual(600);
-            expect(ship2a.level.getExperience()).toEqual(1500);
-            expect(ship2b.level.getExperience()).toEqual(2800);
+            check.equals(ship1a.level.getExperience(), 300);
+            check.equals(ship1b.level.getExperience(), 600);
+            check.equals(ship2a.level.getExperience(), 1500);
+            check.equals(ship2b.level.getExperience(), 2800);
 
             // draw
             let outcome = new BattleOutcome(null);
             outcome.grantExperience([fleet1, fleet2]);
-            expect(ship1a.level.getExperience()).toEqual(345);
-            expect(ship1b.level.getExperience()).toEqual(645);
-            expect(ship2a.level.getExperience()).toEqual(1511);
-            expect(ship2b.level.getExperience()).toEqual(2811);
+            check.equals(ship1a.level.getExperience(), 345);
+            check.equals(ship1b.level.getExperience(), 645);
+            check.equals(ship2a.level.getExperience(), 1511);
+            check.equals(ship2b.level.getExperience(), 2811);
 
             // win/lose
             outcome = new BattleOutcome(fleet1);
             outcome.grantExperience([fleet1, fleet2]);
-            expect(ship1a.level.getExperience()).toEqual(480);
-            expect(ship1b.level.getExperience()).toEqual(780);
-            expect(ship2a.level.getExperience()).toEqual(1518);
-            expect(ship2b.level.getExperience()).toEqual(2818);
+            check.equals(ship1a.level.getExperience(), 480);
+            check.equals(ship1b.level.getExperience(), 780);
+            check.equals(ship2a.level.getExperience(), 1518);
+            check.equals(ship2b.level.getExperience(), 2818);
         });
     });
 }

src/core/BattleStats.spec.ts

@@ -1,95 +1,95 @@
 module TK.SpaceTac.Specs {
-    describe("BattleStats", function () {
-        it("collects stats", function () {
+    testing("BattleStats", test => {
+        test.case("collects stats", check => {
             let stats = new BattleStats();
-            expect(stats.stats).toEqual({});
+            check.equals(stats.stats, {});
 
             stats.addStat("Test", 1, true);
-            expect(stats.stats).toEqual({ Test: [1, 0] });
+            check.equals(stats.stats, { Test: [1, 0] });
 
             stats.addStat("Test", 1, true);
-            expect(stats.stats).toEqual({ Test: [2, 0] });
+            check.equals(stats.stats, { Test: [2, 0] });
 
             stats.addStat("Test", 1, false);
-            expect(stats.stats).toEqual({ Test: [2, 1] });
+            check.equals(stats.stats, { Test: [2, 1] });
 
             stats.addStat("Other Test", 10, true);
-            expect(stats.stats).toEqual({ Test: [2, 1], "Other Test": [10, 0] });
+            check.equals(stats.stats, { Test: [2, 1], "Other Test": [10, 0] });
         })
 
-        it("collects damage dealt", function () {
+        test.case("collects damage dealt", check => {
             let stats = new BattleStats();
             let battle = new Battle();
             let attacker = battle.fleets[0].addShip();
             let defender = battle.fleets[1].addShip();
             stats.processLog(battle.log, battle.fleets[0]);
-            expect(stats.stats).toEqual({});
+            check.equals(stats.stats, {});
 
             battle.log.add(new DamageEvent(attacker, 10, 12));
             stats.processLog(battle.log, battle.fleets[0], true);
-            expect(stats.stats).toEqual({ "Damage dealt": [0, 22] });
+            check.equals(stats.stats, { "Damage dealt": [0, 22] });
 
             battle.log.add(new DamageEvent(defender, 40, 0));
             stats.processLog(battle.log, battle.fleets[0], true);
-            expect(stats.stats).toEqual({ "Damage dealt": [40, 22] });
+            check.equals(stats.stats, { "Damage dealt": [40, 22] });
 
             battle.log.add(new DamageEvent(attacker, 5, 4));
             stats.processLog(battle.log, battle.fleets[0], true);
-            expect(stats.stats).toEqual({ "Damage dealt": [40, 31] });
+            check.equals(stats.stats, { "Damage dealt": [40, 31] });
         })
 
-        it("collects distance moved", function () {
+        test.case("collects distance moved", check => {
             let stats = new BattleStats();
             let battle = new Battle();
             let attacker = battle.fleets[0].addShip();
             let defender = battle.fleets[1].addShip();
             stats.processLog(battle.log, battle.fleets[0]);
-            expect(stats.stats).toEqual({});
+            check.equals(stats.stats, {});
 
             battle.log.add(new MoveEvent(attacker, new ArenaLocationAngle(0, 0), new ArenaLocationAngle(10, 0)));
             stats.processLog(battle.log, battle.fleets[0], true);
-            expect(stats.stats).toEqual({ "Move distance (km)": [10, 0] });
+            check.equals(stats.stats, { "Move distance (km)": [10, 0] });
 
             battle.log.add(new MoveEvent(defender, new ArenaLocationAngle(10, 5), new ArenaLocationAngle(10, 63)));
             stats.processLog(battle.log, battle.fleets[0], true);
-            expect(stats.stats).toEqual({ "Move distance (km)": [10, 58] });
+            check.equals(stats.stats, { "Move distance (km)": [10, 58] });
         })
 
-        it("collects deployed drones", function () {
+        test.case("collects deployed drones", check => {
             let stats = new BattleStats();
             let battle = new Battle();
             let attacker = battle.fleets[0].addShip();
             let defender = battle.fleets[1].addShip();
             stats.processLog(battle.log, battle.fleets[0]);
-            expect(stats.stats).toEqual({});
+            check.equals(stats.stats, {});
 
             battle.log.add(new DroneDeployedEvent(new Drone(attacker)));
             stats.processLog(battle.log, battle.fleets[0], true);
-            expect(stats.stats).toEqual({ "Drones deployed": [1, 0] });
+            check.equals(stats.stats, { "Drones deployed": [1, 0] });
 
             battle.log.add(new DroneDeployedEvent(new Drone(defender)));
             stats.processLog(battle.log, battle.fleets[0], true);
-            expect(stats.stats).toEqual({ "Drones deployed": [1, 1] });
+            check.equals(stats.stats, { "Drones deployed": [1, 1] });
         })
 
-        it("collects power usage", function () {
+        test.case("collects power usage", check => {
             let stats = new BattleStats();
             let battle = new Battle();
             let attacker = battle.fleets[0].addShip();
             let defender = battle.fleets[1].addShip();
             stats.processLog(battle.log, battle.fleets[0]);
-            expect(stats.stats).toEqual({});
+            check.equals(stats.stats, {});
 
             battle.log.add(new ActionAppliedEvent(attacker, new BaseAction("nop", "nop"), null, 4));
             stats.processLog(battle.log, battle.fleets[0], true);
-            expect(stats.stats).toEqual({ "Power used": [4, 0] });
+            check.equals(stats.stats, { "Power used": [4, 0] });
 
             battle.log.add(new ActionAppliedEvent(defender, new BaseAction("nop", "nop"), null, 2));
             stats.processLog(battle.log, battle.fleets[0], true);
-            expect(stats.stats).toEqual({ "Power used": [4, 2] });
+            check.equals(stats.stats, { "Power used": [4, 2] });
         })
 
-        it("evaluates equipment depreciation", function () {
+        test.case("evaluates equipment depreciation", check => {
             let stats = new BattleStats();
             let battle = new Battle();
             let attacker = battle.fleets[0].addShip();
@@ -101,13 +101,13 @@ module TK.SpaceTac.Specs {
             equ2.price = 1100;
 
             stats.onBattleStart(attacker.fleet, defender.fleet);
-            expect(stats.stats).toEqual({ "Equipment wear (zotys)": [1000, 1100] });
+            check.equals(stats.stats, { "Equipment wear (zotys)": [1000, 1100] });
 
             equ1.price = 500;
             equ2.price = 800;
 
             stats.onBattleEnd(attacker.fleet, defender.fleet);
-            expect(stats.stats).toEqual({ "Equipment wear (zotys)": [500, 300] });
+            check.equals(stats.stats, { "Equipment wear (zotys)": [500, 300] });
         })
     })
 }

src/core/Cooldown.spec.ts

@@ -1,38 +1,38 @@
 module TK.SpaceTac.Specs {
-    describe("Cooldown", function () {
-        it("applies overheat and cooldown", function () {
+    testing("Cooldown", test => {
+        test.case("applies overheat and cooldown", check => {
             let cooldown = new Cooldown();
-            expect(cooldown.canUse()).toBe(true);
+            check.equals(cooldown.canUse(), true);
 
             cooldown.use();
-            expect(cooldown.canUse()).toBe(true);
+            check.equals(cooldown.canUse(), true);
 
             cooldown.configure(2, 3);
-            expect(cooldown.canUse()).toBe(true);
+            check.equals(cooldown.canUse(), true);
 
             cooldown.use();
-            expect(cooldown.canUse()).toBe(true);
+            check.equals(cooldown.canUse(), true);
 
             cooldown.use();
-            expect(cooldown.canUse()).toBe(false);
+            check.equals(cooldown.canUse(), false);
 
             cooldown.cool();
-            expect(cooldown.canUse()).toBe(false);
+            check.equals(cooldown.canUse(), false);
 
             cooldown.cool();
-            expect(cooldown.canUse()).toBe(false);
+            check.equals(cooldown.canUse(), false);
 
             cooldown.cool();
-            expect(cooldown.canUse()).toBe(true);
+            check.equals(cooldown.canUse(), true);
 
             cooldown.configure(1, 0);
-            expect(cooldown.canUse()).toBe(true);
+            check.equals(cooldown.canUse(), true);
 
             cooldown.use();
-            expect(cooldown.canUse()).toBe(false);
+            check.equals(cooldown.canUse(), false);
 
             cooldown.cool();
-            expect(cooldown.canUse()).toBe(true);
+            check.equals(cooldown.canUse(), true);
         });
     });
 }

src/core/Drone.spec.ts

@@ -33,8 +33,8 @@ module TK.SpaceTac {
         return [drone, effect];
     }
 
-    describe("Drone", function () {
-        it("applies effects on all ships inside the radius", function () {
+    testing("Drone", test => {
+        test.case("applies effects on all ships inside the radius", check => {
             let battle = new Battle();
             let ship1 = new Ship(battle.fleets[0], "ship1");
             ship1.setArenaPosition(0, 0);
@@ -47,13 +47,13 @@ module TK.SpaceTac {
             ship4.setDead();
             let [drone, effect] = newTestDrone(2, 2, 8, ship1);
 
-            expect(effect.getApplyCalls()).toEqual([]);
+            check.equals(effect.getApplyCalls(), []);
 
             drone.activate();
-            expect(effect.getApplyCalls()).toEqual([ship1, ship2]);
+            check.equals(effect.getApplyCalls(), [ship1, ship2]);
         });
 
-        it("signals the need for destruction after its lifetime", function () {
+        test.case("signals the need for destruction after its lifetime", check => {
             let battle = new Battle();
             let owner = new Ship(battle.fleets[0]);
             let [drone, effect] = newTestDrone(0, 0, 5, owner);
@@ -69,7 +69,7 @@ module TK.SpaceTac {
             expect(removeDrone).toHaveBeenCalledWith(drone, true);
         });
 
-        it("logs each activation", function () {
+        test.case("logs each activation", check => {
             let battle = new Battle();
             let ship = new Ship();
             ship.fleet.setBattle(battle);
@@ -80,23 +80,23 @@ module TK.SpaceTac {
             drone.apply([]);
             drone.apply([other]);
 
-            expect(battle.log.events).toEqual([
+            check.equals(battle.log.events, [
                 new DroneAppliedEvent(drone, [ship, other]),
                 new DroneAppliedEvent(drone, [other])
             ]);
         });
 
-        it("builds a textual description", function () {
+        test.case("builds a textual description", check => {
             let drone = new Drone(new Ship());
             drone.duration = 1;
-            expect(drone.getDescription()).toEqual("For 1 activation:\n• do nothing");
+            check.equals(drone.getDescription(), "For 1 activation:\n• do nothing");
 
             drone.duration = 3;
             drone.effects = [
                 new DamageEffect(5),
                 new AttributeEffect("skill_quantum", 1)
             ]
-            expect(drone.getDescription()).toEqual("For 3 activations:\n• do 5 damage\n• quantum skill +1");
+            check.equals(drone.getDescription(), "For 3 activations:\n• do 5 damage\n• quantum skill +1");
         });
     });
 }

src/core/Equipment.spec.ts

@@ -1,102 +1,102 @@
 module TK.SpaceTac.Specs {
-    describe("Equipment", () => {
-        it("generates a full name", function () {
+    testing("Equipment", test => {
+        test.case("generates a full name", check => {
             let equipment = new Equipment(SlotType.Weapon, "rayofdeath");
-            expect(equipment.getFullName()).toEqual("rayofdeath Mk1");
+            check.equals(equipment.getFullName(), "rayofdeath Mk1");
 
             equipment.name = "Ray of Death";
-            expect(equipment.getFullName()).toEqual("Ray of Death Mk1");
+            check.equals(equipment.getFullName(), "Ray of Death Mk1");
 
             equipment.quality = EquipmentQuality.LEGENDARY;
-            expect(equipment.getFullName()).toEqual("Legendary Ray of Death Mk1");
+            check.equals(equipment.getFullName(), "Legendary Ray of Death Mk1");
         });
 
-        it("checks capabilities requirements", function () {
+        test.case("checks capabilities requirements", check => {
             var equipment = new Equipment();
             var ship = new Ship();
 
-            expect(equipment.canBeEquipped(ship.attributes)).toBe(true);
+            check.equals(equipment.canBeEquipped(ship.attributes), true);
 
             equipment.requirements["skill_time"] = 2;
 
-            expect(equipment.canBeEquipped(ship.attributes)).toBe(false);
+            check.equals(equipment.canBeEquipped(ship.attributes), false);
 
             ship.attributes.skill_time.set(1);
 
-            expect(equipment.canBeEquipped(ship.attributes)).toBe(false);
+            check.equals(equipment.canBeEquipped(ship.attributes), false);
 
             ship.attributes.skill_time.set(2);
 
-            expect(equipment.canBeEquipped(ship.attributes)).toBe(true);
+            check.equals(equipment.canBeEquipped(ship.attributes), true);
 
             ship.attributes.skill_time.set(3);
 
-            expect(equipment.canBeEquipped(ship.attributes)).toBe(true);
+            check.equals(equipment.canBeEquipped(ship.attributes), true);
 
             // Second requirement
             equipment.requirements["skill_materials"] = 3;
 
-            expect(equipment.canBeEquipped(ship.attributes)).toBe(false);
+            check.equals(equipment.canBeEquipped(ship.attributes), false);
 
             ship.attributes.skill_materials.set(4);
 
-            expect(equipment.canBeEquipped(ship.attributes)).toBe(true);
+            check.equals(equipment.canBeEquipped(ship.attributes), true);
         });
 
-        it("generates a description of the effects", function () {
+        test.case("generates a description of the effects", check => {
             let equipment = new Equipment();
-            expect(equipment.getEffectsDescription()).toEqual("does nothing");
+            check.equals(equipment.getEffectsDescription(), "does nothing");
 
             let action = new TriggerAction(equipment, [new DamageEffect(50)], 1, 200, 0);
             equipment.action = action;
-            expect(equipment.getEffectsDescription()).toEqual("Fire (power usage 1, max range 200km):\n• do 50 damage on target");
+            check.equals(equipment.getEffectsDescription(), "Fire (power usage 1, max range 200km):\n• do 50 damage on target");
 
             action.blast = 20;
-            expect(equipment.getEffectsDescription()).toEqual("Fire (power usage 1, max range 200km):\n• do 50 damage in 20km radius");
+            check.equals(equipment.getEffectsDescription(), "Fire (power usage 1, max range 200km):\n• do 50 damage in 20km radius");
 
             action.blast = 0;
             action.effects.push(new StickyEffect(new AttributeLimitEffect("shield_capacity", 200), 3));
-            expect(equipment.getEffectsDescription()).toEqual("Fire (power usage 1, max range 200km):\n• do 50 damage on target\n• limit shield capacity to 200 for 3 turns on target");
+            check.equals(equipment.getEffectsDescription(), "Fire (power usage 1, max range 200km):\n• do 50 damage on target\n• limit shield capacity to 200 for 3 turns on target");
         });
 
-        it("gets a minimal level, based on skills requirements", function () {
+        test.case("gets a minimal level, based on skills requirements", check => {
             let equipment = new Equipment();
-            expect(equipment.getMinimumLevel()).toBe(1);
+            check.equals(equipment.getMinimumLevel(), 1);
 
             equipment.requirements["skill_quantum"] = 10;
-            expect(equipment.getMinimumLevel()).toBe(1);
+            check.equals(equipment.getMinimumLevel(), 1);
 
             equipment.requirements["skill_time"] = 1;
-            expect(equipment.getMinimumLevel()).toBe(2);
+            check.equals(equipment.getMinimumLevel(), 2);
 
             equipment.requirements["skill_gravity"] = 2;
-            expect(equipment.getMinimumLevel()).toBe(2);
+            check.equals(equipment.getMinimumLevel(), 2);
 
             equipment.requirements["skill_antimatter"] = 4;
-            expect(equipment.getMinimumLevel()).toBe(3);
+            check.equals(equipment.getMinimumLevel(), 3);
         });
 
-        it("weighs the price, taking wear into account", function () {
+        test.case("weighs the price, taking wear into account", check => {
             let equipment = new Equipment();
-            expect(equipment.getPrice()).toBe(0);
+            check.equals(equipment.getPrice(), 0);
 
             equipment.price = 100;
-            expect(equipment.getPrice()).toBe(100);
+            check.equals(equipment.getPrice(), 100);
 
             equipment.addWear(1);
-            expect(equipment.getPrice()).toBe(99);
+            check.equals(equipment.getPrice(), 99);
 
             equipment.addWear(10);
-            expect(equipment.getPrice()).toBe(90);
+            check.equals(equipment.getPrice(), 90);
 
             equipment.addWear(89);
-            expect(equipment.getPrice()).toBe(50);
+            check.equals(equipment.getPrice(), 50);
 
             equipment.addWear(400);
-            expect(equipment.getPrice()).toBe(16);
+            check.equals(equipment.getPrice(), 16);
         });
 
-        it("builds a full textual description", function () {
+        test.case("builds a full textual description", check => {
             let equipment = new Equipment();
             equipment.name = "Super Equipment";
             equipment.requirements["skill_gravity"] = 2;
@@ -104,7 +104,7 @@ module TK.SpaceTac.Specs {
             equipment.wear = 50;
 
             let result = equipment.getFullDescription();
-            expect(result).toEqual("Second hand\n\nRequires:\n• gravity skill 2\n\nWhen equipped:\n• time skill +3");
+            check.equals(result, "Second hand\n\nRequires:\n• gravity skill 2\n\nWhen equipped:\n• time skill +3");
         });
     });
 }

src/core/ExclusionAreas.spec.ts

@@ -1,6 +1,6 @@
 module TK.SpaceTac.Specs {
-    describe("ExclusionAreas", function () {
-        it("constructs from a ship or battle", function () {
+    testing("ExclusionAreas", test => {
+        test.case("constructs from a ship or battle", check => {
             let battle = new Battle();
             battle.border = 17;
             battle.ship_separation = 31;
@@ -10,34 +10,34 @@ module TK.SpaceTac.Specs {
             ship2.setArenaPosition(43, 89);
 
             let exclusion = ExclusionAreas.fromBattle(battle);
-            expect(exclusion.hard_border).toEqual(17);
-            expect(exclusion.effective_obstacle).toEqual(31);
-            expect(exclusion.obstacles).toEqual([new ArenaLocationAngle(12, 5), new ArenaLocationAngle(43, 89)]);
+            check.equals(exclusion.hard_border, 17);
+            check.equals(exclusion.effective_obstacle, 31);
+            check.equals(exclusion.obstacles, [new ArenaLocationAngle(12, 5), new ArenaLocationAngle(43, 89)]);
 
             exclusion = ExclusionAreas.fromBattle(battle, [ship1], 120);
-            expect(exclusion.hard_border).toEqual(17);
-            expect(exclusion.effective_obstacle).toEqual(120);
-            expect(exclusion.obstacles).toEqual([new ArenaLocationAngle(43, 89)]);
+            check.equals(exclusion.hard_border, 17);
+            check.equals(exclusion.effective_obstacle, 120);
+            check.equals(exclusion.obstacles, [new ArenaLocationAngle(43, 89)]);
 
             exclusion = ExclusionAreas.fromBattle(battle, [ship2], 10);
-            expect(exclusion.hard_border).toEqual(17);
-            expect(exclusion.effective_obstacle).toEqual(31);
-            expect(exclusion.obstacles).toEqual([new ArenaLocationAngle(12, 5)]);
+            check.equals(exclusion.hard_border, 17);
+            check.equals(exclusion.effective_obstacle, 31);
+            check.equals(exclusion.obstacles, [new ArenaLocationAngle(12, 5)]);
 
             exclusion = ExclusionAreas.fromShip(ship1);
-            expect(exclusion.hard_border).toEqual(17);
-            expect(exclusion.effective_obstacle).toEqual(31);
-            expect(exclusion.obstacles).toEqual([new ArenaLocationAngle(43, 89)]);
+            check.equals(exclusion.hard_border, 17);
+            check.equals(exclusion.effective_obstacle, 31);
+            check.equals(exclusion.obstacles, [new ArenaLocationAngle(43, 89)]);
 
             exclusion = ExclusionAreas.fromShip(ship2, 99);
-            expect(exclusion.hard_border).toEqual(17);
-            expect(exclusion.effective_obstacle).toEqual(99);
-            expect(exclusion.obstacles).toEqual([new ArenaLocationAngle(12, 5)]);
+            check.equals(exclusion.hard_border, 17);
+            check.equals(exclusion.effective_obstacle, 99);
+            check.equals(exclusion.obstacles, [new ArenaLocationAngle(12, 5)]);
 
             exclusion = ExclusionAreas.fromShip(ship2, 10, false);
-            expect(exclusion.hard_border).toEqual(17);
-            expect(exclusion.effective_obstacle).toEqual(31);
-            expect(exclusion.obstacles).toEqual([new ArenaLocationAngle(12, 5), new ArenaLocationAngle(43, 89)]);
+            check.equals(exclusion.hard_border, 17);
+            check.equals(exclusion.effective_obstacle, 31);
+            check.equals(exclusion.obstacles, [new ArenaLocationAngle(12, 5), new ArenaLocationAngle(43, 89)]);
         })
     })
 }

src/core/Fleet.spec.ts

@@ -1,8 +1,8 @@
 module TK.SpaceTac {
-    describe("Fleet", function () {
-        it("get average level", function () {
+    testing("Fleet", test => {
+        test.case("get average level", check => {
             var fleet = new Fleet();
-            expect(fleet.getLevel()).toEqual(0);
+            check.equals(fleet.getLevel(), 0);
 
             fleet.addShip(new Ship());
             fleet.addShip(new Ship());
@@ -11,43 +11,43 @@ module TK.SpaceTac {
             fleet.ships[0].level.forceLevel(2);
             fleet.ships[1].level.forceLevel(4);
             fleet.ships[2].level.forceLevel(7);
-            expect(fleet.getLevel()).toEqual(4);
+            check.equals(fleet.getLevel(), 4);
         });
 
-        it("adds and removes ships", function () {
+        test.case("adds and removes ships", check => {
             let fleet1 = new Fleet();
             let fleet2 = new Fleet();
 
             let ship1 = fleet1.addShip();
-            expect(fleet1.ships).toEqual([ship1]);
-            expect(fleet2.ships).toEqual([]);
+            check.equals(fleet1.ships, [ship1]);
+            check.equals(fleet2.ships, []);
 
             let ship2 = new Ship();
-            expect(fleet1.ships).toEqual([ship1]);
-            expect(fleet2.ships).toEqual([]);
+            check.equals(fleet1.ships, [ship1]);
+            check.equals(fleet2.ships, []);
 
             fleet2.addShip(ship2);
-            expect(fleet1.ships).toEqual([ship1]);
-            expect(fleet2.ships).toEqual([ship2]);
+            check.equals(fleet1.ships, [ship1]);
+            check.equals(fleet2.ships, [ship2]);
 
             fleet1.addShip(ship2);
-            expect(fleet1.ships).toEqual([ship1, ship2]);
-            expect(fleet2.ships).toEqual([]);
+            check.equals(fleet1.ships, [ship1, ship2]);
+            check.equals(fleet2.ships, []);
 
             fleet1.removeShip(ship1, fleet2);
-            expect(fleet1.ships).toEqual([ship2]);
-            expect(fleet2.ships).toEqual([ship1]);
+            check.equals(fleet1.ships, [ship2]);
+            check.equals(fleet2.ships, [ship1]);
 
             fleet1.removeShip(ship1);
-            expect(fleet1.ships).toEqual([ship2]);
-            expect(fleet2.ships).toEqual([ship1]);
+            check.equals(fleet1.ships, [ship2]);
+            check.equals(fleet2.ships, [ship1]);
 
             fleet1.removeShip(ship2);
-            expect(fleet1.ships).toEqual([]);
-            expect(fleet2.ships).toEqual([ship1]);
+            check.equals(fleet1.ships, []);
+            check.equals(fleet2.ships, [ship1]);
         });
 
-        it("changes location, only using jumps to travel between systems", function () {
+        test.case("changes location, only using jumps to travel between systems", check => {
             let fleet = new Fleet();
             let system1 = new Star();
             let system2 = new Star();
@@ -58,87 +58,87 @@ module TK.SpaceTac {
             let other1 = new StarLocation(system1, StarLocationType.PLANET);
 
             let result = fleet.setLocation(other1);
-            expect(result).toBe(true);
-            expect(fleet.location).toBe(other1);
+            check.equals(result, true);
+            check.same(fleet.location, other1);
 
             result = fleet.setLocation(jump2);
-            expect(result).toBe(false);
-            expect(fleet.location).toBe(other1);
+            check.equals(result, false);
+            check.same(fleet.location, other1);
 
             result = fleet.setLocation(jump1);
-            expect(result).toBe(true);
-            expect(fleet.location).toBe(jump1);
+            check.equals(result, true);
+            check.same(fleet.location, jump1);
 
             result = fleet.setLocation(jump2);
-            expect(result).toBe(true);
-            expect(fleet.location).toBe(jump2);
+            check.equals(result, true);
+            check.same(fleet.location, jump2);
 
             result = fleet.setLocation(other1);
-            expect(result).toBe(false);
-            expect(fleet.location).toBe(jump2);
+            check.equals(result, false);
+            check.same(fleet.location, jump2);
 
             result = fleet.setLocation(jump1);
-            expect(result).toBe(true);
-            expect(fleet.location).toBe(jump1);
+            check.equals(result, true);
+            check.same(fleet.location, jump1);
         });
 
-        it("checks if a fleet is alive", function () {
+        test.case("checks if a fleet is alive", check => {
             let battle = new Battle();
             let fleet = battle.fleets[0];
-            expect(fleet.isAlive()).toBe(false);
+            check.equals(fleet.isAlive(), false);
 
             let ship1 = fleet.addShip();
-            expect(fleet.isAlive()).toBe(true);
+            check.equals(fleet.isAlive(), true);
 
             let ship2 = fleet.addShip();
-            expect(fleet.isAlive()).toBe(true);
+            check.equals(fleet.isAlive(), true);
 
             ship1.setDead();
-            expect(fleet.isAlive()).toBe(true);
+            check.equals(fleet.isAlive(), true);
 
             ship2.setDead();
-            expect(fleet.isAlive()).toBe(false);
+            check.equals(fleet.isAlive(), false);
 
             let ship3 = fleet.addShip();
-            expect(fleet.isAlive()).toBe(true);
+            check.equals(fleet.isAlive(), true);
 
             let ship4 = fleet.addShip();
             ship4.critical = true;
-            expect(fleet.isAlive()).toBe(true);
+            check.equals(fleet.isAlive(), true);
 
             ship4.setDead();
-            expect(fleet.isAlive()).toBe(false);
+            check.equals(fleet.isAlive(), false);
         });
 
-        it("adds cargo in first empty slot", function () {
+        test.case("adds cargo in first empty slot", check => {
             let fleet = new Fleet();
             let ship1 = fleet.addShip();
             ship1.cargo_space = 1;
             let ship2 = fleet.addShip();
             ship2.cargo_space = 2;
 
-            expect(ship1.cargo).toEqual([]);
-            expect(ship2.cargo).toEqual([]);
+            check.equals(ship1.cargo, []);
+            check.equals(ship2.cargo, []);
 
             let result = fleet.addCargo(new Equipment());
-            expect(result).toBe(true);
-            expect(ship1.cargo).toEqual([new Equipment()]);
-            expect(ship2.cargo).toEqual([]);
+            check.equals(result, true);
+            check.equals(ship1.cargo, [new Equipment()]);
+            check.equals(ship2.cargo, []);
 
             result = fleet.addCargo(new Equipment());
-            expect(result).toBe(true);
-            expect(ship1.cargo).toEqual([new Equipment()]);
-            expect(ship2.cargo).toEqual([new Equipment()]);
+            check.equals(result, true);
+            check.equals(ship1.cargo, [new Equipment()]);
+            check.equals(ship2.cargo, [new Equipment()]);
 
             result = fleet.addCargo(new Equipment());
-            expect(result).toBe(true);
-            expect(ship1.cargo).toEqual([new Equipment()]);
-            expect(ship2.cargo).toEqual([new Equipment(), new Equipment()]);
+            check.equals(result, true);
+            check.equals(ship1.cargo, [new Equipment()]);
+            check.equals(ship2.cargo, [new Equipment(), new Equipment()]);
 
             result = fleet.addCargo(new Equipment());
-            expect(result).toBe(false);
-            expect(ship1.cargo).toEqual([new Equipment()]);
-            expect(ship2.cargo).toEqual([new Equipment(), new Equipment()]);
+            check.equals(result, false);
+            check.equals(ship1.cargo, [new Equipment()]);
+            check.equals(ship2.cargo, [new Equipment(), new Equipment()]);
         });
     });
 }

src/core/GameSession.spec.ts

@@ -1,10 +1,10 @@
 module TK.SpaceTac.Specs {
-    describe("GameSession", () => {
+    testing("GameSession", test => {
         /**
          * Compare two sessions
          */
         function compare(session1: GameSession, session2: GameSession) {
-            expect(session1).toEqual(session2);
+            test.check.equals(session1, session2);
         }
 
         /**
@@ -17,7 +17,7 @@ module TK.SpaceTac.Specs {
             battle.endBattle(battle.fleets[0]);
         }
 
-        it("serializes to a string", function () {
+        test.case("serializes to a string", check => {
             var session = new GameSession();
             session.startQuickBattle();
 
@@ -36,65 +36,65 @@ module TK.SpaceTac.Specs {
             compare(loaded_session, session);
         });
 
-        it("applies battle outcome to bound player", function () {
+        test.case("applies battle outcome to bound player", check => {
             let session = new GameSession();
-            expect(session.getBattle()).toBeNull();
+            check.equals(session.getBattle(), null);
 
             // Victory case
             let location1 = new StarLocation();
             location1.encounter = new Fleet();
             session.player.fleet.setLocation(location1);
-            expect(session.getBattle()).not.toBeNull();
-            expect(location1.encounter).not.toBeNull();
+            check.notequals(session.getBattle(), null);
+            check.notequals(location1.encounter, null);
 
             let battle = nn(session.getBattle());
             battle.endBattle(session.player.fleet);
             let spyloot = spyOn(battle.outcome, "createLoot").and.stub();
             session.setBattleEnded();
-            expect(session.getBattle()).not.toBeNull();
-            expect(location1.encounter).toBeNull();
+            check.notequals(session.getBattle(), null);
+            check.equals(location1.encounter, null);
             expect(spyloot).toHaveBeenCalledTimes(1);
 
             // Defeat case
             let location2 = new StarLocation(location1.star);
             location2.encounter = new Fleet();
             session.player.fleet.setLocation(location2);
-            expect(session.getBattle()).not.toBeNull();
-            expect(location2.encounter).not.toBeNull();
+            check.notequals(session.getBattle(), null);
+            check.notequals(location2.encounter, null);
 
             battle = nn(session.getBattle());
             battle.endBattle(null);
             spyloot = spyOn(battle.outcome, "createLoot").and.stub();
             session.setBattleEnded();
-            expect(session.getBattle()).not.toBeNull();
-            expect(location2.encounter).not.toBeNull();
+            check.notequals(session.getBattle(), null);
+            check.notequals(location2.encounter, null);
             expect(spyloot).toHaveBeenCalledTimes(0);
         });
 
-        it("generates a new campaign", function () {
+        test.case("generates a new campaign", check => {
             let session = new GameSession();
 
             session.startNewGame(false);
-            expect(session.player).not.toBeNull();
-            expect(session.player.fleet.ships.length).toBe(0);
-            expect(session.player.fleet.credits).toBe(0);
-            expect(session.player.universe.stars.length).toBe(50);
-            expect(session.getBattle()).toBeNull();
-            expect(session.start_location.shop).toBeNull();
-            expect(session.start_location.encounter).toBeNull();
-            expect(session.start_location.encounter_gen).toBe(true);
+            check.notequals(session.player, null);
+            check.equals(session.player.fleet.ships.length, 0);
+            check.equals(session.player.fleet.credits, 0);
+            check.equals(session.player.universe.stars.length, 50);
+            check.equals(session.getBattle(), null);
+            check.equals(session.start_location.shop, null);
+            check.equals(session.start_location.encounter, null);
+            check.equals(session.start_location.encounter_gen, true);
 
             session.setCampaignFleet();
-            expect(session.player.fleet.ships.length).toBe(2);
-            expect(session.player.fleet.credits).toBe(0);
-            expect(session.player.fleet.location).toBe(session.start_location);
+            check.equals(session.player.fleet.ships.length, 2);
+            check.equals(session.player.fleet.credits, 0);
+            check.same(session.player.fleet.location, session.start_location);
         });
 
-        /*it("can generate lots of new games", function () {
+        /*test.case("can generate lots of new games", check => {
             range(20).forEach(() => {
                 let session = new GameSession();
                 session.startNewGame();
-                expect(session.universe.stars.length).toBe(50);
+                check.equals(session.universe.stars.length, 50);
             });
         });*/
     });

src/core/LootGenerator.spec.ts

@@ -9,19 +9,19 @@ module TK.SpaceTac.Specs {
         }
     }
 
-    describe("LootGenerator", () => {
-        it("generates items within a given level range", () => {
+    testing("LootGenerator", test => {
+        test.case("generates items within a given level range", check => {
             var generator = new LootGenerator();
             generator.templates = [new TestTemplate()];
             generator.random = new SkewedRandomGenerator([0.5]);
 
             var equipment = generator.generate(2);
             if (equipment) {
-                expect(equipment.slot_type).toBe(SlotType.Shield);
-                expect(equipment.name).toEqual("Hexagrid Shield");
-                expect(equipment.requirements).toEqual({ "skill_time": 3 });
+                check.same(equipment.slot_type, SlotType.Shield);
+                check.equals(equipment.name, "Hexagrid Shield");
+                check.equals(equipment.requirements, { "skill_time": 3 });
             } else {
-                fail("No equipment generated");
+                check.fail("No equipment generated");
             }
         });
     });

src/core/LootTemplate.spec.ts

@@ -9,128 +9,128 @@ module TK.SpaceTac.Specs {
         }
     }
 
-    describe("LootTemplate", () => {
-        it("generates equipment with correct information", function () {
+    testing("LootTemplate", test => {
+        test.case("generates equipment with correct information", check => {
             let template = new LootTemplate(SlotType.Power, "Power Generator", "A great power generator !");
             let result = template.generate(2, EquipmentQuality.PREMIUM);
 
-            expect(result.slot_type).toEqual(SlotType.Power);
-            expect(result.code).toEqual("powergenerator");
-            expect(result.name).toEqual("Power Generator");
-            expect(result.price).toEqual(350);
-            expect(result.level).toEqual(2);
-            expect(result.quality).toEqual(EquipmentQuality.COMMON);
-            expect(result.description).toEqual("A great power generator !");
+            check.equals(result.slot_type, SlotType.Power);
+            check.equals(result.code, "powergenerator");
+            check.equals(result.name, "Power Generator");
+            check.equals(result.price, 350);
+            check.equals(result.level, 2);
+            check.equals(result.quality, EquipmentQuality.COMMON);
+            check.equals(result.description, "A great power generator !");
 
             template.addAttributeEffect("power_capacity", istep(10));
             result = template.generate(1, EquipmentQuality.COMMON);
-            expect(result.quality).toEqual(EquipmentQuality.COMMON);
-            expect(result.effects).toEqual([new AttributeEffect("power_capacity", 10)]);
+            check.equals(result.quality, EquipmentQuality.COMMON);
+            check.equals(result.effects, [new AttributeEffect("power_capacity", 10)]);
             result = template.generate(1, EquipmentQuality.PREMIUM);
-            expect(result.quality).toEqual(EquipmentQuality.PREMIUM);
-            expect(result.effects).toEqual([new AttributeEffect("power_capacity", 13)]);
+            check.equals(result.quality, EquipmentQuality.PREMIUM);
+            check.equals(result.effects, [new AttributeEffect("power_capacity", 13)]);
         });
 
-        it("applies requirements on skills", function () {
+        test.case("applies requirements on skills", check => {
             let template = new LootTemplate(SlotType.Hull, "Hull");
             template.setSkillsRequirements({ "skill_photons": istep(1), "skill_gravity": istep(2, istep(1)) });
 
             let result = template.generate(1);
-            expect(result.requirements).toEqual({
+            check.equals(result.requirements, {
                 "skill_photons": 1,
                 "skill_gravity": 2
             });
 
             result = template.generate(2);
-            expect(result.requirements).toEqual({
+            check.equals(result.requirements, {
                 "skill_photons": 2,
                 "skill_gravity": 3
             });
 
             result = template.generate(10);
-            expect(result.requirements).toEqual({
+            check.equals(result.requirements, {
                 "skill_photons": 10,
                 "skill_gravity": 47
             });
         });
 
-        it("applies cooldown", function () {
+        test.case("applies cooldown", check => {
             let template = new LootTemplate(SlotType.Weapon, "Weapon");
             template.setCooldown(istep(1), istep(2));
 
             let result = template.generate(1);
-            expect(result.cooldown.overheat).toBe(1);
-            expect(result.cooldown.cooling).toBe(2);
+            check.equals(result.cooldown.overheat, 1);
+            check.equals(result.cooldown.cooling, 2);
 
             result = template.generate(2);
-            expect(result.cooldown.overheat).toBe(2);
-            expect(result.cooldown.cooling).toBe(3);
+            check.equals(result.cooldown.overheat, 2);
+            check.equals(result.cooldown.cooling, 3);
 
             result = template.generate(10);
-            expect(result.cooldown.overheat).toBe(10);
-            expect(result.cooldown.cooling).toBe(11);
+            check.equals(result.cooldown.overheat, 10);
+            check.equals(result.cooldown.cooling, 11);
         });
 
-        it("applies attributes permenant effects", function () {
+        test.case("applies attributes permenant effects", check => {
             let template = new LootTemplate(SlotType.Shield, "Shield");
             template.addAttributeEffect("shield_capacity", irange(undefined, 50, 10));
 
             let result = template.generate(1);
-            expect(result.effects).toEqual([new AttributeEffect("shield_capacity", 50)]);
+            check.equals(result.effects, [new AttributeEffect("shield_capacity", 50)]);
 
             result = template.generate(2);
-            expect(result.effects).toEqual([new AttributeEffect("shield_capacity", 60)]);
+            check.equals(result.effects, [new AttributeEffect("shield_capacity", 60)]);
         });
 
-        it("adds move actions", function () {
+        test.case("adds move actions", check => {
             let template = new LootTemplate(SlotType.Engine, "Engine");
             template.addMoveAction(irange(undefined, 100, 10), istep(50, irepeat(10)), irepeat(95));
 
             let result = template.generate(1);
-            expect(result.action).toEqual(new MoveAction(result, 100, 50, 95));
+            check.equals(result.action, new MoveAction(result, 100, 50, 95));
 
             result = template.generate(2);
-            expect(result.action).toEqual(new MoveAction(result, 110, 60, 95));
+            check.equals(result.action, new MoveAction(result, 110, 60, 95));
         });
 
-        it("adds fire actions", function () {
+        test.case("adds fire actions", check => {
             let template = new LootTemplate(SlotType.Weapon, "Weapon");
             template.addTriggerAction(istep(1), [
                 new EffectTemplate(new FakeEffect(3), { "fakevalue": istep(8) })
             ], istep(100), istep(50), istep(10));
 
             let result = template.generate(1);
-            expect(result.action).toEqual(new TriggerAction(result, [new FakeEffect(8)], 1, 100, 50, 10));
+            check.equals(result.action, new TriggerAction(result, [new FakeEffect(8)], 1, 100, 50, 10));
 
             result = template.generate(2);
-            expect(result.action).toEqual(new TriggerAction(result, [new FakeEffect(9)], 2, 101, 51, 11));
+            check.equals(result.action, new TriggerAction(result, [new FakeEffect(9)], 2, 101, 51, 11));
         });
 
-        it("adds drone actions", function () {
+        test.case("adds drone actions", check => {
             let template = new LootTemplate(SlotType.Weapon, "Weapon");
             template.addDroneAction(istep(1), istep(100), istep(2), istep(50), [
                 new EffectTemplate(new FakeEffect(3), { "fakevalue": istep(8) })
             ]);
 
             let result = template.generate(1);
-            expect(result.action).toEqual(new DeployDroneAction(result, 1, 100, 2, 50, [new FakeEffect(8)]));
+            check.equals(result.action, new DeployDroneAction(result, 1, 100, 2, 50, [new FakeEffect(8)]));
 
             result = template.generate(2);
-            expect(result.action).toEqual(new DeployDroneAction(result, 2, 101, 3, 51, [new FakeEffect(9)]));
+            check.equals(result.action, new DeployDroneAction(result, 2, 101, 3, 51, [new FakeEffect(9)]));
         });
 
-        it("checks the presence of damaging effects", function () {
+        test.case("checks the presence of damaging effects", check => {
             let template = new LootTemplate(SlotType.Weapon, "Weapon");
-            expect(template.hasDamageEffect()).toBe(false);
+            check.equals(template.hasDamageEffect(), false);
 
             template.addAttributeEffect("maneuvrability", irepeat(1));
-            expect(template.hasDamageEffect()).toBe(false);
+            check.equals(template.hasDamageEffect(), false);
 
             template.addTriggerAction(irepeat(1), [new EffectTemplate(new BaseEffect("test"), {})], irepeat(50), irepeat(50));
-            expect(template.hasDamageEffect()).toBe(false);
+            check.equals(template.hasDamageEffect(), false);
 
             template.addTriggerAction(irepeat(1), [new EffectTemplate(new DamageEffect(20), {})], irepeat(50), irepeat(50));
-            expect(template.hasDamageEffect()).toBe(true);
+            check.equals(template.hasDamageEffect(), true);
         });
     });
 }

src/core/MoveFireSimulator.spec.ts

@@ -1,5 +1,5 @@
 module TK.SpaceTac.Specs {
-    describe("MoveFireSimulator", function () {
+    testing("MoveFireSimulator", test => {
 
         function simpleWeaponCase(distance = 10, ship_ap = 5, weapon_ap = 3, engine_distance = 5): [Ship, MoveFireSimulator, BaseAction] {
             let ship = new Ship();
@@ -10,90 +10,90 @@ module TK.SpaceTac.Specs {
             return [ship, simulator, action];
         }
 
-        it("finds the best engine to make a move", function () {
+        test.case("finds the best engine to make a move", check => {
             let ship = new Ship();
             let simulator = new MoveFireSimulator(ship);
-            expect(simulator.findBestEngine()).toBe(null);
+            check.equals(simulator.findBestEngine(), null);
             let engine1 = TestTools.addEngine(ship, 100);
-            expect(simulator.findBestEngine()).toBe(engine1);
+            check.same(simulator.findBestEngine(), engine1);
             let engine2 = TestTools.addEngine(ship, 120);
             let engine3 = TestTools.addEngine(ship, 150);
             let engine4 = TestTools.addEngine(ship, 70);
             let best = simulator.findBestEngine();
-            expect(best).toBe(engine3);
-            expect((<MoveAction>nn(best).action).distance_per_power).toBe(150);
+            check.same(best, engine3);
+            check.equals((<MoveAction>nn(best).action).distance_per_power, 150);
         });
 
-        it("fires directly when in range", function () {
+        test.case("fires directly when in range", check => {
             let [ship, simulator, action] = simpleWeaponCase();
             let result = simulator.simulateAction(action, new Target(ship.arena_x + 5, ship.arena_y, null));
 
-            expect(result.success).toBe(true, 'success');
-            expect(result.need_move).toBe(false, 'need_move');
-            expect(result.need_fire).toBe(true, 'need_fire');
-            expect(result.can_fire).toBe(true, 'can_fire');
-            expect(result.total_fire_ap).toBe(3, 'total_fire_ap');
+            check.same(result.success, true, 'success');
+            check.same(result.need_move, false, 'need_move');
+            check.same(result.need_fire, true, 'need_fire');
+            check.same(result.can_fire, true, 'can_fire');
+            check.same(result.total_fire_ap, 3, 'total_fire_ap');
 
-            expect(<any[]>result.parts).toEqual([
+            check.equals(<any[]>result.parts, [
                 { action: jasmine.objectContaining({ code: "fire-equipment" }), target: new Target(ship.arena_x + 5, ship.arena_y, null), ap: 3, possible: true }
             ]);
         });
 
-        it("can't fire when in range, but not enough AP", function () {
+        test.case("can't fire when in range, but not enough AP", check => {
             let [ship, simulator, action] = simpleWeaponCase(10, 2, 3);
             let result = simulator.simulateAction(action, new Target(ship.arena_x + 5, ship.arena_y, null));
-            expect(result.success).toBe(true, 'success');
-            expect(result.need_move).toBe(false, 'need_move');
-            expect(result.need_fire).toBe(true, 'need_fire');
-            expect(result.can_fire).toBe(false, 'can_fire');
-            expect(result.total_fire_ap).toBe(3, 'total_fire_ap');
+            check.same(result.success, true, 'success');
+            check.same(result.need_move, false, 'need_move');
+            check.same(result.need_fire, true, 'need_fire');
+            check.same(result.can_fire, false, 'can_fire');
+            check.same(result.total_fire_ap, 3, 'total_fire_ap');
 
-            expect(<any[]>result.parts).toEqual([
+            check.equals(<any[]>result.parts, [
                 { action: jasmine.objectContaining({ code: "fire-equipment" }), target: new Target(ship.arena_x + 5, ship.arena_y, null), ap: 3, possible: false }
             ]);
         });
 
-        it("moves straight to get within range", function () {
+        test.case("moves straight to get within range", check => {
             let [ship, simulator, action] = simpleWeaponCase();
             let result = simulator.simulateAction(action, new Target(ship.arena_x + 15, ship.arena_y, null));
-            expect(result.success).toBe(true, 'success');
-            expect(result.need_move).toBe(true, 'need_move');
-            expect(result.can_end_move).toBe(true, 'can_end_move');
-            expect(result.move_location).toEqual(new Target(ship.arena_x + 5, ship.arena_y, null));
-            expect(result.total_move_ap).toBe(1);
-            expect(result.need_fire).toBe(true, 'need_fire');
-            expect(result.can_fire).toBe(true, 'can_fire');
-            expect(result.total_fire_ap).toBe(3, 'total_fire_ap');
+            check.same(result.success, true, 'success');
+            check.same(result.need_move, true, 'need_move');
+            check.same(result.can_end_move, true, 'can_end_move');
+            check.equals(result.move_location, new Target(ship.arena_x + 5, ship.arena_y, null));
+            check.equals(result.total_move_ap, 1);
+            check.same(result.need_fire, true, 'need_fire');
+            check.same(result.can_fire, true, 'can_fire');
+            check.same(result.total_fire_ap, 3, 'total_fire_ap');
 
-            expect(<any[]>result.parts).toEqual([
+            check.equals(<any[]>result.parts, [
                 { action: jasmine.objectContaining({ code: "move" }), target: new Target(ship.arena_x + 5, ship.arena_y, null), ap: 1, possible: true },
                 { action: jasmine.objectContaining({ code: "fire-equipment" }), target: new Target(ship.arena_x + 15, ship.arena_y, null), ap: 3, possible: true }
             ]);
         });
 
-        it("scans a circle for move targets", function () {
+        test.case("scans a circle for move targets", check => {
             let simulator = new MoveFireSimulator(new Ship());
 
             let result = simulator.scanCircle(50, 30, 10, 1, 1);
-            expect(imaterialize(result)).toEqual([
+            check.equals(imaterialize(result), [
                 new Target(50, 30)
             ]);
 
             result = simulator.scanCircle(50, 30, 10, 2, 1);
-            expect(imaterialize(result)).toEqual([
+            check.equals(imaterialize(result), [
                 new Target(50, 30),
                 new Target(60, 30)
             ]);
 
             result = simulator.scanCircle(50, 30, 10, 2, 2);
-            expect(imaterialize(result)).toEqual([
+            check.equals(imaterialize(result), [
                 new Target(50, 30),
                 new Target(60, 30),
                 new Target(40, 30)
             ]);
 
             result = simulator.scanCircle(50, 30, 10, 3, 4);
-            expect(imaterialize(result)).toEqual([
+            check.equals(imaterialize(result), [
                 new Target(50, 30),
                 new Target(55, 30),
                 new Target(45, 30),
@@ -104,7 +104,7 @@ module TK.SpaceTac.Specs {
             ]);
         });
 
-        it("accounts for exclusion areas for the approach", function () {
+        test.case("accounts for exclusion areas for the approach", check => {
             let [ship, simulator, action] = simpleWeaponCase(100, 5, 1, 50);
             ship.setArenaPosition(300, 200);
             let battle = new Battle();
@@ -114,9 +114,9 @@ module TK.SpaceTac.Specs {
             moveaction.safety_distance = 30;
             battle.ship_separation = 30;
 
-            expect(simulator.getApproach(moveaction, Target.newFromLocation(350, 200), 100)).toBe(ApproachSimulationError.NO_MOVE_NEEDED);
-            expect(simulator.getApproach(moveaction, Target.newFromLocation(400, 200), 100)).toBe(ApproachSimulationError.NO_MOVE_NEEDED);
-            expect(simulator.getApproach(moveaction, Target.newFromLocation(500, 200), 100)).toEqual(new Target(400, 200));
+            check.same(simulator.getApproach(moveaction, Target.newFromLocation(350, 200), 100), ApproachSimulationError.NO_MOVE_NEEDED);
+            check.same(simulator.getApproach(moveaction, Target.newFromLocation(400, 200), 100), ApproachSimulationError.NO_MOVE_NEEDED);
+            check.equals(simulator.getApproach(moveaction, Target.newFromLocation(500, 200), 100), new Target(400, 200));
 
             ship1.setArenaPosition(420, 200);
 
@@ -127,46 +127,46 @@ module TK.SpaceTac.Specs {
                 new Target(420, 210),
                 new Target(480, 260),
             ]));
-            expect(simulator.getApproach(moveaction, Target.newFromLocation(500, 200), 100)).toEqual(new Target(410, 230));
+            check.equals(simulator.getApproach(moveaction, Target.newFromLocation(500, 200), 100), new Target(410, 230));
         });
 
-        it("moves to get in range, even if not enough AP to fire", function () {
+        test.case("moves to get in range, even if not enough AP to fire", check => {
             let [ship, simulator, action] = simpleWeaponCase(8, 3, 2, 5);
             let result = simulator.simulateAction(action, new Target(ship.arena_x + 18, ship.arena_y, null));
-            expect(result.success).toBe(true, 'success');
-            expect(result.need_move).toBe(true, 'need_move');
-            expect(result.can_end_move).toBe(true, 'can_end_move');
-            expect(result.move_location).toEqual(new Target(ship.arena_x + 10, ship.arena_y, null));
-            expect(result.total_move_ap).toBe(2);
-            expect(result.need_fire).toBe(true, 'need_fire');
-            expect(result.can_fire).toBe(false, 'can_fire');
-            expect(result.total_fire_ap).toBe(2, 'total_fire_ap');
+            check.same(result.success, true, 'success');
+            check.same(result.need_move, true, 'need_move');
+            check.same(result.can_end_move, true, 'can_end_move');
+            check.equals(result.move_location, new Target(ship.arena_x + 10, ship.arena_y, null));
+            check.equals(result.total_move_ap, 2);
+            check.same(result.need_fire, true, 'need_fire');
+            check.same(result.can_fire, false, 'can_fire');
+            check.same(result.total_fire_ap, 2, 'total_fire_ap');
 
-            expect(<any[]>result.parts).toEqual([
+            check.equals(<any[]>result.parts, [
                 { action: jasmine.objectContaining({ code: "move" }), target: new Target(ship.arena_x + 10, ship.arena_y, null), ap: 2, possible: true },
                 { action: jasmine.objectContaining({ code: "fire-equipment" }), target: new Target(ship.arena_x + 18, ship.arena_y, null), ap: 2, possible: false }
             ]);
         });
 
-        it("does nothing if trying to move in the same spot", function () {
+        test.case("does nothing if trying to move in the same spot", check => {
             let [ship, simulator, action] = simpleWeaponCase();
             let move_action = nn(ship.listEquipment(SlotType.Engine)[0].action)
             let result = simulator.simulateAction(move_action, new Target(ship.arena_x, ship.arena_y, null));
-            expect(result.success).toBe(false);
-            expect(result.need_move).toBe(false);
-            expect(result.need_fire).toBe(false);
-            expect(result.parts).toEqual([]);
+            check.equals(result.success, false);
+            check.equals(result.need_move, false);
+            check.equals(result.need_fire, false);
+            check.equals(result.parts, []);
         });
 
-        it("does not move if already in range, even if in the safety margin", function () {
+        test.case("does not move if already in range, even if in the safety margin", check => {
             let [ship, simulator, action] = simpleWeaponCase(100);
             let result = simulator.simulateAction(action, new Target(ship.arena_x + 97, ship.arena_y, null), 5);
-            expect(result.success).toBe(true);
-            expect(result.need_move).toBe(false);
+            check.equals(result.success, true);
+            check.equals(result.need_move, false);
             result = simulator.simulateAction(action, new Target(ship.arena_x + 101, ship.arena_y, null), 5);
-            expect(result.success).toBe(true);
-            expect(result.need_move).toBe(true);
-            expect(result.move_location).toEqual(new Target(ship.arena_x + 6, ship.arena_y));
+            check.equals(result.success, true);
+            check.equals(result.need_move, true);
+            check.equals(result.move_location, new Target(ship.arena_x + 6, ship.arena_y));
         });
     });
 }

src/core/NameGenerator.spec.ts

@@ -1,13 +1,13 @@
 module TK.SpaceTac.Specs {
-    describe("NameGenerator", () => {
-        it("generates unique names", () => {
+    testing("NameGenerator", test => {
+        test.case("generates unique names", check => {
             var random = new SkewedRandomGenerator([0.48, 0.9, 0.1]);
             var gen = new NameGenerator(["a", "b", "c"], random);
 
-            expect(gen.getName()).toEqual("b");
-            expect(gen.getName()).toEqual("c");
-            expect(gen.getName()).toEqual("a");
-            expect(gen.getName()).toBeNull();
+            check.equals(gen.getName(), "b");
+            check.equals(gen.getName(), "c");
+            check.equals(gen.getName(), "a");
+            check.equals(gen.getName(), null);
         });
     });
 }

src/core/PersonalityReactions.spec.ts

@@ -1,7 +1,7 @@
 /// <reference path="PersonalityReactions.ts" />
 
 module TK.SpaceTac.Specs {
-    describe("PersonalityReactions", function () {
+    testing("PersonalityReactions", test => {
         function apply(pool: ReactionPool): PersonalityReaction | null {
             let reactions = new PersonalityReactions();
             return reactions.check(new Player(), null, null, null, pool);
@@ -18,9 +18,9 @@ module TK.SpaceTac.Specs {
             }
         }
 
-        it("fetches ships from conditions", function () {
+        test.case("fetches ships from conditions", check => {
             let reaction = apply({});
-            expect(reaction).toBeNull();
+            check.equals(reaction, null);
 
             let s1 = new Ship(null, "S1");
             let s2 = new Ship(null, "S2");
@@ -28,10 +28,10 @@ module TK.SpaceTac.Specs {
             reaction = apply({
                 a: [() => [s1, s2], 1, [[() => 1, FakeReaction.cons]]],
             });
-            expect(reaction).toEqual(new FakeReaction([s1, s2]));
+            check.equals(reaction, new FakeReaction([s1, s2]));
         })
 
-        it("applies weight on conditions", function () {
+        test.case("applies weight on conditions", check => {
             let s1 = new Ship(null, "S1");
             let s2 = new Ship(null, "S2");
 
@@ -39,16 +39,16 @@ module TK.SpaceTac.Specs {
                 a: [() => [s1], 1, [[() => 1, FakeReaction.cons]]],
                 b: [() => [s2], 0, [[() => 1, FakeReaction.cons]]],
             });
-            expect(reaction).toEqual(new FakeReaction([s1]));
+            check.equals(reaction, new FakeReaction([s1]));
 
             reaction = apply({
                 a: [() => [s1], 0, [[() => 1, FakeReaction.cons]]],
                 b: [() => [s2], 1, [[() => 1, FakeReaction.cons]]],
             });
-            expect(reaction).toEqual(new FakeReaction([s2]));
+            check.equals(reaction, new FakeReaction([s2]));
         })
 
-        it("checks for friendly fire", function () {
+        test.case("checks for friendly fire", check => {
             let condition = BUILTIN_REACTION_POOL['friendly_fire'][0];
             let battle = new Battle();
             let ship1a = battle.fleets[0].addShip();
@@ -56,10 +56,10 @@ module TK.SpaceTac.Specs {
             let ship2a = battle.fleets[1].addShip();
             let ship2b = battle.fleets[1].addShip();
 
-            expect(condition(ship1a.getPlayer(), battle, ship1a, new DamageEvent(ship1a, 50, 10))).toEqual([], "self shoot");
-            expect(condition(ship1a.getPlayer(), battle, ship1a, new DamageEvent(ship1b, 50, 10))).toEqual([ship1b, ship1a]);
-            expect(condition(ship1a.getPlayer(), battle, ship1a, new DamageEvent(ship2a, 50, 10))).toEqual([], "enemy shoot");
-            expect(condition(ship1a.getPlayer(), battle, ship2a, new DamageEvent(ship2a, 50, 10))).toEqual([], "other player event");
+            check.equals(condition(ship1a.getPlayer(), battle, ship1a, new DamageEvent(ship1a, 50, 10)), [], "self shoot");
+            check.equals(condition(ship1a.getPlayer(), battle, ship1a, new DamageEvent(ship1b, 50, 10)), [ship1b, ship1a]);
+            check.equals(condition(ship1a.getPlayer(), battle, ship1a, new DamageEvent(ship2a, 50, 10)), [], "enemy shoot");
+            check.equals(condition(ship1a.getPlayer(), battle, ship2a, new DamageEvent(ship2a, 50, 10)), [], "other player event");
         })
     })
 }

src/core/Player.spec.ts

@@ -1,6 +1,6 @@
 module TK.SpaceTac {
-    describe("Player", function () {
-        it("keeps track of visited locations", function () {
+    testing("Player", test => {
+        test.case("keeps track of visited locations", check => {
             let player = new Player();
             let star1 = new Star();
             let star2 = new Star();
@@ -10,12 +10,12 @@ module TK.SpaceTac {
             let loc2b = new StarLocation(star2);
 
             function checkVisited(s1 = false, s2 = false, v1a = false, v1b = false, v2a = false, v2b = false) {
-                expect(player.hasVisitedSystem(star1)).toBe(s1);
-                expect(player.hasVisitedSystem(star2)).toBe(s2);
-                expect(player.hasVisitedLocation(loc1a)).toBe(v1a);
-                expect(player.hasVisitedLocation(loc1b)).toBe(v1b);
-                expect(player.hasVisitedLocation(loc2a)).toBe(v2a);
-                expect(player.hasVisitedLocation(loc2b)).toBe(v2b);
+                check.same(player.hasVisitedSystem(star1), s1);
+                check.same(player.hasVisitedSystem(star2), s2);
+                check.same(player.hasVisitedLocation(loc1a), v1a);
+                check.same(player.hasVisitedLocation(loc1b), v1b);
+                check.same(player.hasVisitedLocation(loc2a), v2a);
+                check.same(player.hasVisitedLocation(loc2b), v2b);
             }
 
             checkVisited();
@@ -37,7 +37,7 @@ module TK.SpaceTac {
             checkVisited(true, true, true, true, true, false);
         });
 
-        it("reverts battle", function () {
+        test.case("reverts battle", check => {
             let player = new Player();
             let star = new Star();
             let loc1 = new StarLocation(star);
@@ -46,25 +46,25 @@ module TK.SpaceTac {
             loc2.encounter_random = new SkewedRandomGenerator([0], true);
 
             player.fleet.setLocation(loc1);
-            expect(player.getBattle()).toBeNull();
-            expect(player.fleet.location).toBe(loc1);
+            check.equals(player.getBattle(), null);
+            check.same(player.fleet.location, loc1);
 
             player.fleet.setLocation(loc2);
-            expect(player.getBattle()).not.toBeNull();
-            expect(player.fleet.location).toBe(loc2);
-            expect(player.hasVisitedLocation(loc2)).toBe(true);
+            check.notequals(player.getBattle(), null);
+            check.same(player.fleet.location, loc2);
+            check.equals(player.hasVisitedLocation(loc2), true);
             let enemy = loc2.encounter;
 
             player.revertBattle();
-            expect(player.getBattle()).toBeNull();
-            expect(player.fleet.location).toBe(loc1);
-            expect(player.hasVisitedLocation(loc2)).toBe(true);
+            check.equals(player.getBattle(), null);
+            check.same(player.fleet.location, loc1);
+            check.equals(player.hasVisitedLocation(loc2), true);
 
             player.fleet.setLocation(loc2);
-            expect(player.getBattle()).not.toBeNull();
-            expect(player.fleet.location).toBe(loc2);
-            expect(player.hasVisitedLocation(loc2)).toBe(true);
-            expect(nn(player.getBattle()).fleets[1]).toBe(nn(enemy));
+            check.notequals(player.getBattle(), null);
+            check.same(player.fleet.location, loc2);
+            check.equals(player.hasVisitedLocation(loc2), true);
+            check.same(nn(player.getBattle()).fleets[1], nn(enemy));
         });
     });
 }

src/core/Range.spec.ts

@@ -1,45 +1,45 @@
 module TK.SpaceTac.Specs {
-    function checkProportional(range: Range, value1: number, value2: number) {
-        expect(range.getProportional(value1)).toEqual(value2);
-        expect(range.getReverseProportional(value2)).toEqual(value1);
-    }
-
-    describe("Range", () => {
-        it("can work with proportional values", () => {
+    testing("Range", test => {
+        test.case("can work with proportional values", check => {
             var range = new Range(1, 5);
 
+            function checkProportional(range: Range, value1: number, value2: number) {
+                check.equals(range.getProportional(value1), value2);
+                check.equals(range.getReverseProportional(value2), value1);
+            }
+
             checkProportional(range, 0, 1);
             checkProportional(range, 1, 5);
             checkProportional(range, 0.5, 3);
             checkProportional(range, 0.4, 2.6);
 
-            expect(range.getProportional(-0.25)).toEqual(1);
-            expect(range.getProportional(1.8)).toEqual(5);
+            check.equals(range.getProportional(-0.25), 1);
+            check.equals(range.getProportional(1.8), 5);
 
-            expect(range.getReverseProportional(0)).toEqual(0);
-            expect(range.getReverseProportional(6)).toEqual(1);
+            check.equals(range.getReverseProportional(0), 0);
+            check.equals(range.getReverseProportional(6), 1);
         });
     });
 
-    describe("IntegerRange", () => {
-        it("can work with proportional values", () => {
+    testing("IntegerRange", test => {
+        test.case("can work with proportional values", check => {
             var range = new IntegerRange(1, 5);
 
-            expect(range.getProportional(0)).toEqual(1);
-            expect(range.getProportional(0.1)).toEqual(1);
-            expect(range.getProportional(0.2)).toEqual(2);
-            expect(range.getProportional(0.45)).toEqual(3);
-            expect(range.getProportional(0.5)).toEqual(3);
-            expect(range.getProportional(0.75)).toEqual(4);
-            expect(range.getProportional(0.8)).toEqual(5);
-            expect(range.getProportional(0.99)).toEqual(5);
-            expect(range.getProportional(1)).toEqual(5);
+            check.equals(range.getProportional(0), 1);
+            check.equals(range.getProportional(0.1), 1);
+            check.equals(range.getProportional(0.2), 2);
+            check.equals(range.getProportional(0.45), 3);
+            check.equals(range.getProportional(0.5), 3);
+            check.equals(range.getProportional(0.75), 4);
+            check.equals(range.getProportional(0.8), 5);
+            check.equals(range.getProportional(0.99), 5);
+            check.equals(range.getProportional(1), 5);
 
-            expect(range.getReverseProportional(1)).toEqual(0);
-            expect(range.getReverseProportional(2)).toEqual(0.2);
-            expect(range.getReverseProportional(3)).toEqual(0.4);
-            expect(range.getReverseProportional(4)).toEqual(0.6);
-            expect(range.getReverseProportional(5)).toEqual(0.8);
+            check.equals(range.getReverseProportional(1), 0);
+            check.equals(range.getReverseProportional(2), 0.2);
+            check.equals(range.getReverseProportional(3), 0.4);
+            check.equals(range.getReverseProportional(4), 0.6);
+            check.equals(range.getReverseProportional(5), 0.8);
         });
     });
 }

src/core/Ship.spec.ts

@@ -1,108 +1,108 @@
 module TK.SpaceTac.Specs {
-    describe("Ship", function () {
-        it("creates a full name", function () {
+    testing("Ship", test => {
+        test.case("creates a full name", check => {
             let ship = new Ship();
-            expect(ship.getFullName(false)).toEqual("Level 1 unnamed");
+            check.equals(ship.getFullName(false), "Level 1 unnamed");
 
             ship.name = "Titan";
-            expect(ship.getFullName(false)).toEqual("Level 1 Titan");
+            check.equals(ship.getFullName(false), "Level 1 Titan");
 
             ship.level.forceLevel(3);
-            expect(ship.getFullName(false)).toEqual("Level 3 Titan");
+            check.equals(ship.getFullName(false), "Level 3 Titan");
 
             ship.fleet.player.name = "Emperor";
-            expect(ship.getFullName(true)).toEqual("Emperor's Level 3 Titan");
+            check.equals(ship.getFullName(true), "Emperor's Level 3 Titan");
         });
 
-        it("moves and computes facing angle", function () {
+        test.case("moves and computes facing angle", check => {
             let ship = new Ship(null, "Test");
             let engine = TestTools.addEngine(ship, 50);
             ship.setArenaFacingAngle(0);
             ship.setArenaPosition(50, 50);
 
-            expect(ship.arena_x).toEqual(50);
-            expect(ship.arena_y).toEqual(50);
-            expect(ship.arena_angle).toEqual(0);
+            check.equals(ship.arena_x, 50);
+            check.equals(ship.arena_y, 50);
+            check.equals(ship.arena_angle, 0);
 
             ship.moveTo(51, 50, engine);
-            expect(ship.arena_x).toEqual(51);
-            expect(ship.arena_y).toEqual(50);
-            expect(ship.arena_angle).toEqual(0);
+            check.equals(ship.arena_x, 51);
+            check.equals(ship.arena_y, 50);
+            check.equals(ship.arena_angle, 0);
 
             ship.moveTo(50, 50, engine);
-            expect(ship.arena_angle).toBeCloseTo(3.14159265, 0.00001);
+            check.nears(ship.arena_angle, 3.14159265, 5);
 
             ship.moveTo(51, 51, engine);
-            expect(ship.arena_angle).toBeCloseTo(0.785398, 0.00001);
+            check.nears(ship.arena_angle, 0.785398, 5);
 
             ship.moveTo(51, 52, engine);
-            expect(ship.arena_angle).toBeCloseTo(1.5707963, 0.00001);
+            check.nears(ship.arena_angle, 1.5707963, 5);
 
             ship.moveTo(52, 52, engine);
-            expect(ship.arena_x).toEqual(52);
-            expect(ship.arena_y).toEqual(52);
-            expect(ship.arena_angle).toEqual(0);
+            check.equals(ship.arena_x, 52);
+            check.equals(ship.arena_y, 52);
+            check.equals(ship.arena_angle, 0);
 
             ship.moveTo(52, 50, engine);
-            expect(ship.arena_angle).toBeCloseTo(-1.5707963, 0.00001);
+            check.nears(ship.arena_angle, -1.5707963, 5);
 
             ship.moveTo(50, 50, engine);
-            expect(ship.arena_angle).toBeCloseTo(3.14159265, 0.00001);
+            check.nears(ship.arena_angle, 3.14159265, 5);
 
             let battle = new Battle();
             battle.fleets[0].addShip(ship);
-            expect(battle.log.events).toEqual([]);
+            check.equals(battle.log.events, []);
 
             ship.moveTo(70, 50, engine);
-            expect(battle.log.events).toEqual([new MoveEvent(ship, new ArenaLocationAngle(50, 50, Math.PI), new ArenaLocationAngle(70, 50, 0), engine)]);
+            check.equals(battle.log.events, [new MoveEvent(ship, new ArenaLocationAngle(50, 50, Math.PI), new ArenaLocationAngle(70, 50, 0), engine)]);
 
             battle.log.clear();
             ship.rotate(2.1);
-            expect(battle.log.events).toEqual([
+            check.equals(battle.log.events, [
                 new MoveEvent(ship, new ArenaLocationAngle(70, 50, 0), new ArenaLocationAngle(70, 50, 2.1))
             ]);
 
             battle.log.clear();
             ship.moveTo(0, 0, null);
-            expect(battle.log.events).toEqual([
+            check.equals(battle.log.events, [
                 new MoveEvent(ship, new ArenaLocationAngle(70, 50, 2.1), new ArenaLocationAngle(0, 0, 2.1))
             ]);
         });
 
-        it("applies equipment cooldown", function () {
+        test.case("applies equipment cooldown", check => {
             let ship = new Ship();
             let equipment = new Equipment(SlotType.Weapon);
             equipment.cooldown.configure(1, 2);
             ship.addSlot(SlotType.Weapon).attach(equipment);
 
-            expect(equipment.cooldown.canUse()).toBe(true, 1);
+            check.same(equipment.cooldown.canUse(), true, "1");
             equipment.cooldown.use();
-            expect(equipment.cooldown.canUse()).toBe(false, 2);
+            check.same(equipment.cooldown.canUse(), false, "2");
 
             ship.startBattle();
-            expect(equipment.cooldown.canUse()).toBe(true, 3);
+            check.same(equipment.cooldown.canUse(), true, "3");
 
             ship.startTurn();
             equipment.cooldown.use();
-            expect(equipment.cooldown.canUse()).toBe(false, 4);
+            check.same(equipment.cooldown.canUse(), false, "4");
             ship.endTurn();
-            expect(equipment.cooldown.canUse()).toBe(false, 5);
+            check.same(equipment.cooldown.canUse(), false, "5");
 
             ship.startTurn();
-            expect(equipment.cooldown.canUse()).toBe(false, 6);
+            check.same(equipment.cooldown.canUse(), false, "6");
             ship.endTurn();
-            expect(equipment.cooldown.canUse()).toBe(true, 7);
+            check.same(equipment.cooldown.canUse(), true, "7");
         });
 
-        it("lists available actions from attached equipment", function () {
+        test.case("lists available actions from attached equipment", check => {
             var ship = new Ship(null, "Test");
             var actions: BaseAction[];
             var slot: Slot;
             var equipment: Equipment;
 
             actions = ship.getAvailableActions();
-            expect(actions.length).toBe(1);
-            expect(actions[0].code).toEqual("endturn");
+            check.equals(actions.length, 1);
+            check.equals(actions[0].code, "endturn");
 
             slot = ship.addSlot(SlotType.Engine);
             equipment = new Equipment(slot.type);
@@ -119,13 +119,13 @@ module TK.SpaceTac.Specs {
             slot.attach(equipment);
 
             actions = ship.getAvailableActions();
-            expect(actions.length).toBe(3);
-            expect(actions[0].code).toEqual("move");
-            expect(actions[1].code).toEqual("fire-equipment");
-            expect(actions[2].code).toEqual("endturn");
+            check.equals(actions.length, 3);
+            check.equals(actions[0].code, "move");
+            check.equals(actions[1].code, "fire-equipment");
+            check.equals(actions[2].code, "endturn");
         });
 
-        it("applies permanent effects of equipments on attributes", function () {
+        test.case("applies permanent effects of equipments on attributes", check => {
             var ship = new Ship(null, "Test");
             var slot: Slot;
             var equipment: Equipment;
@@ -143,25 +143,25 @@ module TK.SpaceTac.Specs {
             slot.attach(equipment);
 
             ship.updateAttributes();
-            expect(ship.attributes.power_capacity.get()).toBe(9);
+            check.equals(ship.attributes.power_capacity.get(), 9);
         });
 
-        it("repairs hull and recharges shield", function () {
+        test.case("repairs hull and recharges shield", check => {
             var ship = new Ship(null, "Test");
 
             ship.setAttribute("hull_capacity", 120);
             ship.setAttribute("shield_capacity", 150);
 
-            expect(ship.values.hull.get()).toEqual(0);
-            expect(ship.values.shield.get()).toEqual(0);
+            check.equals(ship.values.hull.get(), 0);
+            check.equals(ship.values.shield.get(), 0);
 
             ship.restoreHealth();
 
-            expect(ship.values.hull.get()).toEqual(120);
-            expect(ship.values.shield.get()).toEqual(150);
+            check.equals(ship.values.hull.get(), 120);
+            check.equals(ship.values.shield.get(), 150);
         });
 
-        it("applies and logs hull and shield damage", function () {
+        test.case("applies and logs hull and shield damage", check => {
             var fleet = new Fleet();
             var battle = new Battle(fleet);
             var ship = new Ship(fleet);
@@ -171,34 +171,34 @@ module TK.SpaceTac.Specs {
             battle.log.clear();
 
             ship.addDamage(10, 20);
-            expect(ship.values.hull.get()).toEqual(140);
-            expect(ship.values.shield.get()).toEqual(380);
-            expect(battle.log.events.length).toBe(3);
-            expect(battle.log.events[0]).toEqual(new ValueChangeEvent(ship, ship.values.shield, -20));
-            expect(battle.log.events[1]).toEqual(new ValueChangeEvent(ship, ship.values.hull, -10));
-            expect(battle.log.events[2]).toEqual(new DamageEvent(ship, 10, 20));
+            check.equals(ship.values.hull.get(), 140);
+            check.equals(ship.values.shield.get(), 380);
+            check.equals(battle.log.events.length, 3);
+            check.equals(battle.log.events[0], new ValueChangeEvent(ship, ship.values.shield, -20));
+            check.equals(battle.log.events[1], new ValueChangeEvent(ship, ship.values.hull, -10));
+            check.equals(battle.log.events[2], new DamageEvent(ship, 10, 20));
 
             battle.log.clear();
 
             ship.addDamage(15, 25, false);
-            expect(ship.values.hull.get()).toEqual(125);
-            expect(ship.values.shield.get()).toEqual(355);
-            expect(battle.log.events.length).toBe(0);
+            check.equals(ship.values.hull.get(), 125);
+            check.equals(ship.values.shield.get(), 355);
+            check.equals(battle.log.events.length, 0);
 
             ship.addDamage(125, 355, false);
-            expect(ship.values.hull.get()).toEqual(0);
-            expect(ship.values.shield.get()).toEqual(0);
-            expect(ship.alive).toBe(false);
+            check.equals(ship.values.hull.get(), 0);
+            check.equals(ship.values.shield.get(), 0);
+            check.equals(ship.alive, false);
         });
 
-        it("sets and logs sticky effects", function () {
+        test.case("sets and logs sticky effects", check => {
             var ship = new Ship();
             var battle = new Battle(ship.fleet);
 
             ship.addStickyEffect(new StickyEffect(new BaseEffect("test"), 2, false, true));
 
-            expect(ship.sticky_effects).toEqual([new StickyEffect(new BaseEffect("test"), 2, false, true)]);
-            expect(battle.log.events).toEqual([
+            check.equals(ship.sticky_effects, [new StickyEffect(new BaseEffect("test"), 2, false, true)]);
+            check.equals(battle.log.events, [
                 new ActiveEffectsEvent(ship, [], [new StickyEffect(new BaseEffect("test"), 2, false, true)])
             ]);
 
@@ -206,8 +206,8 @@ module TK.SpaceTac.Specs {
             battle.log.clear();
             ship.endTurn();
 
-            expect(ship.sticky_effects).toEqual([new StickyEffect(new BaseEffect("test"), 1, false, true)]);
-            expect(battle.log.events).toEqual([
+            check.equals(ship.sticky_effects, [new StickyEffect(new BaseEffect("test"), 1, false, true)]);
+            check.equals(battle.log.events, [
                 new ActiveEffectsEvent(ship, [], [new StickyEffect(new BaseEffect("test"), 1, false, true)])
             ]);
 
@@ -215,8 +215,8 @@ module TK.SpaceTac.Specs {
             battle.log.clear();
             ship.endTurn();
 
-            expect(ship.sticky_effects).toEqual([]);
-            expect(battle.log.events).toEqual([
+            check.equals(ship.sticky_effects, []);
+            check.equals(battle.log.events, [
                 new ActiveEffectsEvent(ship, [], [new StickyEffect(new BaseEffect("test"), 0, false, true)]),
                 new ActiveEffectsEvent(ship, [], [])
             ]);
@@ -225,33 +225,33 @@ module TK.SpaceTac.Specs {
             battle.log.clear();
             ship.endTurn();
 
-            expect(ship.sticky_effects).toEqual([]);
-            expect(battle.log.events).toEqual([]);
+            check.equals(ship.sticky_effects, []);
+            check.equals(battle.log.events, []);
         });
 
-        it("resets toggle actions at the start of turn", function () {
+        test.case("resets toggle actions at the start of turn", check => {
             let ship = new Ship();
             let equ = ship.addSlot(SlotType.Weapon).attach(new Equipment(SlotType.Weapon));
             let action = equ.action = new ToggleAction(equ, 0, 10, [new AttributeEffect("power_capacity", 1)]);
-            expect(action.activated).toBe(false);
+            check.equals(action.activated, false);
 
             let battle = new Battle(ship.fleet);
             TestTools.setShipPlaying(battle, ship);
 
             ship.startTurn();
-            expect(action.activated).toBe(false);
+            check.equals(action.activated, false);
 
             let result = action.apply(ship);
-            expect(result).toBe(true, "Could not be applied");
-            expect(action.activated).toBe(true);
+            check.same(result, true, "Could not be applied");
+            check.equals(action.activated, true);
 
             ship.endTurn();
-            expect(action.activated).toBe(true);
+            check.equals(action.activated, true);
 
             ship.startTurn();
-            expect(action.activated).toBe(false);
+            check.equals(action.activated, false);
 
-            expect(battle.log.events).toEqual([
+            check.equals(battle.log.events, [
                 new ActionAppliedEvent(ship, action, Target.newFromShip(ship), 0),
                 new ToggleEvent(ship, action, true),
                 new ActiveEffectsEvent(ship, [], [], [new AttributeEffect("power_capacity", 1)]),
@@ -263,7 +263,7 @@ module TK.SpaceTac.Specs {
             ]);
         });
 
-        it("updates area effects when the ship moves", function () {
+        test.case("updates area effects when the ship moves", check => {
             let battle = new Battle();
             let ship1 = battle.fleets[0].addShip();
             let ship2 = battle.fleets[0].addShip();
@@ -276,101 +276,101 @@ module TK.SpaceTac.Specs {
             TestTools.setShipPlaying(battle, ship1);
             shield.action.apply(ship1);
 
-            expect(ship1.getAttribute("shield_capacity")).toBe(5);
-            expect(ship2.getAttribute("shield_capacity")).toBe(5);
-            expect(ship3.getAttribute("shield_capacity")).toBe(0);
+            check.equals(ship1.getAttribute("shield_capacity"), 5);
+            check.equals(ship2.getAttribute("shield_capacity"), 5);
+            check.equals(ship3.getAttribute("shield_capacity"), 0);
 
             ship1.moveTo(15, 0);
 
-            expect(ship1.getAttribute("shield_capacity")).toBe(5);
-            expect(ship2.getAttribute("shield_capacity")).toBe(5);
-            expect(ship3.getAttribute("shield_capacity")).toBe(5);
+            check.equals(ship1.getAttribute("shield_capacity"), 5);
+            check.equals(ship2.getAttribute("shield_capacity"), 5);
+            check.equals(ship3.getAttribute("shield_capacity"), 5);
 
             ship1.moveTo(30, 0);
 
-            expect(ship1.getAttribute("shield_capacity")).toBe(5);
-            expect(ship2.getAttribute("shield_capacity")).toBe(0);
-            expect(ship3.getAttribute("shield_capacity")).toBe(5);
+            check.equals(ship1.getAttribute("shield_capacity"), 5);
+            check.equals(ship2.getAttribute("shield_capacity"), 0);
+            check.equals(ship3.getAttribute("shield_capacity"), 5);
 
             ship1.moveTo(50, 0);
 
-            expect(ship1.getAttribute("shield_capacity")).toBe(5);
-            expect(ship2.getAttribute("shield_capacity")).toBe(0);
-            expect(ship3.getAttribute("shield_capacity")).toBe(0);
+            check.equals(ship1.getAttribute("shield_capacity"), 5);
+            check.equals(ship2.getAttribute("shield_capacity"), 0);
+            check.equals(ship3.getAttribute("shield_capacity"), 0);
 
             ship2.moveTo(40, 0);
 
-            expect(ship1.getAttribute("shield_capacity")).toBe(5);
-            expect(ship2.getAttribute("shield_capacity")).toBe(5);
-            expect(ship3.getAttribute("shield_capacity")).toBe(0);
+            check.equals(ship1.getAttribute("shield_capacity"), 5);
+            check.equals(ship2.getAttribute("shield_capacity"), 5);
+            check.equals(ship3.getAttribute("shield_capacity"), 0);
         });
 
-        it("sets and logs death state", function () {
+        test.case("sets and logs death state", check => {
             var fleet = new Fleet();
             var battle = new Battle(fleet);
             var ship = new Ship(fleet);
 
-            expect(ship.alive).toBe(true);
+            check.equals(ship.alive, true);
 
             ship.values.hull.set(10);
             battle.log.clear();
             ship.addDamage(5, 0);
 
-            expect(ship.alive).toBe(true);
-            expect(battle.log.events.length).toBe(2);
-            expect(battle.log.events[0].code).toEqual("value");
-            expect(battle.log.events[1].code).toEqual("damage");
+            check.equals(ship.alive, true);
+            check.equals(battle.log.events.length, 2);
+            check.equals(battle.log.events[0].code, "value");
+            check.equals(battle.log.events[1].code, "damage");
 
             battle.log.clear();
             ship.addDamage(5, 0);
 
-            expect(ship.alive).toBe(false);
-            expect(battle.log.events.length).toBe(3);
-            expect(battle.log.events[0].code).toEqual("value");
-            expect(battle.log.events[1].code).toEqual("damage");
-            expect(battle.log.events[2].code).toEqual("death");
+            check.equals(ship.alive, false);
+            check.equals(battle.log.events.length, 3);
+            check.equals(battle.log.events[0].code, "value");
+            check.equals(battle.log.events[1].code, "damage");
+            check.equals(battle.log.events[2].code, "death");
         });
 
-        it("checks if a ship is able to play", function () {
+        test.case("checks if a ship is able to play", check => {
             let battle = new Battle();
             let ship = battle.fleets[0].addShip();
 
-            expect(ship.isAbleToPlay()).toBe(false);
-            expect(ship.isAbleToPlay(false)).toBe(true);
+            check.equals(ship.isAbleToPlay(), false);
+            check.equals(ship.isAbleToPlay(false), true);
 
             ship.values.power.set(5);
 
-            expect(ship.isAbleToPlay()).toBe(true);
-            expect(ship.isAbleToPlay(false)).toBe(true);
+            check.equals(ship.isAbleToPlay(), true);
+            check.equals(ship.isAbleToPlay(false), true);
 
             ship.values.hull.set(10);
             ship.addDamage(8, 0);
 
-            expect(ship.isAbleToPlay()).toBe(true);
-            expect(ship.isAbleToPlay(false)).toBe(true);
+            check.equals(ship.isAbleToPlay(), true);
+            check.equals(ship.isAbleToPlay(false), true);
 
             ship.addDamage(8, 0);
 
-            expect(ship.isAbleToPlay()).toBe(false);
-            expect(ship.isAbleToPlay(false)).toBe(false);
+            check.equals(ship.isAbleToPlay(), false);
+            check.equals(ship.isAbleToPlay(false), false);
         });
 
-        it("counts attached equipment", function () {
+        test.case("counts attached equipment", check => {
             var ship = new Ship();
 
-            expect(ship.getEquipmentCount()).toBe(0);
+            check.equals(ship.getEquipmentCount(), 0);
 
             ship.addSlot(SlotType.Hull).attach(new Equipment(SlotType.Hull));
             ship.addSlot(SlotType.Shield);
             ship.addSlot(SlotType.Weapon).attach(new Equipment(SlotType.Weapon));
 
-            expect(ship.getEquipmentCount()).toBe(2);
+            check.equals(ship.getEquipmentCount(), 2);
         });
 
-        it("can pick a random attached equipment", function () {
+        test.case("can pick a random attached equipment", check => {
             var ship = new Ship();
 
-            expect(ship.getRandomEquipment()).toBe(null);
+            check.equals(ship.getRandomEquipment(), null);
 
             ship.addSlot(SlotType.Hull).attach(new Equipment(SlotType.Hull));
             ship.addSlot(SlotType.Shield);
@@ -378,16 +378,16 @@ module TK.SpaceTac.Specs {
 
             var random = new SkewedRandomGenerator([0.2]);
             var picked = ship.getRandomEquipment(random);
-            expect(picked).not.toBeNull();
-            expect(picked).toBe(ship.slots[0].attached);
+            check.notequals(picked, null);
+            check.same(picked, ship.slots[0].attached);
 
             random = new SkewedRandomGenerator([0.999999]);
             picked = ship.getRandomEquipment(random);
-            expect(picked).not.toBeNull();
-            expect(picked).toBe(ship.slots[2].attached);
+            check.notequals(picked, null);
+            check.same(picked, ship.slots[2].attached);
         });
 
-        it("recover action points at end of turn", function () {
+        test.case("recover action points at end of turn", check => {
             var ship = new Ship();
 
             let power_generator = new Equipment(SlotType.Power);
@@ -397,171 +397,171 @@ module TK.SpaceTac.Specs {
             ]
             ship.addSlot(SlotType.Power).attach(power_generator);
 
-            expect(ship.values.power.get()).toBe(0);
+            check.equals(ship.values.power.get(), 0);
             ship.initializeActionPoints();
-            expect(ship.values.power.get()).toBe(8);
+            check.equals(ship.values.power.get(), 8);
             ship.values.power.set(3);
-            expect(ship.values.power.get()).toBe(3);
+            check.equals(ship.values.power.get(), 3);
             ship.recoverActionPoints();
-            expect(ship.values.power.get()).toBe(6);
+            check.equals(ship.values.power.get(), 6);
             ship.recoverActionPoints();
-            expect(ship.values.power.get()).toBe(8);
+            check.equals(ship.values.power.get(), 8);
         });
 
-        it("checks if a ship is inside a given circle", function () {
+        test.case("checks if a ship is inside a given circle", check => {
             let ship = new Ship();
             ship.arena_x = 5;
             ship.arena_y = 8;
 
-            expect(ship.isInCircle(5, 8, 0)).toBe(true);
-            expect(ship.isInCircle(5, 8, 1)).toBe(true);
-            expect(ship.isInCircle(5, 7, 1)).toBe(true);
-            expect(ship.isInCircle(6, 9, 1.7)).toBe(true);
-            expect(ship.isInCircle(5, 8.1, 0)).toBe(false);
-            expect(ship.isInCircle(5, 7, 0.9)).toBe(false);
-            expect(ship.isInCircle(12, -4, 5)).toBe(false);
+            check.equals(ship.isInCircle(5, 8, 0), true);
+            check.equals(ship.isInCircle(5, 8, 1), true);
+            check.equals(ship.isInCircle(5, 7, 1), true);
+            check.equals(ship.isInCircle(6, 9, 1.7), true);
+            check.equals(ship.isInCircle(5, 8.1, 0), false);
+            check.equals(ship.isInCircle(5, 7, 0.9), false);
+            check.equals(ship.isInCircle(12, -4, 5), false);
         });
 
-        it("stores items in cargo space", function () {
+        test.case("stores items in cargo space", check => {
             let ship = new Ship();
             let equipment1 = new Equipment();
             let equipment2 = new Equipment();
 
             let result = ship.addCargo(equipment1);
-            expect(result).toBe(false);
-            expect(ship.cargo).toEqual([]);
-            expect(ship.getFreeCargoSpace()).toBe(0);
+            check.equals(result, false);
+            check.equals(ship.cargo, []);
+            check.equals(ship.getFreeCargoSpace(), 0);
 
             ship.setCargoSpace(1);
-            expect(ship.getFreeCargoSpace()).toBe(1);
+            check.equals(ship.getFreeCargoSpace(), 1);
 
             result = ship.addCargo(equipment1);
-            expect(result).toBe(true);
-            expect(ship.cargo).toEqual([equipment1]);
-            expect(ship.getFreeCargoSpace()).toBe(0);
+            check.equals(result, true);
+            check.equals(ship.cargo, [equipment1]);
+            check.equals(ship.getFreeCargoSpace(), 0);
 
             result = ship.addCargo(equipment1);
-            expect(result).toBe(false);
-            expect(ship.cargo).toEqual([equipment1]);
+            check.equals(result, false);
+            check.equals(ship.cargo, [equipment1]);
 
             result = ship.addCargo(equipment2);
-            expect(result).toBe(false);
-            expect(ship.cargo).toEqual([equipment1]);
+            check.equals(result, false);
+            check.equals(ship.cargo, [equipment1]);
 
             ship.setCargoSpace(2);
-            expect(ship.getFreeCargoSpace()).toBe(1);
+            check.equals(ship.getFreeCargoSpace(), 1);
 
             result = ship.addCargo(equipment2);
-            expect(result).toBe(true);
-            expect(ship.cargo).toEqual([equipment1, equipment2]);
-            expect(ship.getFreeCargoSpace()).toBe(0);
+            check.equals(result, true);
+            check.equals(ship.cargo, [equipment1, equipment2]);
+            check.equals(ship.getFreeCargoSpace(), 0);
 
             ship.setCargoSpace(1);
-            expect(ship.cargo).toEqual([equipment1]);
-            expect(ship.getFreeCargoSpace()).toBe(0);
+            check.equals(ship.cargo, [equipment1]);
+            check.equals(ship.getFreeCargoSpace(), 0);
 
             ship.setCargoSpace(2);
-            expect(ship.cargo).toEqual([equipment1]);
-            expect(ship.getFreeCargoSpace()).toBe(1);
+            check.equals(ship.cargo, [equipment1]);
+            check.equals(ship.getFreeCargoSpace(), 1);
         });
 
-        it("equips items from cargo", function () {
+        test.case("equips items from cargo", check => {
             let ship = new Ship();
             let equipment = new Equipment(SlotType.Weapon);
             let slot = ship.addSlot(SlotType.Weapon);
-            expect(ship.listEquipment()).toEqual([]);
+            check.equals(ship.listEquipment(), []);
 
             let result = ship.equip(equipment);
-            expect(result).toBe(false);
-            expect(ship.listEquipment()).toEqual([]);
+            check.equals(result, false);
+            check.equals(ship.listEquipment(), []);
 
             ship.setCargoSpace(1);
             ship.addCargo(equipment);
 
             result = ship.equip(equipment);
-            expect(result).toBe(true);
-            expect(ship.listEquipment(SlotType.Weapon)).toEqual([equipment]);
-            expect(equipment.attached_to).toEqual(slot);
+            check.equals(result, true);
+            check.equals(ship.listEquipment(SlotType.Weapon), [equipment]);
+            check.equals(equipment.attached_to, slot);
         });
 
-        it("removes equipped items", function () {
+        test.case("removes equipped items", check => {
             let ship = new Ship();
             let equipment = new Equipment(SlotType.Weapon);
             let slot = ship.addSlot(SlotType.Weapon);
             slot.attach(equipment);
 
-            expect(ship.listEquipment()).toEqual([equipment]);
-            expect(slot.attached).toBe(equipment);
-            expect(equipment.attached_to).toBe(slot);
+            check.equals(ship.listEquipment(), [equipment]);
+            check.same(slot.attached, equipment);
+            check.same(equipment.attached_to, slot);
 
             let result = ship.unequip(equipment);
-            expect(result).toBe(false);
-            expect(ship.listEquipment()).toEqual([equipment]);
-            expect(ship.cargo).toEqual([]);
+            check.equals(result, false);
+            check.equals(ship.listEquipment(), [equipment]);
+            check.equals(ship.cargo, []);
 
             ship.setCargoSpace(10);
 
             result = ship.unequip(equipment);
-            expect(result).toBe(true);
-            expect(ship.listEquipment()).toEqual([]);
-            expect(ship.cargo).toEqual([equipment]);
-            expect(slot.attached).toBe(null);
-            expect(equipment.attached_to).toBe(null);
+            check.equals(result, true);
+            check.equals(ship.listEquipment(), []);
+            check.equals(ship.cargo, [equipment]);
+            check.equals(slot.attached, null);
+            check.equals(equipment.attached_to, null);
 
             result = ship.unequip(equipment);
-            expect(result).toBe(false);
-            expect(ship.listEquipment()).toEqual([]);
-            expect(ship.cargo).toEqual([equipment]);
+            check.equals(result, false);
+            check.equals(ship.listEquipment(), []);
+            check.equals(ship.cargo, [equipment]);
         });
 
-        it("checks equipment requirements", function () {
+        test.case("checks equipment requirements", check => {
             let ship = new Ship();
             let equipment = new Equipment(SlotType.Hull);
-            expect(ship.canEquip(equipment)).toBe(null);
+            check.equals(ship.canEquip(equipment), null);
 
             ship.addSlot(SlotType.Engine);
-            expect(ship.canEquip(equipment)).toBe(null);
+            check.equals(ship.canEquip(equipment), null);
 
             let slot = ship.addSlot(SlotType.Hull);
-            expect(ship.canEquip(equipment)).toBe(slot);
+            check.same(ship.canEquip(equipment), slot);
 
             equipment.requirements["skill_photons"] = 2;
-            expect(ship.canEquip(equipment)).toBe(null);
+            check.equals(ship.canEquip(equipment), null);
 
             ship.upgradeSkill("skill_photons");
-            expect(ship.canEquip(equipment)).toBe(null);
+            check.equals(ship.canEquip(equipment), null);
 
             ship.upgradeSkill("skill_photons");
-            expect(ship.canEquip(equipment)).toBe(slot);
+            check.same(ship.canEquip(equipment), slot);
 
             slot.attach(new Equipment(SlotType.Hull));
-            expect(ship.canEquip(equipment)).toBe(null);
+            check.equals(ship.canEquip(equipment), null);
         });
 
-        it("allow skills upgrading from current level", function () {
+        test.case("allow skills upgrading from current level", check => {
             let ship = new Ship();
-            expect(ship.level.get()).toBe(1);
-            expect(ship.getAvailableUpgradePoints()).toBe(10);
+            check.equals(ship.level.get(), 1);
+            check.equals(ship.getAvailableUpgradePoints(), 10);
 
             ship.level.forceLevel(2);
-            expect(ship.level.get()).toBe(2);
-            expect(ship.getAvailableUpgradePoints()).toBe(15);
+            check.equals(ship.level.get(), 2);
+            check.equals(ship.getAvailableUpgradePoints(), 15);
 
-            expect(ship.getAttribute("skill_photons")).toBe(0);
+            check.equals(ship.getAttribute("skill_photons"), 0);
             ship.upgradeSkill("skill_photons");
-            expect(ship.getAttribute("skill_photons")).toBe(1);
+            check.equals(ship.getAttribute("skill_photons"), 1);
 
             range(50).forEach(() => ship.upgradeSkill("skill_gravity"));
-            expect(ship.getAttribute("skill_photons")).toBe(1);
-            expect(ship.getAttribute("skill_gravity")).toBe(14);
-            expect(ship.getAvailableUpgradePoints()).toBe(0);
+            check.equals(ship.getAttribute("skill_photons"), 1);
+            check.equals(ship.getAttribute("skill_gravity"), 14);
+            check.equals(ship.getAvailableUpgradePoints(), 0);
 
             ship.updateAttributes();
-            expect(ship.getAttribute("skill_photons")).toBe(1);
-            expect(ship.getAttribute("skill_gravity")).toBe(14);
+            check.equals(ship.getAttribute("skill_photons"), 1);
+            check.equals(ship.getAttribute("skill_gravity"), 14);
         });
 
-        it("restores as new at the end of battle", function () {
+        test.case("restores as new at the end of battle", check => {
             let ship = new Ship();
             TestTools.setShipHP(ship, 10, 20);
             TestTools.setShipAP(ship, 5, 0);
@@ -570,58 +570,58 @@ module TK.SpaceTac.Specs {
             ship.addStickyEffect(new StickyEffect(new AttributeLimitEffect("power_capacity", 3), 12));
             ship.updateAttributes();
 
-            expect(ship.getValue("hull")).toEqual(5);
-            expect(ship.getValue("shield")).toEqual(15);
-            expect(ship.getValue("power")).toEqual(3);
-            expect(ship.sticky_effects.length).toEqual(2);
-            expect(ship.getAttribute("power_capacity")).toEqual(3);
+            check.equals(ship.getValue("hull"), 5);
+            check.equals(ship.getValue("shield"), 15);
+            check.equals(ship.getValue("power"), 3);
+            check.equals(ship.sticky_effects.length, 2);
+            check.equals(ship.getAttribute("power_capacity"), 3);
 
             ship.endBattle(1);
 
-            expect(ship.getValue("hull")).toEqual(10);
-            expect(ship.getValue("shield")).toEqual(20);
-            expect(ship.getValue("power")).toEqual(5);
-            expect(ship.sticky_effects.length).toEqual(0);
-            expect(ship.getAttribute("power_capacity")).toEqual(5);
+            check.equals(ship.getValue("hull"), 10);
+            check.equals(ship.getValue("shield"), 20);
+            check.equals(ship.getValue("power"), 5);
+            check.equals(ship.sticky_effects.length, 0);
+            check.equals(ship.getAttribute("power_capacity"), 5);
         });
 
-        it("lists active effects", function () {
+        test.case("lists active effects", check => {
             let ship = new Ship();
-            expect(imaterialize(ship.ieffects())).toEqual([]);
+            check.equals(imaterialize(ship.ieffects()), []);
 
             let equipment = ship.addSlot(SlotType.Engine).attach(new Equipment(SlotType.Engine));
-            expect(imaterialize(ship.ieffects())).toEqual([]);
+            check.equals(imaterialize(ship.ieffects()), []);
 
             equipment.effects.push(new AttributeEffect("precision", 4));
-            expect(imaterialize(ship.ieffects())).toEqual([
+            check.equals(imaterialize(ship.ieffects()), [
                 new AttributeEffect("precision", 4)
             ]);
 
             ship.addStickyEffect(new StickyEffect(new AttributeLimitEffect("precision", 2), 4));
-            expect(imaterialize(ship.ieffects())).toEqual([
+            check.equals(imaterialize(ship.ieffects()), [
                 new AttributeEffect("precision", 4),
                 new AttributeLimitEffect("precision", 2)
             ]);
         });
 
-        it("gets a textual description of an attribute", function () {
+        test.case("gets a textual description of an attribute", check => {
             let ship = new Ship();
-            expect(ship.getAttributeDescription("skill_photons")).toEqual("Forces of light, and electromagnetic radiation");
+            check.equals(ship.getAttributeDescription("skill_photons"), "Forces of light, and electromagnetic radiation");
 
             let equipment = new Equipment(SlotType.Engine);
             equipment.effects = [new AttributeEffect("skill_photons", 4)];
             equipment.name = "Photonic engine";
             ship.addSlot(SlotType.Engine).attach(equipment);
-            expect(ship.getAttribute("skill_photons")).toBe(4);
-            expect(ship.getAttributeDescription("skill_photons")).toEqual("Forces of light, and electromagnetic radiation\n\nPhotonic engine Mk1: +4");
+            check.equals(ship.getAttribute("skill_photons"), 4);
+            check.equals(ship.getAttributeDescription("skill_photons"), "Forces of light, and electromagnetic radiation\n\nPhotonic engine Mk1: +4");
 
             ship.level.forceLevelUp();
             ship.upgradeSkill("skill_photons");
             ship.upgradeSkill("skill_photons");
-            expect(ship.getAttributeDescription("skill_photons")).toEqual("Forces of light, and electromagnetic radiation\n\nLevelled up: +2\nPhotonic engine Mk1: +4");
+            check.equals(ship.getAttributeDescription("skill_photons"), "Forces of light, and electromagnetic radiation\n\nLevelled up: +2\nPhotonic engine Mk1: +4");
 
             ship.addStickyEffect(new StickyEffect(new AttributeLimitEffect("skill_photons", 3)));
-            expect(ship.getAttributeDescription("skill_photons")).toEqual("Forces of light, and electromagnetic radiation\n\nLevelled up: +2\nPhotonic engine Mk1: +4\n???: limit to 3");
+            check.equals(ship.getAttributeDescription("skill_photons"), "Forces of light, and electromagnetic radiation\n\nLevelled up: +2\nPhotonic engine Mk1: +4\n???: limit to 3");
         });
     });
 }

src/core/ShipGenerator.spec.ts

@@ -1,20 +1,20 @@
 module TK.SpaceTac.Specs {
-    describe("ShipGenerator", function () {
-        it("can use ship model", function () {
+    testing("ShipGenerator", test => {
+        test.case("can use ship model", check => {
             var gen = new ShipGenerator();
             var model = new ShipModel("test", "Test", 1, 2, true, 3);
             var ship = gen.generate(1, model);
-            expect(ship.model).toBe(model);
-            expect(ship.cargo_space).toBe(2);
-            expect(ship.slots.length).toBe(7);
-            expect(ship.slots[0].type).toBe(SlotType.Hull);
-            expect(ship.slots[1].type).toBe(SlotType.Shield);
-            expect(ship.slots[2].type).toBe(SlotType.Power);
-            expect(ship.slots[3].type).toBe(SlotType.Engine);
-            expect(ship.slots[4].type).toBe(SlotType.Weapon);
-            expect(ship.slots[5].type).toBe(SlotType.Weapon);
-            expect(ship.slots[6].type).toBe(SlotType.Weapon);
-            expect(ship.getAttribute("skill_materials")).toBe(1);
+            check.same(ship.model, model);
+            check.equals(ship.cargo_space, 2);
+            check.equals(ship.slots.length, 7);
+            check.same(ship.slots[0].type, SlotType.Hull);
+            check.same(ship.slots[1].type, SlotType.Shield);
+            check.same(ship.slots[2].type, SlotType.Power);
+            check.same(ship.slots[3].type, SlotType.Engine);
+            check.same(ship.slots[4].type, SlotType.Weapon);
+            check.same(ship.slots[5].type, SlotType.Weapon);
+            check.same(ship.slots[6].type, SlotType.Weapon);
+            check.equals(ship.getAttribute("skill_materials"), 1);
         });
     });
 }

src/core/ShipLevel.spec.ts

@@ -1,62 +1,62 @@
 module TK.SpaceTac.Specs {
-    describe("ShipLevel", () => {
-        it("level up from experience points", () => {
+    testing("ShipLevel", test => {
+        test.case("level up from experience points", check => {
             let level = new ShipLevel();
-            expect(level.get()).toEqual(1);
-            expect(level.getNextGoal()).toEqual(100);
-            expect(level.getSkillPoints()).toEqual(10);
+            check.equals(level.get(), 1);
+            check.equals(level.getNextGoal(), 100);
+            check.equals(level.getSkillPoints(), 10);
 
             level.addExperience(60);  // 60
-            expect(level.get()).toEqual(1);
-            expect(level.checkLevelUp()).toBe(false);
+            check.equals(level.get(), 1);
+            check.equals(level.checkLevelUp(), false);
 
             level.addExperience(70);  // 130
-            expect(level.get()).toEqual(1);
-            expect(level.checkLevelUp()).toBe(true);
-            expect(level.get()).toEqual(2);
-            expect(level.getNextGoal()).toEqual(300);
-            expect(level.getSkillPoints()).toEqual(15);
+            check.equals(level.get(), 1);
+            check.equals(level.checkLevelUp(), true);
+            check.equals(level.get(), 2);
+            check.equals(level.getNextGoal(), 300);
+            check.equals(level.getSkillPoints(), 15);
 
             level.addExperience(200);  // 330
-            expect(level.get()).toEqual(2);
-            expect(level.checkLevelUp()).toBe(true);
-            expect(level.get()).toEqual(3);
-            expect(level.getNextGoal()).toEqual(600);
-            expect(level.getSkillPoints()).toEqual(20);
+            check.equals(level.get(), 2);
+            check.equals(level.checkLevelUp(), true);
+            check.equals(level.get(), 3);
+            check.equals(level.getNextGoal(), 600);
+            check.equals(level.getSkillPoints(), 20);
 
             level.addExperience(320);  // 650
-            expect(level.get()).toEqual(3);
-            expect(level.checkLevelUp()).toBe(true);
-            expect(level.get()).toEqual(4);
-            expect(level.getNextGoal()).toEqual(1000);
-            expect(level.getSkillPoints()).toEqual(25);
+            check.equals(level.get(), 3);
+            check.equals(level.checkLevelUp(), true);
+            check.equals(level.get(), 4);
+            check.equals(level.getNextGoal(), 1000);
+            check.equals(level.getSkillPoints(), 25);
         });
 
-        it("forces a given level", () => {
+        test.case("forces a given level", check => {
             let level = new ShipLevel();
-            expect(level.get()).toEqual(1);
+            check.equals(level.get(), 1);
 
             level.forceLevel(10);
-            expect(level.get()).toEqual(10);
+            check.equals(level.get(), 10);
         });
 
-        it("computes needed level for given points", function () {
-            expect(ShipLevel.getLevelForPoints(0)).toBe(1);
-            expect(ShipLevel.getLevelForPoints(1)).toBe(1);
-            expect(ShipLevel.getLevelForPoints(2)).toBe(1);
-            expect(ShipLevel.getLevelForPoints(5)).toBe(1);
-            expect(ShipLevel.getLevelForPoints(10)).toBe(1);
-            expect(ShipLevel.getLevelForPoints(11)).toBe(2);
-            expect(ShipLevel.getLevelForPoints(15)).toBe(2);
-            expect(ShipLevel.getLevelForPoints(16)).toBe(3);
-            expect(ShipLevel.getLevelForPoints(526)).toBe(105);
+        test.case("computes needed level for given points", check => {
+            check.equals(ShipLevel.getLevelForPoints(0), 1);
+            check.equals(ShipLevel.getLevelForPoints(1), 1);
+            check.equals(ShipLevel.getLevelForPoints(2), 1);
+            check.equals(ShipLevel.getLevelForPoints(5), 1);
+            check.equals(ShipLevel.getLevelForPoints(10), 1);
+            check.equals(ShipLevel.getLevelForPoints(11), 2);
+            check.equals(ShipLevel.getLevelForPoints(15), 2);
+            check.equals(ShipLevel.getLevelForPoints(16), 3);
+            check.equals(ShipLevel.getLevelForPoints(526), 105);
         });
 
-        it("computes needed points for given level", function () {
-            expect(ShipLevel.getPointsForLevel(1)).toBe(10);
-            expect(ShipLevel.getPointsForLevel(2)).toBe(15);
-            expect(ShipLevel.getPointsForLevel(3)).toBe(20);
-            expect(ShipLevel.getPointsForLevel(105)).toBe(530);
+        test.case("computes needed points for given level", check => {
+            check.equals(ShipLevel.getPointsForLevel(1), 10);
+            check.equals(ShipLevel.getPointsForLevel(2), 15);
+            check.equals(ShipLevel.getPointsForLevel(3), 20);
+            check.equals(ShipLevel.getPointsForLevel(105), 530);
         });
     });
 }

src/core/ShipModel.spec.ts

@@ -1,6 +1,6 @@
 module TK.SpaceTac.Specs {
-    describe("ShipModel", () => {
-        it("picks random models from default collection", function () {
+    testing("ShipModel", test => {
+        test.case("picks random models from default collection", check => {
             spyOn(console, "error").and.stub();
             spyOn(ShipModel, "getDefaultCollection").and.returnValues(
                 [new ShipModel("a")],
@@ -10,12 +10,12 @@ module TK.SpaceTac.Specs {
                 [],
             );
 
-            expect(ShipModel.getRandomModel()).toEqual(new ShipModel("a"), "pick from a one-item list");
-            expect(ShipModel.getRandomModel()).toEqual(new ShipModel(), "pick from an empty list");
+            check.equals(ShipModel.getRandomModel(), new ShipModel("a"), "pick from a one-item list");
+            check.equals(ShipModel.getRandomModel(), new ShipModel(), "pick from an empty list");
 
-            expect(sorted(ShipModel.getRandomModels(2), (a, b) => cmp(a.code, b.code))).toEqual([new ShipModel("a"), new ShipModel("b")], "sample from good-sized list");
-            expect(ShipModel.getRandomModels(2)).toEqual([new ShipModel("a"), new ShipModel("a")], "sample from too small list");
-            expect(ShipModel.getRandomModels(2)).toEqual([new ShipModel(), new ShipModel()], "sample from empty list");
+            check.equals(sorted(ShipModel.getRandomModels(2), (a, b) => cmp(a.code, b.code)), [new ShipModel("a"), new ShipModel("b")], "sample from good-sized list");
+            check.equals(ShipModel.getRandomModels(2), [new ShipModel("a"), new ShipModel("a")], "sample from too small list");
+            check.equals(ShipModel.getRandomModels(2), [new ShipModel(), new ShipModel()], "sample from empty list");
         });
     });
 }

src/core/ShipValue.spec.ts

@@ -1,72 +1,72 @@
 module TK.SpaceTac {
-    describe("ShipValue", function () {
-        it("is initially not limited", function () {
+    testing("ShipValue", test => {
+        test.case("is initially not limited", check => {
             var attr = new ShipValue("test");
 
             attr.set(8888888);
-            expect(attr.get()).toBe(8888888);
+            check.equals(attr.get(), 8888888);
         });
 
-        it("applies minimal and maximal value", function () {
+        test.case("applies minimal and maximal value", check => {
             var attr = new ShipValue("test", 50, 100);
-            expect(attr.get()).toBe(50);
+            check.equals(attr.get(), 50);
 
             attr.add(8);
-            expect(attr.get()).toBe(58);
+            check.equals(attr.get(), 58);
 
             attr.add(60);
-            expect(attr.get()).toBe(100);
+            check.equals(attr.get(), 100);
 
             attr.add(-72);
-            expect(attr.get()).toBe(28);
+            check.equals(attr.get(), 28);
 
             attr.add(-60);
-            expect(attr.get()).toBe(0);
+            check.equals(attr.get(), 0);
 
             attr.set(8);
-            expect(attr.get()).toBe(8);
+            check.equals(attr.get(), 8);
 
             attr.set(-4);
-            expect(attr.get()).toBe(0);
+            check.equals(attr.get(), 0);
 
             attr.set(105);
-            expect(attr.get()).toBe(100);
+            check.equals(attr.get(), 100);
 
             attr.setMaximal(50);
-            expect(attr.get()).toBe(50);
+            check.equals(attr.get(), 50);
 
             attr.setMaximal(80);
-            expect(attr.get()).toBe(50);
+            check.equals(attr.get(), 50);
         });
 
-        it("tells the value variation", function () {
+        test.case("tells the value variation", check => {
             var result: number;
             var attr = new ShipValue("test", 50, 100);
-            expect(attr.get()).toBe(50);
+            check.equals(attr.get(), 50);
 
             result = attr.set(51);
-            expect(result).toBe(1);
+            check.equals(result, 1);
 
             result = attr.set(51);
-            expect(result).toBe(0);
+            check.equals(result, 0);
 
             result = attr.add(1);
-            expect(result).toBe(1);
+            check.equals(result, 1);
 
             result = attr.add(0);
-            expect(result).toBe(0);
+            check.equals(result, 0);
 
             result = attr.add(1000);
-            expect(result).toBe(48);
+            check.equals(result, 48);
 
             result = attr.add(2000);
-            expect(result).toBe(0);
+            check.equals(result, 0);
 
             result = attr.set(-500);
-            expect(result).toBe(-100);
+            check.same(result, -100);
 
             result = attr.add(-600);
-            expect(result).toBe(0);
+            check.equals(result, 0);
         });
     });
 }

src/core/Shop.spec.ts

@@ -1,12 +1,12 @@
 module TK.SpaceTac.Specs {
-    describe("Shop", () => {
-        it("generates a stock", () => {
+    testing("Shop", test => {
+        test.case("generates a stock", check => {
             let shop = new Shop();
-            expect((<any>shop).stock.length).toBe(0);
+            check.equals((<any>shop).stock.length, 0);
             expect(shop.getStock().length).toBeGreaterThan(20);
         });
 
-        it("buys and sells items", function () {
+        test.case("buys and sells items", check => {
             let equ1 = new Equipment(SlotType.Shield, "shield");
             equ1.price = 50;
             let equ2 = new Equipment(SlotType.Hull, "hull");
@@ -17,54 +17,54 @@ module TK.SpaceTac.Specs {
             spyOn(shop, "getPrice").and.returnValue(800);
 
             let result = shop.sellToFleet(equ1, fleet);
-            expect(result).toBe(true);
-            expect(shop.getStock()).toEqual([equ2]);
-            expect(fleet.credits).toEqual(200);
+            check.equals(result, true);
+            check.equals(shop.getStock(), [equ2]);
+            check.equals(fleet.credits, 200);
             result = shop.sellToFleet(equ2, fleet);
-            expect(result).toBe(false);
-            expect(shop.getStock()).toEqual([equ2]);
-            expect(fleet.credits).toEqual(200);
+            check.equals(result, false);
+            check.equals(shop.getStock(), [equ2]);
+            check.equals(fleet.credits, 200);
 
             result = shop.buyFromFleet(equ1, fleet);
-            expect(result).toBe(true);
-            expect(shop.getStock()).toEqual([equ1, equ2]);
-            expect(fleet.credits).toEqual(1000);
+            check.equals(result, true);
+            check.equals(shop.getStock(), [equ1, equ2]);
+            check.equals(fleet.credits, 1000);
         });
 
-        it("generates secondary missions", function () {
+        test.case("generates secondary missions", check => {
             let universe = new Universe();
             universe.generate(4);
             let start = universe.getStartLocation();
 
             let shop = new Shop();
-            expect((<any>shop).missions.length).toBe(0);
+            check.equals((<any>shop).missions.length, 0);
 
             let result = shop.getMissions(start, 4);
-            expect(result.length).toBe(4);
-            expect((<any>shop).missions.length).toBe(4);
+            check.equals(result.length, 4);
+            check.equals((<any>shop).missions.length, 4);
 
             let oresult = shop.getMissions(start, 4);
-            expect(oresult).toEqual(result);
+            check.equals(oresult, result);
 
             result.forEach(mission => {
-                expect(mission.main).toBe(false);
+                check.equals(mission.main, false);
             });
         });
 
-        it("assigns missions to a fleet", function () {
+        test.case("assigns missions to a fleet", check => {
             let shop = new Shop();
             let player = new Player();
             let mission = new Mission(new Universe());
             (<any>shop).missions = [mission];
 
-            expect(shop.getMissions(new StarLocation(), 1)).toEqual([mission]);
-            expect(player.missions.secondary).toEqual([]);
+            check.equals(shop.getMissions(new StarLocation(), 1), [mission]);
+            check.equals(player.missions.secondary, []);
 
             shop.acceptMission(mission, player);
 
-            expect((<any>shop).missions).toEqual([]);
-            expect(player.missions.secondary).toEqual([mission]);
-            expect(mission.fleet).toBe(player.fleet);
+            check.equals((<any>shop).missions, []);
+            check.equals(player.missions.secondary, [mission]);
+            check.same(mission.fleet, player.fleet);
         });
     });
 }

src/core/Slot.spec.ts

@@ -1,23 +1,23 @@
 module TK.SpaceTac.Specs {
-    describe("Slot", () => {
-        it("checks equipment type", () => {
+    testing("Slot", test => {
+        test.case("checks equipment type", check => {
             var ship = new Ship();
             var slot = ship.addSlot(SlotType.Engine);
 
             var equipment = new Equipment();
             equipment.slot_type = SlotType.Weapon;
 
-            expect(slot.attached).toBeNull();
+            check.equals(slot.attached, null);
             slot.attach(equipment);
-            expect(slot.attached).toBeNull();
+            check.equals(slot.attached, null);
 
             equipment.slot_type = SlotType.Engine;
 
             slot.attach(equipment);
-            expect(slot.attached).toBe(equipment);
+            check.same(slot.attached, equipment);
         });
 
-        it("checks equipment capabilities", () => {
+        test.case("checks equipment capabilities", check => {
             var ship = new Ship();
             var slot = ship.addSlot(SlotType.Shield);
 
@@ -25,14 +25,14 @@ module TK.SpaceTac.Specs {
             equipment.slot_type = SlotType.Shield;
             equipment.requirements["skill_gravity"] = 5;
 
-            expect(slot.attached).toBeNull();
+            check.equals(slot.attached, null);
             slot.attach(equipment);
-            expect(slot.attached).toBeNull();
+            check.equals(slot.attached, null);
 
             ship.attributes.skill_gravity.set(6);
 
             slot.attach(equipment);
-            expect(slot.attached).toBe(equipment);
+            check.same(slot.attached, equipment);
         });
     });
 }

src/core/Star.spec.ts

@@ -1,6 +1,6 @@
 module TK.SpaceTac.Specs {
-    describe("Star", () => {
-        it("lists links to other stars", () => {
+    testing("Star", test => {
+        test.case("lists links to other stars", check => {
             var universe = new Universe();
             universe.stars.push(new Star(universe, 0, 0, "Star A"));
             universe.stars.push(new Star(universe, 1, 0, "Star B"));
@@ -10,27 +10,27 @@ module TK.SpaceTac.Specs {
             universe.addLink(universe.stars[0], universe.stars[3]);
 
             var result = universe.stars[0].getLinks();
-            expect(result.length).toBe(2);
-            expect(result[0]).toEqual(new StarLink(universe.stars[0], universe.stars[1]));
-            expect(result[1]).toEqual(new StarLink(universe.stars[0], universe.stars[3]));
+            check.equals(result.length, 2);
+            check.equals(result[0], new StarLink(universe.stars[0], universe.stars[1]));
+            check.equals(result[1], new StarLink(universe.stars[0], universe.stars[3]));
 
-            expect(universe.stars[0].getLinkTo(universe.stars[1])).toEqual(universe.starlinks[0]);
-            expect(universe.stars[0].getLinkTo(universe.stars[2])).toBeNull();
-            expect(universe.stars[0].getLinkTo(universe.stars[3])).toEqual(universe.starlinks[1]);
-            expect(universe.stars[1].getLinkTo(universe.stars[0])).toEqual(universe.starlinks[0]);
-            expect(universe.stars[1].getLinkTo(universe.stars[2])).toBeNull();
-            expect(universe.stars[1].getLinkTo(universe.stars[3])).toBeNull();
-            expect(universe.stars[2].getLinkTo(universe.stars[0])).toBeNull();
-            expect(universe.stars[2].getLinkTo(universe.stars[1])).toBeNull();
-            expect(universe.stars[2].getLinkTo(universe.stars[3])).toBeNull();
-            expect(universe.stars[3].getLinkTo(universe.stars[0])).toEqual(universe.starlinks[1]);
-            expect(universe.stars[3].getLinkTo(universe.stars[1])).toBeNull();
-            expect(universe.stars[3].getLinkTo(universe.stars[2])).toBeNull();
+            check.equals(universe.stars[0].getLinkTo(universe.stars[1]), universe.starlinks[0]);
+            check.equals(universe.stars[0].getLinkTo(universe.stars[2]), null);
+            check.equals(universe.stars[0].getLinkTo(universe.stars[3]), universe.starlinks[1]);
+            check.equals(universe.stars[1].getLinkTo(universe.stars[0]), universe.starlinks[0]);
+            check.equals(universe.stars[1].getLinkTo(universe.stars[2]), null);
+            check.equals(universe.stars[1].getLinkTo(universe.stars[3]), null);
+            check.equals(universe.stars[2].getLinkTo(universe.stars[0]), null);
+            check.equals(universe.stars[2].getLinkTo(universe.stars[1]), null);
+            check.equals(universe.stars[2].getLinkTo(universe.stars[3]), null);
+            check.equals(universe.stars[3].getLinkTo(universe.stars[0]), universe.starlinks[1]);
+            check.equals(universe.stars[3].getLinkTo(universe.stars[1]), null);
+            check.equals(universe.stars[3].getLinkTo(universe.stars[2]), null);
 
             let neighbors = universe.stars[0].getNeighbors();
-            expect(neighbors.length).toBe(2);
-            expect(neighbors).toContain(universe.stars[1]);
-            expect(neighbors).toContain(universe.stars[3]);
+            check.equals(neighbors.length, 2);
+            check.contains(neighbors, universe.stars[1]);
+            check.contains(neighbors, universe.stars[3]);
         });
     });
 }

src/core/StarLink.spec.ts

@@ -1,6 +1,6 @@
 module TK.SpaceTac.Specs {
-    describe("StarLink", () => {
-        it("checks link intersection", () => {
+    testing("StarLink", test => {
+        test.case("checks link intersection", check => {
             var star1 = new Star(null, 0, 0);
             var star2 = new Star(null, 0, 1);
             var star3 = new Star(null, 1, 0);
@@ -17,22 +17,22 @@ module TK.SpaceTac.Specs {
                     if (first !== second) {
                         var expected = (first === link3 && second === link4) ||
                             (first === link4 && second === link3);
-                        expect(first.isCrossing(second)).toBe(expected);
-                        expect(second.isCrossing(first)).toBe(expected);
+                        check.same(first.isCrossing(second), expected);
+                        check.same(second.isCrossing(first), expected);
                     }
                 });
             });
         });
 
-        it("gets the peer of a given sector", () => {
+        test.case("gets the peer of a given sector", check => {
             var star1 = new Star(null, 0, 0);
             var star2 = new Star(null, 0, 1);
             var star3 = new Star(null, 0, 1);
             var link1 = new StarLink(star1, star2);
 
-            expect(link1.getPeer(star1)).toBe(star2);
-            expect(link1.getPeer(star2)).toBe(star1);
-            expect(link1.getPeer(star3)).toBeNull();
+            check.same(link1.getPeer(star1), star2);
+            check.same(link1.getPeer(star2), star1);
+            check.equals(link1.getPeer(star3), null);
         });
     });
 }

src/core/StarLocation.spec.ts

@@ -1,33 +1,33 @@
 module TK.SpaceTac.Specs {
-    describe("StarLocation", () => {
-        it("removes generated encounters that lose", function () {
+    testing("StarLocation", test => {
+        test.case("removes generated encounters that lose", check => {
             var location = new StarLocation(undefined, StarLocationType.PLANET, 0, 0);
             var fleet = new Fleet();
             fleet.addShip();
             location.encounter_random = new SkewedRandomGenerator([0]);
             var battle = location.enterLocation(fleet);
 
-            expect(location.encounter).not.toBeNull();
-            expect(battle).not.toBeNull();
+            check.notequals(location.encounter, null);
+            check.notequals(battle, null);
 
             nn(battle).endBattle(fleet);
 
-            expect(location.encounter).toBeNull();
+            check.equals(location.encounter, null);
         });
 
-        it("leaves generated encounters that win", function () {
+        test.case("leaves generated encounters that win", check => {
             var location = new StarLocation(undefined, StarLocationType.PLANET, 0, 0);
             var fleet = new Fleet();
             fleet.addShip();
             location.encounter_random = new SkewedRandomGenerator([0]);
             var battle = location.enterLocation(fleet);
 
-            expect(location.encounter).not.toBeNull();
-            expect(battle).not.toBeNull();
+            check.notequals(location.encounter, null);
+            check.notequals(battle, null);
 
             nn(battle).endBattle(location.encounter);
 
-            expect(location.encounter).not.toBeNull();
+            check.notequals(location.encounter, null);
         });
     });
 }

src/core/Target.spec.ts

@@ -1,62 +1,62 @@
 module TK.SpaceTac.Specs {
-    describe("Target", () => {
-        it("initializes from ship or location", () => {
+    testing("Target", test => {
+        test.case("initializes from ship or location", check => {
             var target: Target;
 
             target = Target.newFromLocation(2, 3);
-            expect(target.x).toEqual(2);
-            expect(target.y).toEqual(3);
-            expect(target.ship).toBeNull();
+            check.equals(target.x, 2);
+            check.equals(target.y, 3);
+            check.equals(target.ship, null);
 
             var ship = new Ship();
             ship.arena_x = 4;
             ship.arena_y = -2.1;
             target = Target.newFromShip(ship);
-            expect(target.x).toEqual(4);
-            expect(target.y).toEqual(-2.1);
-            expect(target.ship).toBe(ship);
+            check.equals(target.x, 4);
+            check.equals(target.y, -2.1);
+            check.same(target.ship, ship);
         });
 
-        it("gets distance to another target", () => {
+        test.case("gets distance to another target", check => {
             var t1 = Target.newFromLocation(5, 1);
             var t2 = Target.newFromLocation(6, 2);
-            expect(t1.getDistanceTo(t2)).toBeCloseTo(Math.sqrt(2), 0.00001);
+            check.nears(t1.getDistanceTo(t2), Math.sqrt(2));
         });
 
-        it("gets angle to another target", () => {
+        test.case("gets angle to another target", check => {
             var t1 = Target.newFromLocation(2, 3);
             var t2 = Target.newFromLocation(4, 5);
-            expect(t1.getAngleTo(t2)).toBeCloseTo(Math.PI / 4, 0.0000001);
+            check.nears(t1.getAngleTo(t2), Math.PI / 4);
         });
 
-        it("checks if a target is in range of another", () => {
+        test.case("checks if a target is in range of another", check => {
             var t1 = Target.newFromLocation(5, 4);
-            expect(t1.isInRange(7, 3, 2)).toBe(false);
-            expect(t1.isInRange(7, 3, 3)).toBe(true);
-            expect(t1.isInRange(5, 5, 2)).toBe(true);
+            check.equals(t1.isInRange(7, 3, 2), false);
+            check.equals(t1.isInRange(7, 3, 3), true);
+            check.equals(t1.isInRange(5, 5, 2), true);
         });
 
-        it("constraints a target to a limited range", () => {
+        test.case("constraints a target to a limited range", check => {
             var target = Target.newFromLocation(5, 9);
-            expect(target.constraintInRange(1, 1, Math.sqrt(80) * 0.5)).toEqual(Target.newFromLocation(3, 5));
-            expect(target.constraintInRange(1, 1, 70)).toBe(target);
+            check.equals(target.constraintInRange(1, 1, Math.sqrt(80) * 0.5), Target.newFromLocation(3, 5));
+            check.same(target.constraintInRange(1, 1, 70), target);
         });
 
-        it("pushes a target out of a given circle", () => {
+        test.case("pushes a target out of a given circle", check => {
             var target = Target.newFromLocation(5, 5);
-            expect(target.moveOutOfCircle(0, 0, 3, 0, 0)).toBe(target);
-            expect(target.moveOutOfCircle(6, 6, 3, 0, 0)).toEqual(Target.newFromLocation(3.8786796564403576, 3.8786796564403576));
-            expect(target.moveOutOfCircle(4, 4, 3, 10, 10)).toEqual(Target.newFromLocation(6.121320343559642, 6.121320343559642));
-            expect(target.moveOutOfCircle(5, 8, 6, 5, 0)).toEqual(Target.newFromLocation(5, 2));
-            expect(target.moveOutOfCircle(5, 2, 6, 5, 10)).toEqual(Target.newFromLocation(5, 8));
-            expect(target.moveOutOfCircle(8, 5, 6, 0, 5)).toEqual(Target.newFromLocation(2, 5));
-            expect(target.moveOutOfCircle(2, 5, 6, 10, 5)).toEqual(Target.newFromLocation(8, 5));
+            check.same(target.moveOutOfCircle(0, 0, 3, 0, 0), target);
+            check.equals(target.moveOutOfCircle(6, 6, 3, 0, 0), Target.newFromLocation(3.8786796564403576, 3.8786796564403576));
+            check.equals(target.moveOutOfCircle(4, 4, 3, 10, 10), Target.newFromLocation(6.121320343559642, 6.121320343559642));
+            check.equals(target.moveOutOfCircle(5, 8, 6, 5, 0), Target.newFromLocation(5, 2));
+            check.equals(target.moveOutOfCircle(5, 2, 6, 5, 10), Target.newFromLocation(5, 8));
+            check.equals(target.moveOutOfCircle(8, 5, 6, 0, 5), Target.newFromLocation(2, 5));
+            check.equals(target.moveOutOfCircle(2, 5, 6, 10, 5), Target.newFromLocation(8, 5));
         });
 
-        it("keeps a target inside a rectangle", () => {
+        test.case("keeps a target inside a rectangle", check => {
             var target = Target.newFromLocation(5, 5);
-            expect(target.keepInsideRectangle(0, 0, 10, 10, 0, 0)).toBe(target);
-            expect(target.keepInsideRectangle(8, 0, 13, 10, 10, 5)).toEqual(Target.newFromLocation(8, 5));
+            check.same(target.keepInsideRectangle(0, 0, 10, 10, 0, 0), target);
+            check.equals(target.keepInsideRectangle(8, 0, 13, 10, 10, 5), Target.newFromLocation(8, 5));
         });
     });
 }

src/core/TestTools.spec.ts

@@ -1,33 +1,33 @@
 module TK.SpaceTac.Specs {
-    describe("TestTools", () => {
-        it("set ship power", () => {
+    testing("TestTools", test => {
+        test.case("set ship power", check => {
             let ship = new Ship();
 
-            expect(ship.getAttribute("power_capacity")).toBe(0);
-            expect(ship.getAttribute("power_generation")).toBe(0);
-            expect(ship.getValue("power")).toBe(0);
+            check.equals(ship.getAttribute("power_capacity"), 0);
+            check.equals(ship.getAttribute("power_generation"), 0);
+            check.equals(ship.getValue("power"), 0);
 
             TestTools.setShipAP(ship, 12, 4);
 
-            expect(ship.getAttribute("power_capacity")).toBe(12);
-            expect(ship.getAttribute("power_generation")).toBe(4);
-            expect(ship.getValue("power")).toBe(12);
+            check.equals(ship.getAttribute("power_capacity"), 12);
+            check.equals(ship.getAttribute("power_generation"), 4);
+            check.equals(ship.getValue("power"), 12);
         });
 
-        it("set ship health", () => {
+        test.case("set ship health", check => {
             let ship = new Ship();
 
-            expect(ship.getAttribute("hull_capacity")).toBe(0);
-            expect(ship.getAttribute("shield_capacity")).toBe(0);
-            expect(ship.getValue("hull")).toBe(0);
-            expect(ship.getValue("shield")).toBe(0);
+            check.equals(ship.getAttribute("hull_capacity"), 0);
+            check.equals(ship.getAttribute("shield_capacity"), 0);
+            check.equals(ship.getValue("hull"), 0);
+            check.equals(ship.getValue("shield"), 0);
 
             TestTools.setShipHP(ship, 100, 200);
 
-            expect(ship.getAttribute("hull_capacity")).toBe(100);
-            expect(ship.getAttribute("shield_capacity")).toBe(200);
-            expect(ship.getValue("hull")).toBe(100);
-            expect(ship.getValue("shield")).toBe(200);
+            check.equals(ship.getAttribute("hull_capacity"), 100);
+            check.equals(ship.getAttribute("shield_capacity"), 200);
+            check.equals(ship.getValue("hull"), 100);
+            check.equals(ship.getValue("shield"), 200);
         });
     });
 }

src/core/Universe.spec.ts

@@ -1,26 +1,26 @@
 module TK.SpaceTac.Specs {
-    describe("Universe", () => {
-        it("generates star systems", () => {
+    testing("Universe", test => {
+        test.case("generates star systems", check => {
             var universe = new Universe();
             var result = universe.generateStars(31);
 
-            expect(result.length).toBe(31);
+            check.equals(result.length, 31);
         });
 
-        it("lists potential links between star systems", () => {
+        test.case("lists potential links between star systems", check => {
             var universe = new Universe();
             universe.stars.push(new Star(universe, 0, 0));
             universe.stars.push(new Star(universe, 0, 1));
             universe.stars.push(new Star(universe, 1, 0));
 
             var result = universe.getPotentialLinks();
-            expect(result.length).toBe(3);
-            expect(result[0]).toEqual(new StarLink(universe.stars[0], universe.stars[1]));
-            expect(result[1]).toEqual(new StarLink(universe.stars[0], universe.stars[2]));
-            expect(result[2]).toEqual(new StarLink(universe.stars[1], universe.stars[2]));
+            check.equals(result.length, 3);
+            check.equals(result[0], new StarLink(universe.stars[0], universe.stars[1]));
+            check.equals(result[1], new StarLink(universe.stars[0], universe.stars[2]));
+            check.equals(result[2], new StarLink(universe.stars[1], universe.stars[2]));
         });
 
-        it("filters out crossing links", () => {
+        test.case("filters out crossing links", check => {
             var universe = new Universe();
             universe.stars.push(new Star(universe, 0, 0));
             universe.stars.push(new Star(universe, 0, 1));
@@ -28,15 +28,15 @@ module TK.SpaceTac.Specs {
             universe.stars.push(new Star(universe, 2, 2));
 
             var result = universe.getPotentialLinks();
-            expect(result.length).toBe(6);
+            check.equals(result.length, 6);
 
             var filtered = universe.filterCrossingLinks(result);
-            expect(filtered.length).toBe(5);
-            expect(any(filtered, link => link.isLinking(universe.stars[1], universe.stars[2]))).toBe(true);
-            expect(any(filtered, link => link.isLinking(universe.stars[0], universe.stars[3]))).toBe(false);
+            check.equals(filtered.length, 5);
+            check.equals(any(filtered, link => link.isLinking(universe.stars[1], universe.stars[2])), true);
+            check.equals(any(filtered, link => link.isLinking(universe.stars[0], universe.stars[3])), false);
         });
 
-        it("filters out redundant links", () => {
+        test.case("filters out redundant links", check => {
             let universe = new Universe();
             let s1 = universe.addStar(1, "S1", 0, 0);
             let s2 = universe.addStar(1, "S2", 0, 1);
@@ -52,12 +52,12 @@ module TK.SpaceTac.Specs {
             ]
 
             let filtered = universe.filterRedundantLinks(links);
-            expect(filtered.length).toBe(4);
-            expect(filtered).toContain(links[0]);
-            expect(filtered).not.toContain(links[2]);
+            check.equals(filtered.length, 4);
+            check.contains(filtered, links[0]);
+            check.notcontains(filtered, links[2]);
         });
 
-        it("generates warp locations", () => {
+        test.case("generates warp locations", check => {
             var universe = new Universe();
             universe.stars.push(new Star(universe, 0, 0, "0"));
             universe.stars.push(new Star(universe, 1, 0, "1"));
@@ -75,28 +75,28 @@ module TK.SpaceTac.Specs {
                 return result;
             };
 
-            expect(getWarps(universe.stars[0]).length).toBe(0);
-            expect(getWarps(universe.stars[1]).length).toBe(0);
-            expect(getWarps(universe.stars[2]).length).toBe(0);
+            check.equals(getWarps(universe.stars[0]).length, 0);
+            check.equals(getWarps(universe.stars[1]).length, 0);
+            check.equals(getWarps(universe.stars[2]).length, 0);
 
             universe.generateWarpLocations();
 
             var warps = getWarps(universe.stars[0]);
-            expect(warps.length).toBe(2);
-            expect(nn(warps[0].jump_dest).star).toBe(universe.stars[1]);
-            expect(nn(warps[1].jump_dest).star).toBe(universe.stars[2]);
-            expect(universe.stars[0].getWarpLocationTo(universe.stars[1])).toBe(warps[0]);
-            expect(universe.stars[0].getWarpLocationTo(universe.stars[2])).toBe(warps[1]);
+            check.equals(warps.length, 2);
+            check.same(nn(warps[0].jump_dest).star, universe.stars[1]);
+            check.same(nn(warps[1].jump_dest).star, universe.stars[2]);
+            check.same(universe.stars[0].getWarpLocationTo(universe.stars[1]), warps[0]);
+            check.same(universe.stars[0].getWarpLocationTo(universe.stars[2]), warps[1]);
             warps = getWarps(universe.stars[1]);
-            expect(warps.length).toBe(1);
-            expect(nn(warps[0].jump_dest).star).toBe(universe.stars[0]);
-            expect(universe.stars[1].getWarpLocationTo(universe.stars[2])).toBeNull();
+            check.equals(warps.length, 1);
+            check.same(nn(warps[0].jump_dest).star, universe.stars[0]);
+            check.equals(universe.stars[1].getWarpLocationTo(universe.stars[2]), null);
             warps = getWarps(universe.stars[2]);
-            expect(warps.length).toBe(1);
-            expect(nn(warps[0].jump_dest).star).toBe(universe.stars[0]);
+            check.equals(warps.length, 1);
+            check.same(nn(warps[0].jump_dest).star, universe.stars[0]);
         });
 
-        it("generates danger gradients", function () {
+        test.case("generates danger gradients", check => {
             let universe = new Universe();
 
             universe.stars.push(new Star(universe));
@@ -110,10 +110,10 @@ module TK.SpaceTac.Specs {
             universe.addLink(universe.stars[3], universe.stars[2]);
 
             universe.setEncounterLevels(9);
-            expect(universe.stars.map(star => star.level).sort(cmp)).toEqual([1, 5, 5, 9]);
+            check.equals(universe.stars.map(star => star.level).sort(cmp), [1, 5, 5, 9]);
         });
 
-        it("gets a good start location", function () {
+        test.case("gets a good start location", check => {
             let universe = new Universe();
 
             universe.stars.push(new Star(universe));
@@ -126,7 +126,7 @@ module TK.SpaceTac.Specs {
 
             universe.stars[1].generateLocations(5);
 
-            expect(universe.getStartLocation()).toBe(universe.stars[1].locations[0]);
+            check.same(universe.getStartLocation(), universe.stars[1].locations[0]);
         });
     });
 }

src/core/actions/BaseAction.spec.ts

@@ -1,6 +1,6 @@
 module TK.SpaceTac {
-    describe("BaseAction", function () {
-        it("check if equipment can be used with remaining AP", function () {
+    testing("BaseAction", test => {
+        test.case("check if equipment can be used with remaining AP", check => {
             var equipment = new Equipment(SlotType.Hull);
             var action = new BaseAction("test", "Test", equipment);
             spyOn(action, "getActionPointsUsage").and.returnValue(3);
@@ -8,65 +8,65 @@ module TK.SpaceTac {
             ship.addSlot(SlotType.Hull).attach(equipment);
             ship.values.power.setMaximal(10);
 
-            expect(action.checkCannotBeApplied(ship)).toBe("not enough power");
+            check.equals(action.checkCannotBeApplied(ship), "not enough power");
 
             ship.values.power.set(5);
 
-            expect(action.checkCannotBeApplied(ship)).toBe(null);
-            expect(action.checkCannotBeApplied(ship, 4)).toBe(null);
-            expect(action.checkCannotBeApplied(ship, 3)).toBe(null);
-            expect(action.checkCannotBeApplied(ship, 2)).toBe("not enough power");
+            check.equals(action.checkCannotBeApplied(ship), null);
+            check.equals(action.checkCannotBeApplied(ship, 4), null);
+            check.equals(action.checkCannotBeApplied(ship, 3), null);
+            check.equals(action.checkCannotBeApplied(ship, 2), "not enough power");
 
             ship.values.power.set(3);
 
-            expect(action.checkCannotBeApplied(ship)).toBe(null);
+            check.equals(action.checkCannotBeApplied(ship), null);
 
             ship.values.power.set(2);
 
-            expect(action.checkCannotBeApplied(ship)).toBe("not enough power");
+            check.equals(action.checkCannotBeApplied(ship), "not enough power");
         })
 
-        it("check if equipment can be used with overheat", function () {
+        test.case("check if equipment can be used with overheat", check => {
             let equipment = new Equipment();
             let action = new BaseAction("test", "Test", equipment);
             let ship = new Ship();
 
-            expect(action.checkCannotBeApplied(ship)).toBe(null);
-            expect(action.getUsesBeforeOverheat()).toBe(Infinity);
+            check.equals(action.checkCannotBeApplied(ship), null);
+            check.same(action.getUsesBeforeOverheat(), Infinity);
 
             equipment.cooldown.use();
-            expect(action.checkCannotBeApplied(ship)).toBe(null);
-            expect(action.getUsesBeforeOverheat()).toBe(Infinity);
+            check.equals(action.checkCannotBeApplied(ship), null);
+            check.same(action.getUsesBeforeOverheat(), Infinity);
 
             equipment.cooldown.configure(2, 3);
-            expect(action.checkCannotBeApplied(ship)).toBe(null);
-            expect(action.getUsesBeforeOverheat()).toBe(2);
+            check.equals(action.checkCannotBeApplied(ship), null);
+            check.equals(action.getUsesBeforeOverheat(), 2);
 
             equipment.cooldown.use();
-            expect(action.checkCannotBeApplied(ship)).toBe(null);
-            expect(action.getUsesBeforeOverheat()).toBe(1);
-            expect(action.getCooldownDuration()).toBe(0);
+            check.equals(action.checkCannotBeApplied(ship), null);
+            check.equals(action.getUsesBeforeOverheat(), 1);
+            check.equals(action.getCooldownDuration(), 0);
 
             equipment.cooldown.use();
-            expect(action.checkCannotBeApplied(ship)).toBe("overheated");
-            expect(action.getUsesBeforeOverheat()).toBe(0);
-            expect(action.getCooldownDuration()).toBe(3);
+            check.equals(action.checkCannotBeApplied(ship), "overheated");
+            check.equals(action.getUsesBeforeOverheat(), 0);
+            check.equals(action.getCooldownDuration(), 3);
 
             equipment.cooldown.cool();
-            expect(action.checkCannotBeApplied(ship)).toBe("overheated");
-            expect(action.getCooldownDuration()).toBe(2);
+            check.equals(action.checkCannotBeApplied(ship), "overheated");
+            check.equals(action.getCooldownDuration(), 2);
 
             equipment.cooldown.cool();
-            expect(action.checkCannotBeApplied(ship)).toBe("overheated");
-            expect(action.getCooldownDuration()).toBe(1);
+            check.equals(action.checkCannotBeApplied(ship), "overheated");
+            check.equals(action.getCooldownDuration(), 1);
 
             equipment.cooldown.cool();
-            expect(action.checkCannotBeApplied(ship)).toBe(null);
-            expect(action.getCooldownDuration()).toBe(0);
-            expect(action.getCooldownDuration(true)).toBe(3);
+            check.equals(action.checkCannotBeApplied(ship), null);
+            check.equals(action.getCooldownDuration(), 0);
+            check.equals(action.getCooldownDuration(true), 3);
         })
 
-        it("wears down equipment and power generators", function () {
+        test.case("wears down equipment and power generators", check => {
             let ship = new Ship();
             TestTools.setShipAP(ship, 10);
             let power = ship.listEquipment(SlotType.Power)[0];
@@ -75,12 +75,12 @@ module TK.SpaceTac {
 
             spyOn(action, "checkTarget").and.callFake((ship: Ship, target: Target) => target);
 
-            expect(power.wear).toBe(0);
-            expect(equipment.wear).toBe(0);
+            check.equals(power.wear, 0);
+            check.equals(equipment.wear, 0);
             action.apply(ship);
 
-            expect(power.wear).toBe(1);
-            expect(equipment.wear).toBe(1);
+            check.equals(power.wear, 1);
+            check.equals(equipment.wear, 1);
         })
     });
 }

src/core/actions/DeployDroneAction.spec.ts

@@ -1,28 +1,28 @@
 module TK.SpaceTac {
-    describe("DeployDroneAction", function () {
-        it("stores useful information", function () {
+    testing("DeployDroneAction", test => {
+        test.case("stores useful information", check => {
             let equipment = new Equipment(SlotType.Weapon, "testdrone");
             let action = new DeployDroneAction(equipment);
 
-            expect(action.code).toEqual("deploy-testdrone");
-            expect(action.name).toEqual("Deploy");
-            expect(action.equipment).toBe(equipment);
+            check.equals(action.code, "deploy-testdrone");
+            check.equals(action.name, "Deploy");
+            check.same(action.equipment, equipment);
         });
 
-        it("allows to deploy in range", function () {
+        test.case("allows to deploy in range", check => {
             let ship = new Ship();
             ship.setArenaPosition(0, 0);
             let action = new DeployDroneAction(new Equipment(), 0, 8);
 
-            expect(action.checkTarget(ship, new Target(8, 0, null))).toEqual(new Target(8, 0, null));
-            expect(action.checkTarget(ship, new Target(12, 0, null))).toEqual(new Target(8, 0, null));
+            check.equals(action.checkTarget(ship, new Target(8, 0, null)), new Target(8, 0, null));
+            check.equals(action.checkTarget(ship, new Target(12, 0, null)), new Target(8, 0, null));
 
             let other = new Ship();
             other.setArenaPosition(8, 0);
-            expect(action.checkTarget(ship, new Target(8, 0, other))).toBeNull();
+            check.equals(action.checkTarget(ship, new Target(8, 0, other)), null);
         });
 
-        it("deploys a new drone", function () {
+        test.case("deploys a new drone", check => {
             let battle = new Battle();
             let ship = battle.fleets[0].addShip();
             ship.setArenaPosition(0, 0);
@@ -35,23 +35,23 @@ module TK.SpaceTac {
             battle.log.addFilter("value");
             let result = action.apply(ship, new Target(5, 0, null));
 
-            expect(result).toBe(true);
-            expect(battle.drones.length).toBe(1);
+            check.equals(result, true);
+            check.equals(battle.drones.length, 1);
 
             let drone = battle.drones[0];
-            expect(drone.code).toEqual("testdrone");
-            expect(drone.duration).toEqual(2);
-            expect(drone.owner).toBe(ship);
-            expect(drone.x).toEqual(5);
-            expect(drone.y).toEqual(0);
-            expect(drone.radius).toEqual(4);
-            expect(drone.effects).toEqual([new DamageEffect(50)]);
-            expect(battle.log.events).toEqual([
+            check.equals(drone.code, "testdrone");
+            check.equals(drone.duration, 2);
+            check.same(drone.owner, ship);
+            check.equals(drone.x, 5);
+            check.equals(drone.y, 0);
+            check.equals(drone.radius, 4);
+            check.equals(drone.effects, [new DamageEffect(50)]);
+            check.equals(battle.log.events, [
                 new ActionAppliedEvent(ship, action, Target.newFromLocation(5, 0), 2),
                 new DroneDeployedEvent(drone)
             ]);
 
-            expect(ship.values.power.get()).toEqual(1);
+            check.equals(ship.values.power.get(), 1);
         });
     });
 }

src/core/actions/EndTurnAction.spec.ts

@@ -1,30 +1,30 @@
 module TK.SpaceTac.Specs {
-    describe("EndTurnAction", () => {
-        it("can't be applied to non-playing ship", () => {
+    testing("EndTurnAction", test => {
+        test.case("can't be applied to non-playing ship", check => {
             spyOn(console, "warn").and.stub();
 
             let battle = Battle.newQuickRandom();
             let action = new EndTurnAction();
 
-            expect(action.checkCannotBeApplied(battle.play_order[0])).toBe(null);
-            expect(action.checkCannotBeApplied(battle.play_order[1])).toBe("ship not playing");
+            check.equals(action.checkCannotBeApplied(battle.play_order[0]), null);
+            check.equals(action.checkCannotBeApplied(battle.play_order[1]), "ship not playing");
 
             let ship = battle.play_order[1];
             let result = action.apply(battle.play_order[1]);
-            expect(result).toBe(false);
+            check.equals(result, false);
 
             expect(console.warn).toHaveBeenCalledWith("Action rejected - ship not playing", ship, action, Target.newFromShip(ship));
         });
 
-        it("ends turn when applied", () => {
+        test.case("ends turn when applied", check => {
             let battle = Battle.newQuickRandom();
             let action = new EndTurnAction();
 
-            expect(battle.play_index).toBe(0);
+            check.equals(battle.play_index, 0);
 
             let result = action.apply(battle.play_order[0], Target.newFromShip(battle.play_order[0]));
-            expect(result).toBe(true);
-            expect(battle.play_index).toBe(1);
+            check.equals(result, true);
+            check.equals(battle.play_index, 1);
         });
     });
 }

src/core/actions/MoveAction.spec.ts

@@ -1,6 +1,6 @@
 module TK.SpaceTac {
-    describe("MoveAction", function () {
-        it("checks movement against remaining AP", function () {
+    testing("MoveAction", test => {
+        test.case("checks movement against remaining AP", check => {
             var ship = new Ship();
             var battle = new Battle(ship.fleet);
             TestTools.setShipPlaying(battle, ship);
@@ -11,32 +11,32 @@ module TK.SpaceTac {
             var engine = new Equipment();
             var action = new MoveAction(engine, 10);
 
-            expect(action.getDistanceByActionPoint(ship)).toBe(10);
+            check.equals(action.getDistanceByActionPoint(ship), 10);
 
             var result = action.checkTarget(ship, Target.newFromLocation(0, 20));
-            expect(result).toEqual(Target.newFromLocation(0, 20));
+            check.equals(result, Target.newFromLocation(0, 20));
 
             result = action.checkTarget(ship, Target.newFromLocation(0, 80));
-            expect(nn(result).y).toBeCloseTo(59.9, 0.000001);
+            check.nears(nn(result).y, 59.9);
 
             ship.values.power.set(0);
             result = action.checkTarget(ship, Target.newFromLocation(0, 80));
-            expect(result).toBeNull();
+            check.equals(result, null);
         });
 
-        it("forbids targetting a ship", function () {
+        test.case("forbids targetting a ship", check => {
             var ship1 = new Ship(null, "Test1");
             var ship2 = new Ship(null, "Test2");
             var action = new MoveAction(new Equipment());
 
             var result = action.checkTarget(ship1, Target.newFromShip(ship1));
-            expect(result).toBeNull();
+            check.equals(result, null);
 
             result = action.checkTarget(ship1, Target.newFromShip(ship2));
-            expect(result).toBeNull();
+            check.equals(result, null);
         });
 
-        it("applies to ship location, battle log and AP", function () {
+        test.case("applies to ship location, battle log and AP", check => {
             var ship = new Ship();
             var battle = new Battle(ship.fleet);
             ship.values.power.setMaximal(20);
@@ -50,35 +50,35 @@ module TK.SpaceTac {
             spyOn(console, "warn").and.stub();
 
             var result = action.apply(ship, Target.newFromLocation(10, 10));
-            expect(result).toBe(true);
-            expect(ship.arena_x).toBeCloseTo(3.535533, 0.00001);
-            expect(ship.arena_y).toBeCloseTo(3.535533, 0.00001);
-            expect(ship.values.power.get()).toEqual(0);
+            check.equals(result, true);
+            check.nears(ship.arena_x, 3.464823, 5);
+            check.nears(ship.arena_y, 3.464823, 5);
+            check.equals(ship.values.power.get(), 0);
 
             result = action.apply(ship, Target.newFromLocation(10, 10));
-            expect(result).toBe(false);
-            expect(ship.arena_x).toBeCloseTo(3.535533, 0.00001);
-            expect(ship.arena_y).toBeCloseTo(3.535533, 0.00001);
-            expect(ship.values.power.get()).toEqual(0);
+            check.equals(result, false);
+            check.nears(ship.arena_x, 3.464823, 5);
+            check.nears(ship.arena_y, 3.464823, 5);
+            check.equals(ship.values.power.get(), 0);
 
-            expect(battle.log.events.length).toBe(3);
+            check.equals(battle.log.events.length, 3);
 
-            expect(battle.log.events[0].code).toEqual("value");
-            expect(battle.log.events[0].ship).toBe(ship);
-            expect((<ValueChangeEvent>battle.log.events[0]).value).toEqual(
+            check.equals(battle.log.events[0].code, "value");
+            check.same(battle.log.events[0].ship, ship);
+            check.equals((<ValueChangeEvent>battle.log.events[0]).value,
                 new ShipValue("power", 0, 20));
 
-            expect(battle.log.events[1].code).toEqual("action");
-            expect(battle.log.events[1].ship).toBe(ship);
+            check.equals(battle.log.events[1].code, "action");
+            check.same(battle.log.events[1].ship, ship);
 
-            expect(battle.log.events[2].code).toEqual("move");
-            expect(battle.log.events[2].ship).toBe(ship);
+            check.equals(battle.log.events[2].code, "move");
+            check.same(battle.log.events[2].ship, ship);
             let dest = (<MoveEvent>battle.log.events[2]).end;
-            expect(dest.x).toBeCloseTo(3.535533, 0.00001);
-            expect(dest.y).toBeCloseTo(3.535533, 0.00001);
+            check.nears(dest.x, 3.464823, 5);
+            check.nears(dest.y, 3.464823, 5);
         });
 
-        it("can't move too much near another ship", function () {
+        test.case("can't move too much near another ship", check => {
             var battle = TestTools.createBattle(1, 1);
             var ship = battle.fleets[0].ships[0];
             var enemy = battle.fleets[1].ships[0];
@@ -91,22 +91,22 @@ module TK.SpaceTac {
             action.safety_distance = 200;
 
             var result = action.checkLocationTarget(ship, Target.newFromLocation(700, 500));
-            expect(result).toEqual(Target.newFromLocation(700, 500));
+            check.equals(result, Target.newFromLocation(700, 500));
 
             result = action.checkLocationTarget(ship, Target.newFromLocation(800, 500));
-            expect(result).toEqual(Target.newFromLocation(800, 500));
+            check.equals(result, Target.newFromLocation(800, 500));
 
             result = action.checkLocationTarget(ship, Target.newFromLocation(900, 500));
-            expect(result).toEqual(Target.newFromLocation(800, 500));
+            check.equals(result, Target.newFromLocation(800, 500));
 
             result = action.checkLocationTarget(ship, Target.newFromLocation(1000, 500));
-            expect(result).toEqual(Target.newFromLocation(800, 500));
+            check.equals(result, Target.newFromLocation(800, 500));
 
             result = action.checkLocationTarget(ship, Target.newFromLocation(1200, 500));
-            expect(result).toEqual(Target.newFromLocation(1200, 500));
+            check.equals(result, Target.newFromLocation(1200, 500));
         });
 
-        it("exclusion radius is applied correctly over two ships", function () {
+        test.case("exclusion radius is applied correctly over two ships", check => {
             var battle = TestTools.createBattle(1, 2);
             var ship = battle.fleets[0].ships[0];
             var enemy1 = battle.fleets[1].ships[0];
@@ -120,10 +120,10 @@ module TK.SpaceTac {
             action.safety_distance = 150;
 
             var result = action.checkLocationTarget(ship, Target.newFromLocation(0, 1100));
-            expect(result).toEqual(Target.newFromLocation(0, 650));
+            check.equals(result, Target.newFromLocation(0, 650));
         });
 
-        it("exclusion radius does not make the ship go back", function () {
+        test.case("exclusion radius does not make the ship go back", check => {
             var battle = TestTools.createBattle(1, 2);
             var ship = battle.fleets[0].ships[0];
             var enemy1 = battle.fleets[1].ships[0];
@@ -137,40 +137,40 @@ module TK.SpaceTac {
             action.safety_distance = 600;
 
             let result = action.checkLocationTarget(ship, Target.newFromLocation(0, 1000));
-            expect(result).toBeNull();
+            check.equals(result, null);
             result = action.checkLocationTarget(ship, Target.newFromLocation(0, 1400));
-            expect(result).toEqual(Target.newFromLocation(0, 1400));
+            check.equals(result, Target.newFromLocation(0, 1400));
         });
 
-        it("applies ship maneuvrability to determine distance per power point", function () {
+        test.case("applies ship maneuvrability to determine distance per power point", check => {
             let ship = new Ship();
 
             let action = new MoveAction(new Equipment(), 100, undefined, 60);
             ship.setAttribute("maneuvrability", 0);
-            expect(action.getDistanceByActionPoint(ship)).toBeCloseTo(40, 0.01);
+            check.nears(action.getDistanceByActionPoint(ship), 40);
             ship.setAttribute("maneuvrability", 1);
-            expect(action.getDistanceByActionPoint(ship)).toBeCloseTo(60, 0.01);
+            check.nears(action.getDistanceByActionPoint(ship), 60);
             ship.setAttribute("maneuvrability", 2);
-            expect(action.getDistanceByActionPoint(ship)).toBeCloseTo(70, 0.01);
+            check.nears(action.getDistanceByActionPoint(ship), 70);
             ship.setAttribute("maneuvrability", 10);
-            expect(action.getDistanceByActionPoint(ship)).toBeCloseTo(90, 0.01);
+            check.nears(action.getDistanceByActionPoint(ship), 90);
 
             action = new MoveAction(new Equipment(), 100, undefined, 0);
             ship.setAttribute("maneuvrability", 0);
-            expect(action.getDistanceByActionPoint(ship)).toBeCloseTo(100, 0.01);
+            check.nears(action.getDistanceByActionPoint(ship), 100);
             ship.setAttribute("maneuvrability", 10);
-            expect(action.getDistanceByActionPoint(ship)).toBeCloseTo(100, 0.01);
+            check.nears(action.getDistanceByActionPoint(ship), 100);
         });
 
-        it("builds a textual description", function () {
+        test.case("builds a textual description", check => {
             let action = new MoveAction(new Equipment(), 58, 0, 0);
-            expect(action.getEffectsDescription()).toEqual("Move: 58km per power point");
+            check.equals(action.getEffectsDescription(), "Move: 58km per power point");
 
             action = new MoveAction(new Equipment(), 58, 12, 0);
-            expect(action.getEffectsDescription()).toEqual("Move: 58km per power point (safety: 12km)");
+            check.equals(action.getEffectsDescription(), "Move: 58km per power point (safety: 12km)");
 
             action = new MoveAction(new Equipment(), 58, 12, 80);
-            expect(action.getEffectsDescription()).toEqual("Move: 12-58km per power point (safety: 12km)");
+            check.equals(action.getEffectsDescription(), "Move: 12-58km per power point (safety: 12km)");
         });
     });
 }

src/core/actions/ToggleAction.spec.ts

@@ -1,20 +1,20 @@
 module TK.SpaceTac {
-    describe("ToggleAction", function () {
-        it("returns correct targetting mode", function () {
+    testing("ToggleAction", test => {
+        test.case("returns correct targetting mode", check => {
             let action = new ToggleAction(new Equipment(), 1, 0, []);
-            expect(action.getTargettingMode(new Ship())).toBe(ActionTargettingMode.SELF_CONFIRM);
+            check.same(action.getTargettingMode(new Ship()), ActionTargettingMode.SELF_CONFIRM);
 
             action.activated = true;
-            expect(action.getTargettingMode(new Ship())).toBe(ActionTargettingMode.SELF_CONFIRM);
+            check.same(action.getTargettingMode(new Ship()), ActionTargettingMode.SELF_CONFIRM);
 
             action = new ToggleAction(new Equipment(), 1, 50, []);
-            expect(action.getTargettingMode(new Ship())).toBe(ActionTargettingMode.SURROUNDINGS);
+            check.same(action.getTargettingMode(new Ship()), ActionTargettingMode.SURROUNDINGS);
 
             action.activated = true;
-            expect(action.getTargettingMode(new Ship())).toBe(ActionTargettingMode.SELF_CONFIRM);
+            check.same(action.getTargettingMode(new Ship()), ActionTargettingMode.SELF_CONFIRM);
         })
 
-        it("collects impacted ships", function () {
+        test.case("collects impacted ships", check => {
             let action = new ToggleAction(new Equipment(), 1, 50, []);
             let battle = new Battle();
             let ship1 = battle.fleets[0].addShip();
@@ -25,7 +25,7 @@ module TK.SpaceTac {
             ship3.setArenaPosition(0, 60);
 
             let result = action.getImpactedShips(ship1, Target.newFromShip(ship1));
-            expect(result).toEqual([ship1, ship2]);
+            check.equals(result, [ship1, ship2]);
         });
     })
 }

src/core/actions/TriggerAction.spec.ts

@@ -1,15 +1,15 @@
 module TK.SpaceTac {
-    describe("TriggerAction", function () {
-        it("constructs correctly", function () {
+    testing("TriggerAction", test => {
+        test.case("constructs correctly", check => {
             let equipment = new Equipment(SlotType.Weapon, "testweapon");
             let action = new TriggerAction(equipment, [], 4, 30, 10);
 
-            expect(action.code).toEqual("fire-testweapon");
-            expect(action.name).toEqual("Fire");
-            expect(action.equipment).toBe(equipment);
+            check.equals(action.code, "fire-testweapon");
+            check.equals(action.name, "Fire");
+            check.same(action.equipment, equipment);
         })
 
-        it("applies effects to alive ships in blast radius", function () {
+        test.case("applies effects to alive ships in blast radius", check => {
             let fleet = new Fleet();
             let ship = new Ship(fleet, "ship");
             let equipment = new Equipment(SlotType.Weapon, "testweapon");
@@ -37,7 +37,7 @@ module TK.SpaceTac {
             expect(mock_apply).toHaveBeenCalledWith(ship2, ship);
         })
 
-        it("transforms ship target in location target, when the weapon has blast radius", function () {
+        test.case("transforms ship target in location target, when the weapon has blast radius", check => {
             let ship1 = new Ship();
             ship1.setArenaPosition(50, 10);
             let ship2 = new Ship();
@@ -46,23 +46,23 @@ module TK.SpaceTac {
             let action = nn(weapon.action);
 
             let target = action.checkTarget(ship1, new Target(150, 10));
-            expect(target).toEqual(new Target(150, 10));
+            check.equals(target, new Target(150, 10));
 
             target = action.checkTarget(ship1, Target.newFromShip(ship2));
-            expect(target).toEqual(new Target(150, 10));
+            check.equals(target, new Target(150, 10));
 
             ship1.setArenaPosition(30, 10);
 
             target = action.checkTarget(ship1, Target.newFromShip(ship2));
-            expect(target).toEqual(new Target(130, 10));
+            check.equals(target, new Target(130, 10));
 
             ship1.setArenaPosition(0, 10);
 
             target = action.checkTarget(ship1, Target.newFromShip(ship2));
-            expect(target).toEqual(new Target(100, 10));
+            check.equals(target, new Target(100, 10));
         })
 
-        it("lists impacted ships", function () {
+        test.case("lists impacted ships", check => {
             let ship1 = new Ship(null, "S1");
             ship1.setArenaPosition(10, 50);
             let ship2 = new Ship(null, "S2");
@@ -72,49 +72,49 @@ module TK.SpaceTac {
             let ships = [ship1, ship2, ship3];
 
             let action = new TriggerAction(new Equipment(), [], 1, 50);
-            expect(action.filterImpactedShips({ x: 0, y: 0 }, Target.newFromShip(ship2), ships)).toEqual([ship2]);
-            expect(action.filterImpactedShips({ x: 0, y: 0 }, Target.newFromLocation(10, 50), ships)).toEqual([]);
+            check.equals(action.filterImpactedShips({ x: 0, y: 0 }, Target.newFromShip(ship2), ships), [ship2]);
+            check.equals(action.filterImpactedShips({ x: 0, y: 0 }, Target.newFromLocation(10, 50), ships), []);
 
             action = new TriggerAction(new Equipment(), [], 1, 50, 40);
-            expect(action.filterImpactedShips({ x: 0, y: 0 }, Target.newFromLocation(20, 20), ships)).toEqual([ship1, ship3]);
+            check.equals(action.filterImpactedShips({ x: 0, y: 0 }, Target.newFromLocation(20, 20), ships), [ship1, ship3]);
 
             action = new TriggerAction(new Equipment(), [], 1, 100, 0, 30);
-            expect(action.filterImpactedShips({ x: 0, y: 51 }, Target.newFromLocation(30, 50), ships)).toEqual([ship1, ship2]);
+            check.equals(action.filterImpactedShips({ x: 0, y: 51 }, Target.newFromLocation(30, 50), ships), [ship1, ship2]);
         })
 
-        it("guesses targetting mode", function () {
+        test.case("guesses targetting mode", check => {
             let ship = new Ship();
             let equ = new Equipment();
             let action = new TriggerAction(equ, []);
-            expect(action.getTargettingMode(ship)).toEqual(ActionTargettingMode.SELF_CONFIRM, "self");
+            check.equals(action.getTargettingMode(ship), ActionTargettingMode.SELF_CONFIRM, "self");
 
             action = new TriggerAction(equ, [], 1, 50);
-            expect(action.getTargettingMode(ship)).toEqual(ActionTargettingMode.SHIP, "ship");
+            check.equals(action.getTargettingMode(ship), ActionTargettingMode.SHIP, "ship");
 
             action = new TriggerAction(equ, [], 1, 50, 20);
-            expect(action.getTargettingMode(ship)).toEqual(ActionTargettingMode.SPACE, "blast");
+            check.equals(action.getTargettingMode(ship), ActionTargettingMode.SPACE, "blast");
 
             action = new TriggerAction(equ, [], 1, 0, 20);
-            expect(action.getTargettingMode(ship)).toEqual(ActionTargettingMode.SURROUNDINGS, "surroundings");
+            check.equals(action.getTargettingMode(ship), ActionTargettingMode.SURROUNDINGS, "surroundings");
 
             action = new TriggerAction(equ, [], 1, 50, 0, 15);
-            expect(action.getTargettingMode(ship)).toEqual(ActionTargettingMode.SPACE, "angle");
+            check.equals(action.getTargettingMode(ship), ActionTargettingMode.SPACE, "angle");
         })
 
-        it("rotates toward the target", function () {
+        test.case("rotates toward the target", check => {
             let ship = new Ship();
             let weapon = TestTools.addWeapon(ship, 1, 0, 100, 30);
             let action = nn(weapon.action);
             spyOn(action, "checkTarget").and.callFake((ship: Ship, target: Target) => target);
-            expect(ship.arena_angle).toEqual(0);
+            check.equals(ship.arena_angle, 0);
 
             let result = action.apply(ship, Target.newFromLocation(10, 20));
-            expect(result).toBe(true);
-            expect(ship.arena_angle).toBeCloseTo(1.107, 0.001);
+            check.equals(result, true);
+            check.nears(ship.arena_angle, 1.107, 3);
 
             result = action.apply(ship, Target.newFromShip(ship));
-            expect(result).toBe(true);
-            expect(ship.arena_angle).toBeCloseTo(1.107, 0.001);
+            check.equals(result, true);
+            check.nears(ship.arena_angle, 1.107, 3);
         })
     });
 }

src/core/ai/Maneuver.spec.ts

@@ -1,6 +1,6 @@
 module TK.SpaceTac.Specs {
-    describe("Maneuver", function () {
-        it("guesses weapon effects", function () {
+    testing("Maneuver", test => {
+        test.case("guesses weapon effects", check => {
             let battle = new Battle();
             let ship1 = battle.fleets[0].addShip();
             let ship2 = battle.fleets[0].addShip();
@@ -13,13 +13,13 @@ module TK.SpaceTac.Specs {
             ship3.setArenaPosition(0, 15);
             TestTools.setShipHP(ship3, 30, 30);
             let maneuver = new Maneuver(ship1, nn(weapon.action), Target.newFromLocation(0, 0));
-            expect(maneuver.effects).toEqual([
+            check.equals(maneuver.effects, [
                 [ship1, new DamageEffect(50)],
                 [ship2, new DamageEffect(50)]
             ]);
         });
 
-        it("guesses drone effects", function () {
+        test.case("guesses drone effects", check => {
             let battle = new Battle();
             let ship1 = battle.fleets[0].addShip();
             let ship2 = battle.fleets[0].addShip();
@@ -33,13 +33,13 @@ module TK.SpaceTac.Specs {
             ship3.setArenaPosition(0, 15);
             TestTools.setShipHP(ship3, 30, 30);
             let maneuver = new Maneuver(ship1, weapon.action, Target.newFromLocation(0, 0));
-            expect(maneuver.effects).toEqual([
+            check.equals(maneuver.effects, [
                 [ship1, new ValueEffect("shield", 10)],
                 [ship2, new ValueEffect("shield", 10)]
             ]);
         });
 
-        it("guesses area effects on final location", function () {
+        test.case("guesses area effects on final location", check => {
             let battle = new Battle();
             let ship = battle.fleets[0].addShip();
             let engine = TestTools.addEngine(ship, 500);
@@ -53,12 +53,12 @@ module TK.SpaceTac.Specs {
             battle.addDrone(drone);
 
             let maneuver = new Maneuver(ship, move, Target.newFromLocation(40, 30));
-            expect(maneuver.getFinalLocation()).toEqual(jasmine.objectContaining({ x: 40, y: 30 }));
-            expect(maneuver.effects).toEqual([]);
+            check.containing(maneuver.getFinalLocation(), { x: 40, y: 30 });
+            check.equals(maneuver.effects, []);
 
             maneuver = new Maneuver(ship, move, Target.newFromLocation(100, 30));
-            expect(maneuver.getFinalLocation()).toEqual(jasmine.objectContaining({ x: 100, y: 30 }));
-            expect(maneuver.effects).toEqual([[ship, new AttributeEffect("maneuvrability", 1)]]);
+            check.containing(maneuver.getFinalLocation(), { x: 100, y: 30 });
+            check.equals(maneuver.effects, [[ship, new AttributeEffect("maneuvrability", 1)]]);
         });
     });
 }

src/core/ai/TacticalAI.spec.ts

@@ -1,7 +1,7 @@
 /// <reference path="Maneuver.ts" />
 
 module TK.SpaceTac.Specs {
-    describe("TacticalAI", function () {
+    testing("TacticalAI", test => {
         class FixedManeuver extends Maneuver {
             score: number;
             constructor(score: number) {
@@ -21,7 +21,7 @@ module TK.SpaceTac.Specs {
             applied = [];
         });
 
-        it("applies the highest evaluated maneuver", function () {
+        test.case("applies the highest evaluated maneuver", check => {
             let battle = new Battle();
             let ship = battle.fleets[0].addShip();
             TestTools.setShipPlaying(battle, ship);
@@ -38,7 +38,7 @@ module TK.SpaceTac.Specs {
             spyOn(ai, "applyManeuver").and.callFake((maneuver: FixedManeuver) => applied.push(maneuver.score));
 
             ai.play();
-            expect(applied).toEqual([7]);
+            check.equals(applied, [7]);
         });
     });
 }

src/core/ai/TacticalAIHelpers.spec.ts

@@ -1,6 +1,6 @@
 module TK.SpaceTac.Specs {
-    describe("TacticalAIHelpers", function () {
-        it("produces direct weapon shots", function () {
+    testing("TacticalAIHelpers", test => {
+        test.case("produces direct weapon shots", check => {
             let battle = new Battle();
             let ship0a = battle.fleets[0].addShip(new Ship(null, "0A"));
             let ship0b = battle.fleets[0].addShip(new Ship(null, "0B"));
@@ -11,19 +11,19 @@ module TK.SpaceTac.Specs {
             TestTools.setShipPlaying(battle, ship0a);
 
             let result = imaterialize(TacticalAIHelpers.produceDirectShots(ship0a, battle));
-            expect(result.length).toBe(0);
+            check.equals(result.length, 0);
 
             let weapon1 = TestTools.addWeapon(ship0a, 10);
             let weapon2 = TestTools.addWeapon(ship0a, 15);
             result = imaterialize(TacticalAIHelpers.produceDirectShots(ship0a, battle));
-            expect(result.length).toBe(4);
-            expect(result).toContain(new Maneuver(ship0a, nn(weapon1.action), Target.newFromShip(ship1a)));
-            expect(result).toContain(new Maneuver(ship0a, nn(weapon1.action), Target.newFromShip(ship1b)));
-            expect(result).toContain(new Maneuver(ship0a, nn(weapon2.action), Target.newFromShip(ship1a)));
-            expect(result).toContain(new Maneuver(ship0a, nn(weapon2.action), Target.newFromShip(ship1b)));
+            check.equals(result.length, 4);
+            check.contains(result, new Maneuver(ship0a, nn(weapon1.action), Target.newFromShip(ship1a)));
+            check.contains(result, new Maneuver(ship0a, nn(weapon1.action), Target.newFromShip(ship1b)));
+            check.contains(result, new Maneuver(ship0a, nn(weapon2.action), Target.newFromShip(ship1a)));
+            check.contains(result, new Maneuver(ship0a, nn(weapon2.action), Target.newFromShip(ship1b)));
         });
 
-        it("produces random moves inside a grid", function () {
+        test.case("produces random moves inside a grid", check => {
             let battle = new Battle();
             battle.width = 100;
             battle.height = 100;
@@ -33,12 +33,12 @@ module TK.SpaceTac.Specs {
             TestTools.setShipPlaying(battle, ship);
 
             let result = imaterialize(TacticalAIHelpers.produceRandomMoves(ship, battle, 2, 1));
-            expect(result.length).toBe(0);
+            check.equals(result.length, 0);
 
             let engine = TestTools.addEngine(ship, 1000);
 
             result = imaterialize(TacticalAIHelpers.produceRandomMoves(ship, battle, 2, 1, new SkewedRandomGenerator([0.5], true)));
-            expect(result).toEqual([
+            check.equals(result, [
                 new Maneuver(ship, nn(engine.action), Target.newFromLocation(25, 25)),
                 new Maneuver(ship, nn(engine.action), Target.newFromLocation(75, 25)),
                 new Maneuver(ship, nn(engine.action), Target.newFromLocation(25, 75)),
@@ -46,7 +46,7 @@ module TK.SpaceTac.Specs {
             ]);
         });
 
-        it("produces interesting blast shots", function () {
+        test.case("produces interesting blast shots", check => {
             let battle = new Battle();
             let ship = battle.fleets[0].addShip();
             let weapon = TestTools.addWeapon(ship, 50, 1, 1000, 105);
@@ -55,19 +55,19 @@ module TK.SpaceTac.Specs {
             TestTools.setShipPlaying(battle, ship);
 
             let result = imaterialize(TacticalAIHelpers.produceInterestingBlastShots(ship, battle));
-            expect(result.length).toBe(0);
+            check.equals(result.length, 0);
 
             let enemy1 = battle.fleets[1].addShip();
             enemy1.setArenaPosition(500, 0);
 
             result = imaterialize(TacticalAIHelpers.produceInterestingBlastShots(ship, battle));
-            expect(result.length).toBe(0);
+            check.equals(result.length, 0);
 
             let enemy2 = battle.fleets[1].addShip();
             enemy2.setArenaPosition(700, 0);
 
             result = imaterialize(TacticalAIHelpers.produceInterestingBlastShots(ship, battle));
-            expect(result).toEqual([
+            check.equals(result, [
                 new Maneuver(ship, nn(weapon.action), Target.newFromLocation(600, 0)),
                 new Maneuver(ship, nn(weapon.action), Target.newFromLocation(600, 0)),
             ]);
@@ -76,13 +76,13 @@ module TK.SpaceTac.Specs {
             enemy3.setArenaPosition(700, 300);
 
             result = imaterialize(TacticalAIHelpers.produceInterestingBlastShots(ship, battle));
-            expect(result).toEqual([
+            check.equals(result, [
                 new Maneuver(ship, nn(weapon.action), Target.newFromLocation(600, 0)),
                 new Maneuver(ship, nn(weapon.action), Target.newFromLocation(600, 0)),
             ]);
         });
 
-        it("evaluates turn cost", function () {
+        test.case("evaluates turn cost", check => {
             let battle = new Battle();
             let ship = battle.fleets[0].addShip();
             let weapon = TestTools.addWeapon(ship, 50, 5, 100);
@@ -90,30 +90,30 @@ module TK.SpaceTac.Specs {
             let engine = TestTools.addEngine(ship, 25);
 
             let maneuver = new Maneuver(ship, new BaseAction("fake", "Nothing"), new Target(0, 0), 0);
-            expect(TacticalAIHelpers.evaluateTurnCost(ship, battle, maneuver)).toBe(-1);
+            check.same(TacticalAIHelpers.evaluateTurnCost(ship, battle, maneuver), -1);
 
             maneuver = new Maneuver(ship, action, Target.newFromLocation(100, 0), 0);
-            expect(TacticalAIHelpers.evaluateTurnCost(ship, battle, maneuver)).toBe(-Infinity);
+            check.same(TacticalAIHelpers.evaluateTurnCost(ship, battle, maneuver), -Infinity);
 
             TestTools.setShipAP(ship, 4);
             maneuver = new Maneuver(ship, action, Target.newFromLocation(100, 0), 0);
-            expect(TacticalAIHelpers.evaluateTurnCost(ship, battle, maneuver)).toBe(-Infinity);
+            check.same(TacticalAIHelpers.evaluateTurnCost(ship, battle, maneuver), -Infinity);
 
             TestTools.setShipAP(ship, 10);
             maneuver = new Maneuver(ship, action, Target.newFromLocation(100, 0), 0);
-            expect(TacticalAIHelpers.evaluateTurnCost(ship, battle, maneuver)).toBe(0.5);  // 5 power remaining on 10
+            check.equals(TacticalAIHelpers.evaluateTurnCost(ship, battle, maneuver), 0.5);  // 5 power remaining on 10
 
             maneuver = new Maneuver(ship, action, Target.newFromLocation(110, 0), 0);
-            expect(TacticalAIHelpers.evaluateTurnCost(ship, battle, maneuver)).toBe(0.4);  // 4 power remaining on 10
+            check.equals(TacticalAIHelpers.evaluateTurnCost(ship, battle, maneuver), 0.4);  // 4 power remaining on 10
 
             maneuver = new Maneuver(ship, action, Target.newFromLocation(140, 0), 0);
-            expect(TacticalAIHelpers.evaluateTurnCost(ship, battle, maneuver)).toBe(0.3);  // 3 power remaining on 10
+            check.equals(TacticalAIHelpers.evaluateTurnCost(ship, battle, maneuver), 0.3);  // 3 power remaining on 10
 
             maneuver = new Maneuver(ship, action, Target.newFromLocation(310, 0), 0);
-            expect(TacticalAIHelpers.evaluateTurnCost(ship, battle, maneuver)).toBe(-1);  // can't do in one turn
+            check.same(TacticalAIHelpers.evaluateTurnCost(ship, battle, maneuver), -1);  // can't do in one turn
         });
 
-        it("evaluates the drawback of doing nothing", function () {
+        test.case("evaluates the drawback of doing nothing", check => {
             let battle = new Battle();
             let ship = battle.fleets[0].addShip();
             TestTools.setShipAP(ship, 10, 5);
@@ -121,21 +121,21 @@ module TK.SpaceTac.Specs {
             let weapon = TestTools.addWeapon(ship, 10, 2, 100, 10);
 
             let maneuver = new Maneuver(ship, nn(weapon.action), Target.newFromLocation(0, 0));
-            expect(TacticalAIHelpers.evaluateIdling(ship, battle, maneuver)).toEqual(-0.3);
+            check.equals(TacticalAIHelpers.evaluateIdling(ship, battle, maneuver), -0.3);
 
             maneuver = new Maneuver(ship, nn(engine.action), Target.newFromLocation(0, 0));
-            expect(TacticalAIHelpers.evaluateIdling(ship, battle, maneuver)).toEqual(-0.5);
+            check.equals(TacticalAIHelpers.evaluateIdling(ship, battle, maneuver), -0.5);
 
             ship.setValue("power", 2);
 
             maneuver = new Maneuver(ship, nn(weapon.action), Target.newFromLocation(0, 0));
-            expect(TacticalAIHelpers.evaluateIdling(ship, battle, maneuver)).toEqual(0.5);
+            check.equals(TacticalAIHelpers.evaluateIdling(ship, battle, maneuver), 0.5);
 
             maneuver = new Maneuver(ship, nn(engine.action), Target.newFromLocation(0, 0));
-            expect(TacticalAIHelpers.evaluateIdling(ship, battle, maneuver)).toEqual(0);
+            check.equals(TacticalAIHelpers.evaluateIdling(ship, battle, maneuver), 0);
         });
 
-        it("evaluates damage to enemies", function () {
+        test.case("evaluates damage to enemies", check => {
             let battle = new Battle();
             let ship = battle.fleets[0].addShip();
             let weapon = TestTools.addWeapon(ship, 50, 5, 500, 100);
@@ -150,18 +150,18 @@ module TK.SpaceTac.Specs {
 
             // no enemies hurt
             let maneuver = new Maneuver(ship, action, Target.newFromLocation(100, 0));
-            expect(TacticalAIHelpers.evaluateEnemyHealth(ship, battle, maneuver)).toBeCloseTo(0, 8);
+            check.nears(TacticalAIHelpers.evaluateEnemyHealth(ship, battle, maneuver), 0, 8);
 
             // one enemy loses half-life
             maneuver = new Maneuver(ship, action, Target.newFromLocation(180, 0));
-            expect(TacticalAIHelpers.evaluateEnemyHealth(ship, battle, maneuver)).toBeCloseTo(0.1666666666, 8);
+            check.nears(TacticalAIHelpers.evaluateEnemyHealth(ship, battle, maneuver), 0.1666666666, 8);
 
             // one enemy loses half-life, the other one is dead
             maneuver = new Maneuver(ship, action, Target.newFromLocation(280, 0));
-            expect(TacticalAIHelpers.evaluateEnemyHealth(ship, battle, maneuver)).toBeCloseTo(0.6666666666, 8);
+            check.nears(TacticalAIHelpers.evaluateEnemyHealth(ship, battle, maneuver), 0.6666666666, 8);
         });
 
-        it("evaluates ship clustering", function () {
+        test.case("evaluates ship clustering", check => {
             let battle = new Battle();
             let ship = battle.fleets[0].addShip();
             TestTools.addEngine(ship, 100);
@@ -169,24 +169,24 @@ module TK.SpaceTac.Specs {
             let weapon = TestTools.addWeapon(ship, 100, 1, 100, 10);
 
             let maneuver = new Maneuver(ship, nn(weapon.action), Target.newFromLocation(200, 0), 0.5);
-            expect(maneuver.simulation.move_location.x).toBeCloseTo(100.5, 1);
-            expect(maneuver.simulation.move_location.y).toBe(0);
-            expect(TacticalAIHelpers.evaluateClustering(ship, battle, maneuver)).toEqual(0);
+            check.nears(maneuver.simulation.move_location.x, 100.5, 1);
+            check.equals(maneuver.simulation.move_location.y, 0);
+            check.equals(TacticalAIHelpers.evaluateClustering(ship, battle, maneuver), 0);
 
             battle.fleets[1].addShip().setArenaPosition(battle.width, battle.height);
-            expect(TacticalAIHelpers.evaluateClustering(ship, battle, maneuver)).toBeCloseTo(-0.01, 2);
+            check.nears(TacticalAIHelpers.evaluateClustering(ship, battle, maneuver), -0.01, 2);
 
             battle.fleets[1].addShip().setArenaPosition(120, 40);
-            expect(TacticalAIHelpers.evaluateClustering(ship, battle, maneuver)).toBeCloseTo(-0.4, 1);
+            check.nears(TacticalAIHelpers.evaluateClustering(ship, battle, maneuver), -0.4, 1);
 
             battle.fleets[0].addShip().setArenaPosition(80, 60);
-            expect(TacticalAIHelpers.evaluateClustering(ship, battle, maneuver)).toBeCloseTo(-0.7, 1);
+            check.nears(TacticalAIHelpers.evaluateClustering(ship, battle, maneuver), -0.7, 1);
 
             battle.fleets[0].addShip().setArenaPosition(110, 20);
-            expect(TacticalAIHelpers.evaluateClustering(ship, battle, maneuver)).toEqual(-1);
+            check.equals(TacticalAIHelpers.evaluateClustering(ship, battle, maneuver), -1);
         });
 
-        it("evaluates ship position", function () {
+        test.case("evaluates ship position", check => {
             let battle = new Battle(undefined, undefined, 200, 100);
             let ship = battle.fleets[0].addShip();
             let weapon = TestTools.addWeapon(ship, 1, 1, 400);
@@ -194,40 +194,40 @@ module TK.SpaceTac.Specs {
 
             ship.setArenaPosition(0, 0);
             let maneuver = new Maneuver(ship, action, new Target(0, 0), 0);
-            expect(TacticalAIHelpers.evaluatePosition(ship, battle, maneuver)).toEqual(-1);
+            check.equals(TacticalAIHelpers.evaluatePosition(ship, battle, maneuver), -1);
 
             ship.setArenaPosition(100, 0);
             maneuver = new Maneuver(ship, action, new Target(0, 0), 0);
-            expect(TacticalAIHelpers.evaluatePosition(ship, battle, maneuver)).toEqual(-1);
+            check.equals(TacticalAIHelpers.evaluatePosition(ship, battle, maneuver), -1);
 
             ship.setArenaPosition(100, 10);
             maneuver = new Maneuver(ship, action, new Target(0, 0), 0);
-            expect(TacticalAIHelpers.evaluatePosition(ship, battle, maneuver)).toEqual(-0.6);
+            check.equals(TacticalAIHelpers.evaluatePosition(ship, battle, maneuver), -0.6);
 
             ship.setArenaPosition(100, 50);
             maneuver = new Maneuver(ship, action, new Target(0, 0), 0);
-            expect(TacticalAIHelpers.evaluatePosition(ship, battle, maneuver)).toEqual(1);
+            check.equals(TacticalAIHelpers.evaluatePosition(ship, battle, maneuver), 1);
         });
 
-        it("evaluates overheat", function () {
+        test.case("evaluates overheat", check => {
             let battle = new Battle(undefined, undefined, 200, 100);
             let ship = battle.fleets[0].addShip();
             let weapon = TestTools.addWeapon(ship, 1, 1, 400);
 
             let maneuver = new Maneuver(ship, nn(weapon.action), new Target(0, 0));
-            expect(TacticalAIHelpers.evaluateOverheat(ship, battle, maneuver)).toEqual(0);
+            check.equals(TacticalAIHelpers.evaluateOverheat(ship, battle, maneuver), 0);
 
             weapon.cooldown.configure(1, 1);
-            expect(TacticalAIHelpers.evaluateOverheat(ship, battle, maneuver)).toEqual(-0.4);
+            check.equals(TacticalAIHelpers.evaluateOverheat(ship, battle, maneuver), -0.4);
 
             weapon.cooldown.configure(1, 2);
-            expect(TacticalAIHelpers.evaluateOverheat(ship, battle, maneuver)).toEqual(-0.8);
+            check.equals(TacticalAIHelpers.evaluateOverheat(ship, battle, maneuver), -0.8);
 
             weapon.cooldown.configure(1, 3);
-            expect(TacticalAIHelpers.evaluateOverheat(ship, battle, maneuver)).toEqual(-1);
+            check.equals(TacticalAIHelpers.evaluateOverheat(ship, battle, maneuver), -1);
 
             weapon.cooldown.configure(2, 1);
-            expect(TacticalAIHelpers.evaluateOverheat(ship, battle, maneuver)).toEqual(0);
+            check.equals(TacticalAIHelpers.evaluateOverheat(ship, battle, maneuver), 0);
         });
     });
 }

src/core/effects/AttributeEffect.spec.ts

@@ -1,24 +1,24 @@
 module TK.SpaceTac {
-    describe("AttributeEffect", function () {
-        it("is not applied directly", function () {
+    testing("AttributeEffect", test => {
+        test.case("is not applied directly", check => {
             let ship = new Ship();
-            expect(ship.getAttribute("maneuvrability")).toBe(0);
+            check.equals(ship.getAttribute("maneuvrability"), 0);
 
             let effect = new AttributeEffect("maneuvrability", 20);
             effect.applyOnShip(ship, ship);
-            expect(ship.getAttribute("maneuvrability")).toBe(0);
+            check.equals(ship.getAttribute("maneuvrability"), 0);
 
             ship.sticky_effects.push(new StickyEffect(effect, 2));
             ship.updateAttributes();
-            expect(ship.getAttribute("maneuvrability")).toBe(20);
+            check.equals(ship.getAttribute("maneuvrability"), 20);
         });
 
-        it("has a description", function () {
+        test.case("has a description", check => {
             let effect = new AttributeEffect("maneuvrability", 12);
-            expect(effect.getDescription()).toEqual("maneuvrability +12");
+            check.equals(effect.getDescription(), "maneuvrability +12");
 
             effect = new AttributeEffect("shield_capacity", -4);
-            expect(effect.getDescription()).toEqual("shield capacity -4");
+            check.equals(effect.getDescription(), "shield capacity -4");
         });
     });
 }

src/core/effects/AttributeLimitEffect.spec.ts

@@ -1,23 +1,23 @@
 module TK.SpaceTac {
-    describe("AttributeLimitEffect", function () {
-        it("limits an attribute", function () {
+    testing("AttributeLimitEffect", test => {
+        test.case("limits an attribute", check => {
             let battle = new Battle();
             let ship = battle.fleets[0].addShip();
-            expect(ship.getAttribute("shield_capacity")).toBe(0);
-            expect(ship.getValue("shield")).toBe(0);
+            check.equals(ship.getAttribute("shield_capacity"), 0);
+            check.equals(ship.getValue("shield"), 0);
 
             TestTools.setShipHP(ship, 100, 50);
             ship.setValue("shield", 40);
-            expect(ship.getAttribute("shield_capacity")).toBe(50);
-            expect(ship.getValue("shield")).toBe(40);
+            check.equals(ship.getAttribute("shield_capacity"), 50);
+            check.equals(ship.getValue("shield"), 40);
 
             battle.log.clear();
             let effect = new StickyEffect(new AttributeLimitEffect("shield_capacity", 30));
             ship.addStickyEffect(effect);
 
-            expect(ship.getAttribute("shield_capacity")).toBe(30);
-            expect(ship.getValue("shield")).toBe(30);
-            expect(battle.log.events).toEqual([
+            check.equals(ship.getAttribute("shield_capacity"), 30);
+            check.equals(ship.getValue("shield"), 30);
+            check.equals(battle.log.events, [
                 new ActiveEffectsEvent(ship, [new AttributeEffect("hull_capacity", 100), new AttributeEffect("shield_capacity", 50)], [effect]),
                 new ValueChangeEvent(ship, new ShipValue("shield", 30, 50), -10),
                 new ValueChangeEvent(ship, new ShipAttribute("shield capacity", 30), -20),
@@ -25,8 +25,8 @@ module TK.SpaceTac {
 
             ship.cleanStickyEffects();
 
-            expect(ship.getAttribute("shield_capacity")).toBe(50);
-            expect(ship.getValue("shield")).toBe(30);
+            check.equals(ship.getAttribute("shield_capacity"), 50);
+            check.equals(ship.getValue("shield"), 30);
         });
     });
 }

src/core/effects/BaseEffect.spec.ts

@@ -1,11 +1,11 @@
 module TK.SpaceTac.Specs {
-    describe("BaseEffect", function () {
-        it("gets a fixed or variable amount", function () {
+    testing("BaseEffect", test => {
+        test.case("gets a fixed or variable amount", check => {
             let effect = new BaseEffect("test");
 
-            expect(effect.resolveAmount(50)).toBe(50);
-            expect(effect.resolveAmount({ base: 20, span: 10 }, new SkewedRandomGenerator([0.3]))).toBe(23);
-            expect(effect.resolveAmount({ base: 20, span: 0 }, new SkewedRandomGenerator([0.3]))).toBe(20);
+            check.equals(effect.resolveAmount(50), 50);
+            check.equals(effect.resolveAmount({ base: 20, span: 10 }, new SkewedRandomGenerator([0.3])), 23);
+            check.equals(effect.resolveAmount({ base: 20, span: 0 }, new SkewedRandomGenerator([0.3])), 20);
         })
     })
 }

src/core/effects/CooldownEffect.spec.ts

@@ -1,34 +1,34 @@
 module TK.SpaceTac {
-    describe("CooldownEffect", function () {
-        it("cools down equipment", function () {
+    testing("CooldownEffect", test => {
+        test.case("cools down equipment", check => {
             let ship = new Ship();
             let weapons = [TestTools.addWeapon(ship), TestTools.addWeapon(ship), TestTools.addWeapon(ship)];
             weapons.forEach(weapon => weapon.cooldown.configure(1, 3));
-            expect(weapons.map(weapon => weapon.cooldown.heat)).toEqual([0, 0, 0]);
+            check.equals(weapons.map(weapon => weapon.cooldown.heat), [0, 0, 0]);
 
             new CooldownEffect(0, 0).applyOnShip(ship, ship);
-            expect(weapons.map(weapon => weapon.cooldown.heat)).toEqual([0, 0, 0]);
+            check.equals(weapons.map(weapon => weapon.cooldown.heat), [0, 0, 0]);
 
             weapons.forEach(weapon => weapon.cooldown.use());
-            expect(weapons.map(weapon => weapon.cooldown.heat)).toEqual([3, 3, 3]);
+            check.equals(weapons.map(weapon => weapon.cooldown.heat), [3, 3, 3]);
 
             new CooldownEffect(0, 0).applyOnShip(ship, ship);
-            expect(weapons.map(weapon => weapon.cooldown.heat)).toEqual([0, 0, 0]);
+            check.equals(weapons.map(weapon => weapon.cooldown.heat), [0, 0, 0]);
 
             weapons.forEach(weapon => weapon.cooldown.use());
-            expect(weapons.map(weapon => weapon.cooldown.heat)).toEqual([3, 3, 3]);
+            check.equals(weapons.map(weapon => weapon.cooldown.heat), [3, 3, 3]);
 
             new CooldownEffect(1, 0).applyOnShip(ship, ship);
-            expect(weapons.map(weapon => weapon.cooldown.heat)).toEqual([2, 2, 2]);
+            check.equals(weapons.map(weapon => weapon.cooldown.heat), [2, 2, 2]);
 
             new CooldownEffect(1, 2).applyOnShip(ship, ship);
-            expect(weapons.map(weapon => weapon.cooldown.heat).sort()).toEqual([1, 1, 2]);
+            check.equals(weapons.map(weapon => weapon.cooldown.heat).sort(), [1, 1, 2]);
         })
 
-        it("builds a textual description", function () {
-            expect(new CooldownEffect(0, 0).getDescription()).toBe("Full cooling (all equipments)");
-            expect(new CooldownEffect(1, 1).getDescription()).toBe("1 cooling (1 equipment)");
-            expect(new CooldownEffect(2, 2).getDescription()).toBe("2 cooling (2 equipments)");
+        test.case("builds a textual description", check => {
+            check.equals(new CooldownEffect(0, 0).getDescription(), "Full cooling (all equipments)");
+            check.equals(new CooldownEffect(1, 1).getDescription(), "1 cooling (1 equipment)");
+            check.equals(new CooldownEffect(2, 2).getDescription(), "2 cooling (2 equipments)");
         })
     })
 }

src/core/effects/DamageEffect.spec.ts

@@ -1,6 +1,6 @@
 module TK.SpaceTac.Specs {
-    describe("DamageEffect", function () {
-        it("applies damage and wear", function () {
+    testing("DamageEffect", test => {
+        test.case("applies damage and wear", check => {
             let battle = new Battle();
             let ship = battle.fleets[0].addShip();
 
@@ -9,49 +9,49 @@ module TK.SpaceTac.Specs {
             let shield = ship.listEquipment(SlotType.Shield)[0];
             ship.restoreHealth();
 
-            expect(ship.getValue("hull")).toEqual(150);
-            expect(ship.getValue("shield")).toEqual(400);
-            expect(hull.wear).toBe(0);
-            expect(shield.wear).toBe(0);
+            check.equals(ship.getValue("hull"), 150);
+            check.equals(ship.getValue("shield"), 400);
+            check.equals(hull.wear, 0);
+            check.equals(shield.wear, 0);
 
             new DamageEffect(50).applyOnShip(ship, ship);
-            expect(ship.getValue("hull")).toEqual(150);
-            expect(ship.getValue("shield")).toEqual(350);
-            expect(hull.wear).toBe(0);
-            expect(shield.wear).toBe(1);
+            check.equals(ship.getValue("hull"), 150);
+            check.equals(ship.getValue("shield"), 350);
+            check.equals(hull.wear, 0);
+            check.equals(shield.wear, 1);
 
             new DamageEffect(250).applyOnShip(ship, ship);
-            expect(ship.getValue("hull")).toEqual(150);
-            expect(ship.getValue("shield")).toEqual(100);
-            expect(hull.wear).toBe(0);
-            expect(shield.wear).toBe(4);
+            check.equals(ship.getValue("hull"), 150);
+            check.equals(ship.getValue("shield"), 100);
+            check.equals(hull.wear, 0);
+            check.equals(shield.wear, 4);
 
             new DamageEffect(201).applyOnShip(ship, ship);
-            expect(ship.getValue("hull")).toEqual(49);
-            expect(ship.getValue("shield")).toEqual(0);
-            expect(hull.wear).toBe(2);
-            expect(shield.wear).toBe(5);
-            expect(ship.alive).toBe(true);
+            check.equals(ship.getValue("hull"), 49);
+            check.equals(ship.getValue("shield"), 0);
+            check.equals(hull.wear, 2);
+            check.equals(shield.wear, 5);
+            check.equals(ship.alive, true);
 
             new DamageEffect(8000).applyOnShip(ship, ship);
-            expect(ship.getValue("hull")).toEqual(0);
-            expect(ship.getValue("shield")).toEqual(0);
-            expect(hull.wear).toBe(3);
-            expect(shield.wear).toBe(5);
-            expect(ship.alive).toBe(false);
+            check.equals(ship.getValue("hull"), 0);
+            check.equals(ship.getValue("shield"), 0);
+            check.equals(hull.wear, 3);
+            check.equals(shield.wear, 5);
+            check.equals(ship.alive, false);
         });
 
-        it("gets a textual description", function () {
-            expect(new DamageEffect(10).getDescription()).toEqual("do 10 damage");
-            expect(new DamageEffect(10, 5).getDescription()).toEqual("do 10-15 damage");
+        test.case("gets a textual description", check => {
+            check.equals(new DamageEffect(10).getDescription(), "do 10 damage");
+            check.equals(new DamageEffect(10, 5).getDescription(), "do 10-15 damage");
         });
 
-        it("applies damage modifiers", function () {
+        test.case("applies damage modifiers", check => {
             let ship = new Ship();
             TestTools.setShipHP(ship, 1000, 1000);
             let damage = new DamageEffect(200);
 
-            expect(damage.getEffectiveDamage(ship)).toEqual([200, 0]);
+            check.equals(damage.getEffectiveDamage(ship), [200, 0]);
 
             spyOn(ship, "ieffects").and.returnValues(
                 isingle(new DamageModifierEffect(-15)),
@@ -62,14 +62,14 @@ module TK.SpaceTac.Specs {
                 isingle(new DamageModifierEffect(3))
             );
 
-            expect(damage.getEffectiveDamage(ship)).toEqual([170, 0]);
-            expect(damage.getEffectiveDamage(ship)).toEqual([240, 0]);
-            expect(damage.getEffectiveDamage(ship)).toEqual([0, 0]);
-            expect(damage.getEffectiveDamage(ship)).toEqual([400, 0]);
-            expect(damage.getEffectiveDamage(ship)).toEqual([190, 0]);
+            check.equals(damage.getEffectiveDamage(ship), [170, 0]);
+            check.equals(damage.getEffectiveDamage(ship), [240, 0]);
+            check.equals(damage.getEffectiveDamage(ship), [0, 0]);
+            check.equals(damage.getEffectiveDamage(ship), [400, 0]);
+            check.equals(damage.getEffectiveDamage(ship), [190, 0]);
 
             damage = new DamageEffect(40);
-            expect(damage.getEffectiveDamage(ship)).toEqual([41, 0]);
+            check.equals(damage.getEffectiveDamage(ship), [41, 0]);
         });
     });
 }

src/core/effects/RepelEffect.spec.ts

@@ -1,10 +1,10 @@
 module TK.SpaceTac.Specs {
-    describe("RepelEffect", function () {
-        it("shows a textual description", function () {
-            expect(new RepelEffect(34).getDescription()).toEqual("repel ships 34km away");
+    testing("RepelEffect", test => {
+        test.case("shows a textual description", check => {
+            check.equals(new RepelEffect(34).getDescription(), "repel ships 34km away");
         })
             
-        it("repel other ships from a central point", function () {
+        test.case("repel other ships from a central point", check => {
             let battle = new Battle();
             let ship1a = battle.fleets[0].addShip();
             ship1a.setArenaPosition(100, 100);
@@ -18,12 +18,12 @@ module TK.SpaceTac.Specs {
             effect.applyOnShip(ship1b, ship1a);
             effect.applyOnShip(ship2a, ship1a);
 
-            expect(ship1a.location).toEqual(new ArenaLocationAngle(100, 100));
-            expect(ship1b.location).toEqual(new ArenaLocationAngle(262, 100));
-            expect(ship2a.location).toEqual(new ArenaLocationAngle(100, 292));
+            check.equals(ship1a.location, new ArenaLocationAngle(100, 100));
+            check.equals(ship1b.location, new ArenaLocationAngle(262, 100));
+            check.equals(ship2a.location, new ArenaLocationAngle(100, 292));
         })
 
-        it("does not push a ship inside a hard exclusion area", function () {
+        test.case("does not push a ship inside a hard exclusion area", check => {
             let battle = new Battle();
             let ship1a = battle.fleets[0].addShip();
             ship1a.setArenaPosition(100, 100);
@@ -34,7 +34,7 @@ module TK.SpaceTac.Specs {
 
             let effect = new RepelEffect(85);
             effect.applyOnShip(ship2a, ship1a);
-            expect(ship2a.location).toEqual(new ArenaLocationAngle(100, 250));
+            check.equals(ship2a.location, new ArenaLocationAngle(100, 250));
         })
     })
 }

src/core/effects/ValueEffect.spec.ts

@@ -1,26 +1,26 @@
 module TK.SpaceTac {
-    describe("ValueEffect", function () {
-        it("adds an amount to a ship value", function () {
+    testing("ValueEffect", test => {
+        test.case("adds an amount to a ship value", check => {
             let effect = new ValueEffect("shield", 20);
 
             let ship = new Ship();
             ship.values.shield.setMaximal(80);
             ship.setValue("shield", 55);
-            expect(ship.values.shield.get()).toEqual(55);
+            check.equals(ship.values.shield.get(), 55);
 
             effect.applyOnShip(ship, ship);
-            expect(ship.values.shield.get()).toEqual(75);
+            check.equals(ship.values.shield.get(), 75);
 
             effect.applyOnShip(ship, ship);
-            expect(ship.values.shield.get()).toEqual(80);
+            check.equals(ship.values.shield.get(), 80);
         });
 
-        it("has a description", function () {
+        test.case("has a description", check => {
             let effect = new ValueEffect("power", 12);
-            expect(effect.getDescription()).toEqual("power +12");
+            check.equals(effect.getDescription(), "power +12");
 
             effect = new ValueEffect("power", -4);
-            expect(effect.getDescription()).toEqual("power -4");
+            check.equals(effect.getDescription(), "power -4");
         });
     });
 }

src/core/effects/ValueTransferEffect.spec.ts

@@ -1,6 +1,6 @@
 module TK.SpaceTac.Specs {
-    describe("ValueTransferEffect", function () {
-        it("takes or gives value", function () {
+    testing("ValueTransferEffect", test => {
+        test.case("takes or gives value", check => {
             let ship1 = new Ship();
             TestTools.setShipHP(ship1, 100, 50);
             ship1.setValue("hull", 10);
@@ -9,23 +9,23 @@ module TK.SpaceTac.Specs {
 
             let effect = new ValueTransferEffect("hull", -30);
             effect.applyOnShip(ship2, ship1);
-            expect(ship1.getValue("hull")).toEqual(40);
-            expect(ship2.getValue("hull")).toEqual(70);
+            check.equals(ship1.getValue("hull"), 40);
+            check.equals(ship2.getValue("hull"), 70);
 
             effect = new ValueTransferEffect("hull", 1000);
             effect.applyOnShip(ship2, ship1);
-            expect(ship1.getValue("hull")).toEqual(0);
-            expect(ship2.getValue("hull")).toEqual(100);
+            check.equals(ship1.getValue("hull"), 0);
+            check.equals(ship2.getValue("hull"), 100);
         })
 
-        it("builds a description", function () {
+        test.case("builds a description", check => {
             let effect = new ValueTransferEffect("power", 12);
-            expect(effect.getDescription()).toEqual("give 12 power");
-            expect(effect.isBeneficial()).toBe(true);
+            check.equals(effect.getDescription(), "give 12 power");
+            check.equals(effect.isBeneficial(), true);
 
             effect = new ValueTransferEffect("shield", -20);
-            expect(effect.getDescription()).toEqual("steal 20 shield");
-            expect(effect.isBeneficial()).toBe(false);
+            check.equals(effect.getDescription(), "steal 20 shield");
+            check.equals(effect.isBeneficial(), false);
         })
     })
 }

src/core/equipments/DamageProtector.spec.ts

@@ -1,34 +1,34 @@
 module TK.SpaceTac.Equipments {
-    describe("DamageProtector", function () {
-        it("generates equipment based on level", function () {
+    testing("DamageProtector", test => {
+        test.case("generates equipment based on level", check => {
             let template = new DamageProtector();
 
             let equipment = template.generate(1);
-            expect(equipment.requirements).toEqual({ "skill_time": 3 });
-            expect(equipment.action).toEqual(new ToggleAction(equipment, 2, 300, [
+            check.equals(equipment.requirements, { "skill_time": 3 });
+            check.equals(equipment.action, new ToggleAction(equipment, 2, 300, [
                 new DamageModifierEffect(-17)
             ]));
 
             equipment = template.generate(2);
-            expect(equipment.requirements).toEqual({ "skill_time": 4 });
-            expect(equipment.action).toEqual(new ToggleAction(equipment, 2, 310, [
+            check.equals(equipment.requirements, { "skill_time": 4 });
+            check.equals(equipment.action, new ToggleAction(equipment, 2, 310, [
                 new DamageModifierEffect(-22)
             ]));
 
             equipment = template.generate(3);
-            expect(equipment.requirements).toEqual({ "skill_time": 5 });
-            expect(equipment.action).toEqual(new ToggleAction(equipment, 2, 322, [
+            check.equals(equipment.requirements, { "skill_time": 5 });
+            check.equals(equipment.action, new ToggleAction(equipment, 2, 322, [
                 new DamageModifierEffect(-28)
             ]));
 
             equipment = template.generate(10);
-            expect(equipment.requirements).toEqual({ "skill_time": 22 });
-            expect(equipment.action).toEqual(new ToggleAction(equipment, 8, 462, [
+            check.equals(equipment.requirements, { "skill_time": 22 });
+            check.equals(equipment.action, new ToggleAction(equipment, 8, 462, [
                 new DamageModifierEffect(-60)
             ]));
         });
 
-        it("reduces damage around the ship", function () {
+        test.case("reduces damage around the ship", check => {
             let battle = new Battle();
             let ship1 = battle.fleets[0].addShip();
             ship1.upgradeSkill("skill_time", 3);
@@ -41,7 +41,7 @@ module TK.SpaceTac.Equipments {
             ship2.setArenaPosition(100, 0);
             ship3.setArenaPosition(800, 0);
             TestTools.setShipPlaying(battle, ship1);
-            expect(ship1.getAvailableActions()).toEqual([action, new EndTurnAction()]);
+            check.equals(ship1.getAvailableActions(), [action, new EndTurnAction()]);
 
             TestTools.setShipHP(ship1, 100, 0);
             TestTools.setShipHP(ship2, 100, 0);
@@ -49,32 +49,32 @@ module TK.SpaceTac.Equipments {
 
             iforeach(battle.iships(), ship => new DamageEffect(10).applyOnShip(ship, ship1));
 
-            expect(ship1.getValue("power")).toEqual(10);
-            expect(ship1.getValue("hull")).toEqual(90);
-            expect(ship2.getValue("hull")).toEqual(90);
-            expect(ship3.getValue("hull")).toEqual(90);
+            check.equals(ship1.getValue("power"), 10);
+            check.equals(ship1.getValue("hull"), 90);
+            check.equals(ship2.getValue("hull"), 90);
+            check.equals(ship3.getValue("hull"), 90);
 
             let result = action.apply(ship1);
-            expect(result).toBe(true);
-            expect((<ToggleAction>protector.action).activated).toBe(true);
+            check.equals(result, true);
+            check.equals((<ToggleAction>protector.action).activated, true);
 
             iforeach(battle.iships(), ship => new DamageEffect(10).applyOnShip(ship, ship1));
 
-            expect(ship1.getValue("power")).toEqual(8);
-            expect(ship1.getValue("hull")).toEqual(82);
-            expect(ship2.getValue("hull")).toEqual(82);
-            expect(ship3.getValue("hull")).toEqual(80);
+            check.equals(ship1.getValue("power"), 8);
+            check.equals(ship1.getValue("hull"), 82);
+            check.equals(ship2.getValue("hull"), 82);
+            check.equals(ship3.getValue("hull"), 80);
 
             result = action.apply(ship1);
-            expect(result).toBe(true);
-            expect((<ToggleAction>protector.action).activated).toBe(false);
+            check.equals(result, true);
+            check.equals((<ToggleAction>protector.action).activated, false);
 
             iforeach(battle.iships(), ship => new DamageEffect(10).applyOnShip(ship, ship1));
 
-            expect(ship1.getValue("power")).toEqual(8);
-            expect(ship1.getValue("hull")).toEqual(72);
-            expect(ship2.getValue("hull")).toEqual(72);
-            expect(ship3.getValue("hull")).toEqual(70);
+            check.equals(ship1.getValue("power"), 8);
+            check.equals(ship1.getValue("hull"), 72);
+            check.equals(ship2.getValue("hull"), 72);
+            check.equals(ship3.getValue("hull"), 70);
         });
     });
 }

src/core/equipments/Engines.spec.ts

@@ -1,99 +1,99 @@
 module TK.SpaceTac.Equipments {
-    describe("Engines", function () {
-        it("generates RocketEngine based on level", function () {
+    testing("Engines", test => {
+        test.case("generates RocketEngine based on level", check => {
             let template = new RocketEngine();
 
             let equipment = template.generate(1);
-            expect(equipment.requirements).toEqual({ "skill_materials": 1 });
-            expect(equipment.effects).toEqual([new AttributeEffect("maneuvrability", 2)]);
-            expect(equipment.cooldown).toEqual(new Cooldown(2, 0));
-            expect(equipment.action).toEqual(new MoveAction(equipment, 200, 120, 70));
-            expect(equipment.price).toEqual(120);
+            check.equals(equipment.requirements, { "skill_materials": 1 });
+            check.equals(equipment.effects, [new AttributeEffect("maneuvrability", 2)]);
+            check.equals(equipment.cooldown, new Cooldown(2, 0));
+            check.equals(equipment.action, new MoveAction(equipment, 200, 120, 70));
+            check.equals(equipment.price, 120);
 
             equipment = template.generate(2);
-            expect(equipment.requirements).toEqual({ "skill_materials": 2 });
-            expect(equipment.effects).toEqual([new AttributeEffect("maneuvrability", 2)]);
-            expect(equipment.cooldown).toEqual(new Cooldown(2, 0));
-            expect(equipment.action).toEqual(new MoveAction(equipment, 210, 120, 70));
-            expect(equipment.price).toEqual(420);
+            check.equals(equipment.requirements, { "skill_materials": 2 });
+            check.equals(equipment.effects, [new AttributeEffect("maneuvrability", 2)]);
+            check.equals(equipment.cooldown, new Cooldown(2, 0));
+            check.equals(equipment.action, new MoveAction(equipment, 210, 120, 70));
+            check.equals(equipment.price, 420);
 
             equipment = template.generate(3);
-            expect(equipment.requirements).toEqual({ "skill_materials": 3 });
-            expect(equipment.effects).toEqual([new AttributeEffect("maneuvrability", 3)]);
-            expect(equipment.cooldown).toEqual(new Cooldown(2, 0));
-            expect(equipment.action).toEqual(new MoveAction(equipment, 220, 120, 70));
-            expect(equipment.price).toEqual(1020);
+            check.equals(equipment.requirements, { "skill_materials": 3 });
+            check.equals(equipment.effects, [new AttributeEffect("maneuvrability", 3)]);
+            check.equals(equipment.cooldown, new Cooldown(2, 0));
+            check.equals(equipment.action, new MoveAction(equipment, 220, 120, 70));
+            check.equals(equipment.price, 1020);
 
             equipment = template.generate(10);
-            expect(equipment.requirements).toEqual({ "skill_materials": 17 });
-            expect(equipment.effects).toEqual([new AttributeEffect("maneuvrability", 14)]);
-            expect(equipment.cooldown).toEqual(new Cooldown(2, 0));
-            expect(equipment.action).toEqual(new MoveAction(equipment, 290, 120, 70));
-            expect(equipment.price).toEqual(13620);
+            check.equals(equipment.requirements, { "skill_materials": 17 });
+            check.equals(equipment.effects, [new AttributeEffect("maneuvrability", 14)]);
+            check.equals(equipment.cooldown, new Cooldown(2, 0));
+            check.equals(equipment.action, new MoveAction(equipment, 290, 120, 70));
+            check.equals(equipment.price, 13620);
         });
 
-        it("generates IonThruster based on level", function () {
+        test.case("generates IonThruster based on level", check => {
             let template = new IonThruster();
 
             let equipment = template.generate(1);
-            expect(equipment.requirements).toEqual({ "skill_photons": 1 });
-            expect(equipment.effects).toEqual([new AttributeEffect("maneuvrability", 1)]);
-            expect(equipment.cooldown).toEqual(new Cooldown(3, 1));
-            expect(equipment.action).toEqual(new MoveAction(equipment, 120, 120, 80));
-            expect(equipment.price).toEqual(150);
+            check.equals(equipment.requirements, { "skill_photons": 1 });
+            check.equals(equipment.effects, [new AttributeEffect("maneuvrability", 1)]);
+            check.equals(equipment.cooldown, new Cooldown(3, 1));
+            check.equals(equipment.action, new MoveAction(equipment, 120, 120, 80));
+            check.equals(equipment.price, 150);
 
             equipment = template.generate(2);
-            expect(equipment.requirements).toEqual({ "skill_photons": 2 });
-            expect(equipment.effects).toEqual([new AttributeEffect("maneuvrability", 2)]);
-            expect(equipment.cooldown).toEqual(new Cooldown(3, 1));
-            expect(equipment.action).toEqual(new MoveAction(equipment, 130, 120, 80));
-            expect(equipment.price).toEqual(525);
+            check.equals(equipment.requirements, { "skill_photons": 2 });
+            check.equals(equipment.effects, [new AttributeEffect("maneuvrability", 2)]);
+            check.equals(equipment.cooldown, new Cooldown(3, 1));
+            check.equals(equipment.action, new MoveAction(equipment, 130, 120, 80));
+            check.equals(equipment.price, 525);
 
             equipment = template.generate(3);
-            expect(equipment.requirements).toEqual({ "skill_photons": 3 });
-            expect(equipment.effects).toEqual([new AttributeEffect("maneuvrability", 3)]);
-            expect(equipment.cooldown).toEqual(new Cooldown(3, 1));
-            expect(equipment.action).toEqual(new MoveAction(equipment, 140, 120, 80));
-            expect(equipment.price).toEqual(1275);
+            check.equals(equipment.requirements, { "skill_photons": 3 });
+            check.equals(equipment.effects, [new AttributeEffect("maneuvrability", 3)]);
+            check.equals(equipment.cooldown, new Cooldown(3, 1));
+            check.equals(equipment.action, new MoveAction(equipment, 140, 120, 80));
+            check.equals(equipment.price, 1275);
 
             equipment = template.generate(10);
-            expect(equipment.requirements).toEqual({ "skill_photons": 17 });
-            expect(equipment.effects).toEqual([new AttributeEffect("maneuvrability", 17)]);
-            expect(equipment.cooldown).toEqual(new Cooldown(3, 1));
-            expect(equipment.action).toEqual(new MoveAction(equipment, 210, 120, 80));
-            expect(equipment.price).toEqual(17025);
+            check.equals(equipment.requirements, { "skill_photons": 17 });
+            check.equals(equipment.effects, [new AttributeEffect("maneuvrability", 17)]);
+            check.equals(equipment.cooldown, new Cooldown(3, 1));
+            check.equals(equipment.action, new MoveAction(equipment, 210, 120, 80));
+            check.equals(equipment.price, 17025);
         });
 
-        it("generates VoidhawkEngine based on level", function () {
+        test.case("generates VoidhawkEngine based on level", check => {
             let template = new VoidhawkEngine();
 
             let equipment = template.generate(1);
-            expect(equipment.requirements).toEqual({ "skill_gravity": 2 });
-            expect(equipment.effects).toEqual([new AttributeEffect("maneuvrability", -3)]);
-            expect(equipment.cooldown).toEqual(new Cooldown(1, 0));
-            expect(equipment.action).toEqual(new MoveAction(equipment, 2000, 270, 0));
-            expect(equipment.price).toEqual(300);
+            check.equals(equipment.requirements, { "skill_gravity": 2 });
+            check.equals(equipment.effects, [new AttributeEffect("maneuvrability", -3)]);
+            check.equals(equipment.cooldown, new Cooldown(1, 0));
+            check.equals(equipment.action, new MoveAction(equipment, 2000, 270, 0));
+            check.equals(equipment.price, 300);
 
             equipment = template.generate(2);
-            expect(equipment.requirements).toEqual({ "skill_gravity": 3 });
-            expect(equipment.effects).toEqual([new AttributeEffect("maneuvrability", -4)]);
-            expect(equipment.cooldown).toEqual(new Cooldown(1, 0));
-            expect(equipment.action).toEqual(new MoveAction(equipment, 2000, 245, 0));
-            expect(equipment.price).toEqual(1050);
+            check.equals(equipment.requirements, { "skill_gravity": 3 });
+            check.equals(equipment.effects, [new AttributeEffect("maneuvrability", -4)]);
+            check.equals(equipment.cooldown, new Cooldown(1, 0));
+            check.equals(equipment.action, new MoveAction(equipment, 2000, 245, 0));
+            check.equals(equipment.price, 1050);
 
             equipment = template.generate(3);
-            expect(equipment.requirements).toEqual({ "skill_gravity": 5 });
-            expect(equipment.effects).toEqual([new AttributeEffect("maneuvrability", -4)]);
-            expect(equipment.cooldown).toEqual(new Cooldown(1, 0));
-            expect(equipment.action).toEqual(new MoveAction(equipment, 2000, 224, 0));
-            expect(equipment.price).toEqual(2550);
+            check.equals(equipment.requirements, { "skill_gravity": 5 });
+            check.equals(equipment.effects, [new AttributeEffect("maneuvrability", -4)]);
+            check.equals(equipment.cooldown, new Cooldown(1, 0));
+            check.equals(equipment.action, new MoveAction(equipment, 2000, 224, 0));
+            check.equals(equipment.price, 2550);
 
             equipment = template.generate(10);
-            expect(equipment.requirements).toEqual({ "skill_gravity": 26 });
-            expect(equipment.effects).toEqual([new AttributeEffect("maneuvrability", -5)]);
-            expect(equipment.cooldown).toEqual(new Cooldown(2, 0));
-            expect(equipment.action).toEqual(new MoveAction(equipment, 2000, 155, 0));
-            expect(equipment.price).toEqual(34050);
+            check.equals(equipment.requirements, { "skill_gravity": 26 });
+            check.equals(equipment.effects, [new AttributeEffect("maneuvrability", -5)]);
+            check.equals(equipment.cooldown, new Cooldown(2, 0));
+            check.equals(equipment.action, new MoveAction(equipment, 2000, 155, 0));
+            check.equals(equipment.price, 34050);
         });
     });
 }

src/core/equipments/Generators.spec.ts

@@ -1,83 +1,83 @@
 module TK.SpaceTac.Equipments {
-    describe("Generators", function () {
-        it("generates NuclearReactor based on level", function () {
+    testing("Generators", test => {
+        test.case("generates NuclearReactor based on level", check => {
             let template = new NuclearReactor();
 
             let equipment = template.generate(1);
-            expect(equipment.requirements).toEqual({ "skill_photons": 1 });
-            expect(equipment.effects).toEqual([
+            check.equals(equipment.requirements, { "skill_photons": 1 });
+            check.equals(equipment.effects, [
                 new AttributeEffect("maneuvrability", 1),
                 new AttributeEffect("power_capacity", 7),
                 new AttributeEffect("power_generation", 4),
             ]);
-            expect(equipment.price).toEqual(395);
+            check.equals(equipment.price, 395);
 
             equipment = template.generate(2);
-            expect(equipment.requirements).toEqual({ "skill_photons": 3 });
-            expect(equipment.effects).toEqual([
+            check.equals(equipment.requirements, { "skill_photons": 3 });
+            check.equals(equipment.effects, [
                 new AttributeEffect("maneuvrability", 2),
                 new AttributeEffect("power_capacity", 7),
                 new AttributeEffect("power_generation", 5),
             ]);
-            expect(equipment.price).toEqual(1382);
+            check.equals(equipment.price, 1382);
 
             equipment = template.generate(3);
-            expect(equipment.requirements).toEqual({ "skill_photons": 5 });
-            expect(equipment.effects).toEqual([
+            check.equals(equipment.requirements, { "skill_photons": 5 });
+            check.equals(equipment.effects, [
                 new AttributeEffect("maneuvrability", 3),
                 new AttributeEffect("power_capacity", 8),
                 new AttributeEffect("power_generation", 5),
             ]);
-            expect(equipment.price).toEqual(3357);
+            check.equals(equipment.price, 3357);
 
             equipment = template.generate(10);
-            expect(equipment.requirements).toEqual({ "skill_photons": 33 });
-            expect(equipment.effects).toEqual([
+            check.equals(equipment.requirements, { "skill_photons": 33 });
+            check.equals(equipment.effects, [
                 new AttributeEffect("maneuvrability", 10),
                 new AttributeEffect("power_capacity", 15),
                 new AttributeEffect("power_generation", 12),
             ]);
-            expect(equipment.price).toEqual(44832);
+            check.equals(equipment.price, 44832);
         })
 
-        it("generates KelvinGenerator based on level", function () {
+        test.case("generates KelvinGenerator based on level", check => {
             let template = new KelvinGenerator();
 
             let equipment = template.generate(1);
-            expect(equipment.requirements).toEqual({ "skill_time": 1 });
-            expect(equipment.effects).toEqual([
+            check.equals(equipment.requirements, { "skill_time": 1 });
+            check.equals(equipment.effects, [
                 new AttributeEffect("power_capacity", 5),
                 new AttributeEffect("power_generation", 4),
             ]);
-            expect(equipment.action).toEqual(new TriggerAction(equipment, [new CooldownEffect(1, 1)]));
-            expect(equipment.price).toEqual(420);
+            check.equals(equipment.action, new TriggerAction(equipment, [new CooldownEffect(1, 1)]));
+            check.equals(equipment.price, 420);
 
             equipment = template.generate(2);
-            expect(equipment.requirements).toEqual({ "skill_time": 2 });
-            expect(equipment.effects).toEqual([
+            check.equals(equipment.requirements, { "skill_time": 2 });
+            check.equals(equipment.effects, [
                 new AttributeEffect("power_capacity", 6),
                 new AttributeEffect("power_generation", 4),
             ]);
-            expect(equipment.action).toEqual(new TriggerAction(equipment, [new CooldownEffect(1, 1)]));
-            expect(equipment.price).toEqual(1470);
+            check.equals(equipment.action, new TriggerAction(equipment, [new CooldownEffect(1, 1)]));
+            check.equals(equipment.price, 1470);
 
             equipment = template.generate(3);
-            expect(equipment.requirements).toEqual({ "skill_time": 4, "skill_gravity": 1 });
-            expect(equipment.effects).toEqual([
+            check.equals(equipment.requirements, { "skill_time": 4, "skill_gravity": 1 });
+            check.equals(equipment.effects, [
                 new AttributeEffect("power_capacity", 6),
                 new AttributeEffect("power_generation", 5),
             ]);
-            expect(equipment.action).toEqual(new TriggerAction(equipment, [new CooldownEffect(1, 1)]));
-            expect(equipment.price).toEqual(3570);
+            check.equals(equipment.action, new TriggerAction(equipment, [new CooldownEffect(1, 1)]));
+            check.equals(equipment.price, 3570);
 
             equipment = template.generate(10);
-            expect(equipment.requirements).toEqual({ "skill_time": 28, "skill_gravity": 6 });
-            expect(equipment.effects).toEqual([
+            check.equals(equipment.requirements, { "skill_time": 28, "skill_gravity": 6 });
+            check.equals(equipment.effects, [
                 new AttributeEffect("power_capacity", 13),
                 new AttributeEffect("power_generation", 12),
             ]);
-            expect(equipment.action).toEqual(new TriggerAction(equipment, [new CooldownEffect(4, 7)], 7));
-            expect(equipment.price).toEqual(47670);
+            check.equals(equipment.action, new TriggerAction(equipment, [new CooldownEffect(4, 7)], 7));
+            check.equals(equipment.price, 47670);
         })
     })
 }

src/core/equipments/Hulls.spec.ts

@@ -1,104 +1,104 @@
 module TK.SpaceTac.Equipments {
-    describe("Hulls", function () {
-        it("generates IronHull based on level", function () {
+    testing("Hulls", test => {
+        test.case("generates IronHull based on level", check => {
             let template = new IronHull();
 
             let equipment = template.generate(1);
-            expect(equipment.requirements).toEqual({ "skill_materials": 1 });
-            expect(equipment.effects).toEqual([new AttributeEffect("hull_capacity", 100)]);
-            expect(equipment.price).toEqual(100);
+            check.equals(equipment.requirements, { "skill_materials": 1 });
+            check.equals(equipment.effects, [new AttributeEffect("hull_capacity", 100)]);
+            check.equals(equipment.price, 100);
 
             equipment = template.generate(2);
-            expect(equipment.requirements).toEqual({ "skill_materials": 2 });
-            expect(equipment.effects).toEqual([new AttributeEffect("hull_capacity", 140)]);
-            expect(equipment.price).toEqual(350);
+            check.equals(equipment.requirements, { "skill_materials": 2 });
+            check.equals(equipment.effects, [new AttributeEffect("hull_capacity", 140)]);
+            check.equals(equipment.price, 350);
 
             equipment = template.generate(3);
-            expect(equipment.requirements).toEqual({ "skill_materials": 3 });
-            expect(equipment.effects).toEqual([new AttributeEffect("hull_capacity", 188)]);
-            expect(equipment.price).toEqual(850);
+            check.equals(equipment.requirements, { "skill_materials": 3 });
+            check.equals(equipment.effects, [new AttributeEffect("hull_capacity", 188)]);
+            check.equals(equipment.price, 850);
 
             equipment = template.generate(10);
-            expect(equipment.requirements).toEqual({ "skill_materials": 17 });
-            expect(equipment.effects).toEqual([new AttributeEffect("hull_capacity", 748)]);
-            expect(equipment.price).toEqual(11350);
+            check.equals(equipment.requirements, { "skill_materials": 17 });
+            check.equals(equipment.effects, [new AttributeEffect("hull_capacity", 748)]);
+            check.equals(equipment.price, 11350);
         });
 
-        it("generates HardCoatedHull based on level", function () {
+        test.case("generates HardCoatedHull based on level", check => {
             let template = new HardCoatedHull();
 
             let equipment = template.generate(1);
-            expect(equipment.requirements).toEqual({ "skill_materials": 2 });
-            expect(equipment.effects).toEqual([
+            check.equals(equipment.requirements, { "skill_materials": 2 });
+            check.equals(equipment.effects, [
                 new AttributeEffect("hull_capacity", 130),
                 new AttributeEffect("maneuvrability", -2),
             ]);
-            expect(equipment.price).toEqual(124);
+            check.equals(equipment.price, 124);
 
             equipment = template.generate(2);
-            expect(equipment.requirements).toEqual({ "skill_materials": 5 });
-            expect(equipment.effects).toEqual([
+            check.equals(equipment.requirements, { "skill_materials": 5 });
+            check.equals(equipment.effects, [
                 new AttributeEffect("hull_capacity", 182),
                 new AttributeEffect("maneuvrability", -3),
             ]);
-            expect(equipment.price).toEqual(434);
+            check.equals(equipment.price, 434);
 
             equipment = template.generate(3);
-            expect(equipment.requirements).toEqual({ "skill_materials": 8 });
-            expect(equipment.effects).toEqual([
+            check.equals(equipment.requirements, { "skill_materials": 8 });
+            check.equals(equipment.effects, [
                 new AttributeEffect("hull_capacity", 244),
                 new AttributeEffect("maneuvrability", -5),
             ]);
-            expect(equipment.price).toEqual(1054);
+            check.equals(equipment.price, 1054);
 
             equipment = template.generate(10);
-            expect(equipment.requirements).toEqual({ "skill_materials": 50 });
-            expect(equipment.effects).toEqual([
+            check.equals(equipment.requirements, { "skill_materials": 50 });
+            check.equals(equipment.effects, [
                 new AttributeEffect("hull_capacity", 972),
                 new AttributeEffect("maneuvrability", -19),
             ]);
-            expect(equipment.price).toEqual(14074);
+            check.equals(equipment.price, 14074);
         });
 
-        it("generates FractalHull based on level", function () {
+        test.case("generates FractalHull based on level", check => {
             let template = new FractalHull();
 
             let equipment = template.generate(1);
-            expect(equipment.requirements).toEqual({ "skill_quantum": 1 });
-            expect(equipment.effects).toEqual([
+            check.equals(equipment.requirements, { "skill_quantum": 1 });
+            check.equals(equipment.effects, [
                 new AttributeEffect("hull_capacity", 60),
                 new AttributeEffect("precision", 2),
             ]);
-            expect(equipment.action).toEqual(new TriggerAction(equipment, [new ValueEffect("hull", 60)]));
-            expect(equipment.cooldown).toEqual(new Cooldown(1, 4));
-            expect(equipment.price).toEqual(250);
+            check.equals(equipment.action, new TriggerAction(equipment, [new ValueEffect("hull", 60)]));
+            check.equals(equipment.cooldown, new Cooldown(1, 4));
+            check.equals(equipment.price, 250);
 
             equipment = template.generate(2);
-            expect(equipment.requirements).toEqual({ "skill_quantum": 3 });
-            expect(equipment.effects).toEqual([
+            check.equals(equipment.requirements, { "skill_quantum": 3 });
+            check.equals(equipment.effects, [
                 new AttributeEffect("hull_capacity", 84),
                 new AttributeEffect("precision", 2),
             ]);
-            expect(equipment.cooldown).toEqual(new Cooldown(1, 4));
-            expect(equipment.price).toEqual(875);
+            check.equals(equipment.cooldown, new Cooldown(1, 4));
+            check.equals(equipment.price, 875);
 
             equipment = template.generate(3);
-            expect(equipment.requirements).toEqual({ "skill_quantum": 5 });
-            expect(equipment.effects).toEqual([
+            check.equals(equipment.requirements, { "skill_quantum": 5 });
+            check.equals(equipment.effects, [
                 new AttributeEffect("hull_capacity", 112),
                 new AttributeEffect("precision", 3),
             ]);
-            expect(equipment.cooldown).toEqual(new Cooldown(1, 4));
-            expect(equipment.price).toEqual(2125);
+            check.equals(equipment.cooldown, new Cooldown(1, 4));
+            check.equals(equipment.price, 2125);
 
             equipment = template.generate(10);
-            expect(equipment.requirements).toEqual({ "skill_quantum": 33 });
-            expect(equipment.effects).toEqual([
+            check.equals(equipment.requirements, { "skill_quantum": 33 });
+            check.equals(equipment.effects, [
                 new AttributeEffect("hull_capacity", 448),
                 new AttributeEffect("precision", 14),
             ]);
-            expect(equipment.cooldown).toEqual(new Cooldown(1, 4));
-            expect(equipment.price).toEqual(28375);
+            check.equals(equipment.cooldown, new Cooldown(1, 4));
+            check.equals(equipment.price, 28375);
         });
     });
 }

src/core/equipments/PowerDepleter.spec.ts

@@ -1,35 +1,35 @@
 module TK.SpaceTac.Equipments {
-    describe("PowerDepleter", () => {
-        it("generates equipment based on level", function () {
+    testing("PowerDepleter", test => {
+        test.case("generates equipment based on level", check => {
             let template = new PowerDepleter();
 
             let equipment = template.generate(1);
-            expect(equipment.requirements).toEqual({ "skill_antimatter": 1 });
-            expect(equipment.action).toEqual(new TriggerAction(equipment, [
+            check.equals(equipment.requirements, { "skill_antimatter": 1 });
+            check.equals(equipment.action, new TriggerAction(equipment, [
                 new StickyEffect(new AttributeLimitEffect("power_capacity", 3), 2, true)
             ], 4, 460, 0));
-            expect(equipment.price).toEqual(100);
+            check.equals(equipment.price, 100);
 
             equipment = template.generate(2);
-            expect(equipment.requirements).toEqual({ "skill_antimatter": 2 });
-            expect(equipment.action).toEqual(new TriggerAction(equipment, [
+            check.equals(equipment.requirements, { "skill_antimatter": 2 });
+            check.equals(equipment.action, new TriggerAction(equipment, [
                 new StickyEffect(new AttributeLimitEffect("power_capacity", 3), 2, true)
             ], 4, 490, 0));
-            expect(equipment.price).toEqual(350);
+            check.equals(equipment.price, 350);
 
             equipment = template.generate(3);
-            expect(equipment.requirements).toEqual({ "skill_antimatter": 4 });
-            expect(equipment.action).toEqual(new TriggerAction(equipment, [
+            check.equals(equipment.requirements, { "skill_antimatter": 4 });
+            check.equals(equipment.action, new TriggerAction(equipment, [
                 new StickyEffect(new AttributeLimitEffect("power_capacity", 3), 2, true)
             ], 4, 526, 0));
-            expect(equipment.price).toEqual(850);
+            check.equals(equipment.price, 850);
 
             equipment = template.generate(10);
-            expect(equipment.requirements).toEqual({ "skill_antimatter": 25 });
-            expect(equipment.action).toEqual(new TriggerAction(equipment, [
+            check.equals(equipment.requirements, { "skill_antimatter": 25 });
+            check.equals(equipment.action, new TriggerAction(equipment, [
                 new StickyEffect(new AttributeLimitEffect("power_capacity", 3), 2, true)
             ], 4, 946, 0));
-            expect(equipment.price).toEqual(11350);
+            check.equals(equipment.price, 11350);
         });
     });
 }

src/core/equipments/RawWeapons.spec.ts

@@ -1,87 +1,87 @@
 module TK.SpaceTac.Equipments {
-    describe("RawWeapons", function () {
-        it("generates GatlingGun based on level", function () {
+    testing("RawWeapons", test => {
+        test.case("generates GatlingGun based on level", check => {
             let template = new GatlingGun();
 
             let equipment = template.generate(1);
-            expect(equipment.requirements).toEqual({ "skill_materials": 1 });
-            expect(equipment.action).toEqual(new TriggerAction(equipment, [new DamageEffect(30, 20)], 3, 400, 0));
-            expect(equipment.price).toEqual(100);
-            expect(equipment.cooldown).toEqual(new Cooldown(2, 2));
+            check.equals(equipment.requirements, { "skill_materials": 1 });
+            check.equals(equipment.action, new TriggerAction(equipment, [new DamageEffect(30, 20)], 3, 400, 0));
+            check.equals(equipment.price, 100);
+            check.equals(equipment.cooldown, new Cooldown(2, 2));
 
             equipment = template.generate(2);
-            expect(equipment.requirements).toEqual({ "skill_materials": 2 });
-            expect(equipment.action).toEqual(new TriggerAction(equipment, [new DamageEffect(42, 28)], 3, 412, 0));
-            expect(equipment.price).toEqual(350);
-            expect(equipment.cooldown).toEqual(new Cooldown(2, 2));
+            check.equals(equipment.requirements, { "skill_materials": 2 });
+            check.equals(equipment.action, new TriggerAction(equipment, [new DamageEffect(42, 28)], 3, 412, 0));
+            check.equals(equipment.price, 350);
+            check.equals(equipment.cooldown, new Cooldown(2, 2));
 
             equipment = template.generate(3);
-            expect(equipment.requirements).toEqual({ "skill_materials": 4 });
-            expect(equipment.action).toEqual(new TriggerAction(equipment, [new DamageEffect(56, 37)], 3, 426, 0));
-            expect(equipment.price).toEqual(850);
-            expect(equipment.cooldown).toEqual(new Cooldown(2, 2));
+            check.equals(equipment.requirements, { "skill_materials": 4 });
+            check.equals(equipment.action, new TriggerAction(equipment, [new DamageEffect(56, 37)], 3, 426, 0));
+            check.equals(equipment.price, 850);
+            check.equals(equipment.cooldown, new Cooldown(2, 2));
 
             equipment = template.generate(10);
-            expect(equipment.requirements).toEqual({ "skill_materials": 23 });
-            expect(equipment.action).toEqual(new TriggerAction(equipment, [new DamageEffect(224, 149)], 3, 594, 0));
-            expect(equipment.price).toEqual(11350);
-            expect(equipment.cooldown).toEqual(new Cooldown(2, 2));
+            check.equals(equipment.requirements, { "skill_materials": 23 });
+            check.equals(equipment.action, new TriggerAction(equipment, [new DamageEffect(224, 149)], 3, 594, 0));
+            check.equals(equipment.price, 11350);
+            check.equals(equipment.cooldown, new Cooldown(2, 2));
         });
 
-        it("generates SubMunitionMissile based on level", function () {
+        test.case("generates SubMunitionMissile based on level", check => {
             let template = new SubMunitionMissile();
 
             let equipment = template.generate(1);
-            expect(equipment.requirements).toEqual({ "skill_materials": 1, "skill_photons": 1 });
-            expect(equipment.action).toEqual(new TriggerAction(equipment, [new DamageEffect(26, 4)], 4, 500, 150));
-            expect(equipment.cooldown).toEqual(new Cooldown(1, 0));
-            expect(equipment.price).toEqual(163);
+            check.equals(equipment.requirements, { "skill_materials": 1, "skill_photons": 1 });
+            check.equals(equipment.action, new TriggerAction(equipment, [new DamageEffect(26, 4)], 4, 500, 150));
+            check.equals(equipment.cooldown, new Cooldown(1, 0));
+            check.equals(equipment.price, 163);
 
             equipment = template.generate(2);
-            expect(equipment.requirements).toEqual({ "skill_materials": 2, "skill_photons": 1 });
-            expect(equipment.action).toEqual(new TriggerAction(equipment, [new DamageEffect(28, 5)], 4, 520, 155));
-            expect(equipment.cooldown).toEqual(new Cooldown(1, 0));
-            expect(equipment.price).toEqual(570);
+            check.equals(equipment.requirements, { "skill_materials": 2, "skill_photons": 1 });
+            check.equals(equipment.action, new TriggerAction(equipment, [new DamageEffect(28, 5)], 4, 520, 155));
+            check.equals(equipment.cooldown, new Cooldown(1, 0));
+            check.equals(equipment.price, 570);
 
             equipment = template.generate(3);
-            expect(equipment.requirements).toEqual({ "skill_materials": 3, "skill_photons": 2 });
-            expect(equipment.action).toEqual(new TriggerAction(equipment, [new DamageEffect(30, 6)], 4, 544, 161));
-            expect(equipment.cooldown).toEqual(new Cooldown(1, 0));
-            expect(equipment.price).toEqual(1385);
+            check.equals(equipment.requirements, { "skill_materials": 3, "skill_photons": 2 });
+            check.equals(equipment.action, new TriggerAction(equipment, [new DamageEffect(30, 6)], 4, 544, 161));
+            check.equals(equipment.cooldown, new Cooldown(1, 0));
+            check.equals(equipment.price, 1385);
 
             equipment = template.generate(10);
-            expect(equipment.requirements).toEqual({ "skill_materials": 20, "skill_photons": 13 });
-            expect(equipment.action).toEqual(new TriggerAction(equipment, [new DamageEffect(58, 20)], 4, 824, 231));
-            expect(equipment.cooldown).toEqual(new Cooldown(1, 0));
-            expect(equipment.price).toEqual(18500);
+            check.equals(equipment.requirements, { "skill_materials": 20, "skill_photons": 13 });
+            check.equals(equipment.action, new TriggerAction(equipment, [new DamageEffect(58, 20)], 4, 824, 231));
+            check.equals(equipment.cooldown, new Cooldown(1, 0));
+            check.equals(equipment.price, 18500);
         });
 
-        it("generates ProkhorovLaser based on level", function () {
+        test.case("generates ProkhorovLaser based on level", check => {
             let template = new ProkhorovLaser();
 
             let equipment = template.generate(1);
-            expect(equipment.requirements).toEqual({ "skill_photons": 1, "skill_quantum": 1 });
-            expect(equipment.action).toEqual(new TriggerAction(equipment, [new DamageEffect(20, 25)], 5, 300, 0, 40));
-            expect(equipment.cooldown).toEqual(new Cooldown(1, 1));
-            expect(equipment.price).toEqual(152);
+            check.equals(equipment.requirements, { "skill_photons": 1, "skill_quantum": 1 });
+            check.equals(equipment.action, new TriggerAction(equipment, [new DamageEffect(20, 25)], 5, 300, 0, 40));
+            check.equals(equipment.cooldown, new Cooldown(1, 1));
+            check.equals(equipment.price, 152);
 
             equipment = template.generate(2);
-            expect(equipment.requirements).toEqual({ "skill_antimatter": 1, "skill_photons": 2, "skill_quantum": 2 });
-            expect(equipment.action).toEqual(new TriggerAction(equipment, [new DamageEffect(28, 35)], 5, 310, 0, 42));
-            expect(equipment.cooldown).toEqual(new Cooldown(1, 1));
-            expect(equipment.price).toEqual(532);
+            check.equals(equipment.requirements, { "skill_antimatter": 1, "skill_photons": 2, "skill_quantum": 2 });
+            check.equals(equipment.action, new TriggerAction(equipment, [new DamageEffect(28, 35)], 5, 310, 0, 42));
+            check.equals(equipment.cooldown, new Cooldown(1, 1));
+            check.equals(equipment.price, 532);
 
             equipment = template.generate(3);
-            expect(equipment.requirements).toEqual({ "skill_antimatter": 1, "skill_photons": 4, "skill_quantum": 3 });
-            expect(equipment.action).toEqual(new TriggerAction(equipment, [new DamageEffect(37, 47)], 5, 322, 0, 44));
-            expect(equipment.cooldown).toEqual(new Cooldown(1, 1));
-            expect(equipment.price).toEqual(1292);
+            check.equals(equipment.requirements, { "skill_antimatter": 1, "skill_photons": 4, "skill_quantum": 3 });
+            check.equals(equipment.action, new TriggerAction(equipment, [new DamageEffect(37, 47)], 5, 322, 0, 44));
+            check.equals(equipment.cooldown, new Cooldown(1, 1));
+            check.equals(equipment.price, 1292);
 
             equipment = template.generate(10);
-            expect(equipment.requirements).toEqual({ "skill_antimatter": 11, "skill_photons": 23, "skill_quantum": 20 });
-            expect(equipment.action).toEqual(new TriggerAction(equipment, [new DamageEffect(149, 187)], 5, 462, 0, 72));
-            expect(equipment.cooldown).toEqual(new Cooldown(1, 1));
-            expect(equipment.price).toEqual(17252);
+            check.equals(equipment.requirements, { "skill_antimatter": 11, "skill_photons": 23, "skill_quantum": 20 });
+            check.equals(equipment.action, new TriggerAction(equipment, [new DamageEffect(149, 187)], 5, 462, 0, 72));
+            check.equals(equipment.cooldown, new Cooldown(1, 1));
+            check.equals(equipment.price, 17252);
         });
     });
 }

src/core/equipments/RepairDrone.spec.ts

@@ -1,38 +1,38 @@
 module TK.SpaceTac.Equipments {
-    describe("RepairDrone", function () {
-        it("generates equipment based on level", function () {
+    testing("RepairDrone", test => {
+        test.case("generates equipment based on level", check => {
             let template = new RepairDrone();
 
             let equipment = template.generate(1);
-            expect(equipment.requirements).toEqual({ "skill_quantum": 1 });
-            expect(equipment.action).toEqual(new DeployDroneAction(equipment, 4, 300, 10, 150, [
+            check.equals(equipment.requirements, { "skill_quantum": 1 });
+            check.equals(equipment.action, new DeployDroneAction(equipment, 4, 300, 10, 150, [
                 new ValueEffect("hull", 2)
             ]));
 
             equipment = template.generate(2);
-            expect(equipment.requirements).toEqual({ "skill_quantum": 4 });
-            expect(equipment.action).toEqual(new DeployDroneAction(equipment, 4, 310, 11, 155, [
+            check.equals(equipment.requirements, { "skill_quantum": 4 });
+            check.equals(equipment.action, new DeployDroneAction(equipment, 4, 310, 11, 155, [
                 new ValueEffect("hull", 3)
             ]));
 
             equipment = template.generate(3);
-            expect(equipment.requirements).toEqual({ "skill_quantum": 7 });
-            expect(equipment.action).toEqual(new DeployDroneAction(equipment, 4, 322, 12, 161, [
+            check.equals(equipment.requirements, { "skill_quantum": 7 });
+            check.equals(equipment.action, new DeployDroneAction(equipment, 4, 322, 12, 161, [
                 new ValueEffect("hull", 4)
             ]));
 
             equipment = template.generate(10);
-            expect(equipment.requirements).toEqual({ "skill_quantum": 49 });
-            expect(equipment.action).toEqual(new DeployDroneAction(equipment, 10, 462, 26, 231, [
+            check.equals(equipment.requirements, { "skill_quantum": 49 });
+            check.equals(equipment.action, new DeployDroneAction(equipment, 10, 462, 26, 231, [
                 new ValueEffect("hull", 11)
             ]));
         });
 
-        it("generates a drone that may repair ships hull", function () {
+        test.case("generates a drone that may repair ships hull", check => {
             let template = new RepairDrone();
 
             let equipment = template.generate(4);
-            expect(equipment.action).toEqual(new DeployDroneAction(equipment, 5, 336, 13, 168, [
+            check.equals(equipment.action, new DeployDroneAction(equipment, 5, 336, 13, 168, [
                 new ValueEffect("hull", 5)
             ]));
 
@@ -41,17 +41,17 @@ module TK.SpaceTac.Equipments {
             TestTools.setShipPlaying(battle, ship);
             TestTools.setShipAP(ship, 10);
             let result = nn(equipment.action).apply(ship, new Target(5, 5, null));
-            expect(result).toBe(true);
+            check.equals(result, true);
 
-            expect(battle.drones.length).toBe(1);
+            check.equals(battle.drones.length, 1);
             let drone = battle.drones[0];
-            expect(drone.duration).toBe(13);
+            check.equals(drone.duration, 13);
             ship.setAttribute("hull_capacity", 100);
             ship.setValue("hull", 93);
             drone.apply([ship]);
-            expect(ship.getValue("hull")).toBe(98);
+            check.equals(ship.getValue("hull"), 98);
             drone.apply([ship]);
-            expect(ship.getValue("hull")).toBe(100);
+            check.equals(ship.getValue("hull"), 100);
         });
     });
 }

src/core/equipments/ShieldTransfer.spec.ts

@@ -1,33 +1,33 @@
 module TK.SpaceTac.Equipments {
-    describe("ShieldTransfer", () => {
-        it("generates equipment based on level", function () {
+    testing("ShieldTransfer", test => {
+        test.case("generates equipment based on level", check => {
             let template = new ShieldTransfer();
 
             let equipment = template.generate(1);
-            expect(equipment.requirements).toEqual({ "skill_gravity": 2 });
-            expect(equipment.cooldown).toEqual(new Cooldown(3, 3));
-            expect(equipment.action).toEqual(new TriggerAction(equipment, [
+            check.equals(equipment.requirements, { "skill_gravity": 2 });
+            check.equals(equipment.cooldown, new Cooldown(3, 3));
+            check.equals(equipment.action, new TriggerAction(equipment, [
                 new ValueTransferEffect("shield", -40)
             ], 3, 0, 250));
 
             equipment = template.generate(2);
-            expect(equipment.requirements).toEqual({ "skill_gravity": 3 });
-            expect(equipment.cooldown).toEqual(new Cooldown(3, 3));
-            expect(equipment.action).toEqual(new TriggerAction(equipment, [
+            check.equals(equipment.requirements, { "skill_gravity": 3 });
+            check.equals(equipment.cooldown, new Cooldown(3, 3));
+            check.equals(equipment.action, new TriggerAction(equipment, [
                 new ValueTransferEffect("shield", -44)
             ], 3, 0, 270));
 
             equipment = template.generate(3);
-            expect(equipment.requirements).toEqual({ "skill_gravity": 5 });
-            expect(equipment.cooldown).toEqual(new Cooldown(3, 3));
-            expect(equipment.action).toEqual(new TriggerAction(equipment, [
+            check.equals(equipment.requirements, { "skill_gravity": 5 });
+            check.equals(equipment.cooldown, new Cooldown(3, 3));
+            check.equals(equipment.action, new TriggerAction(equipment, [
                 new ValueTransferEffect("shield", -49)
             ], 3, 0, 294));
 
             equipment = template.generate(10);
-            expect(equipment.requirements).toEqual({ "skill_gravity": 26 });
-            expect(equipment.cooldown).toEqual(new Cooldown(3, 3));
-            expect(equipment.action).toEqual(new TriggerAction(equipment, [
+            check.equals(equipment.requirements, { "skill_gravity": 26 });
+            check.equals(equipment.cooldown, new Cooldown(3, 3));
+            check.equals(equipment.action, new TriggerAction(equipment, [
                 new ValueTransferEffect("shield", -105)
             ], 3, 0, 574));
         })

src/core/equipments/Shields.spec.ts

@@ -1,99 +1,99 @@
 module TK.SpaceTac.Equipments {
-    describe("Shields", function () {
-        it("generates ForceField based on level", function () {
+    testing("Shields", test => {
+        test.case("generates ForceField based on level", check => {
             let template = new ForceField();
 
             let equipment = template.generate(1);
-            expect(equipment.requirements).toEqual({ "skill_photons": 1 });
-            expect(equipment.effects).toEqual([new AttributeEffect("shield_capacity", 80)]);
-            expect(equipment.price).toEqual(95);
+            check.equals(equipment.requirements, { "skill_photons": 1 });
+            check.equals(equipment.effects, [new AttributeEffect("shield_capacity", 80)]);
+            check.equals(equipment.price, 95);
 
             equipment = template.generate(2);
-            expect(equipment.requirements).toEqual({ "skill_photons": 3 });
-            expect(equipment.effects).toEqual([new AttributeEffect("shield_capacity", 112)]);
-            expect(equipment.price).toEqual(332);
+            check.equals(equipment.requirements, { "skill_photons": 3 });
+            check.equals(equipment.effects, [new AttributeEffect("shield_capacity", 112)]);
+            check.equals(equipment.price, 332);
 
             equipment = template.generate(3);
-            expect(equipment.requirements).toEqual({ "skill_photons": 5 });
-            expect(equipment.effects).toEqual([new AttributeEffect("shield_capacity", 150)]);
-            expect(equipment.price).toEqual(807);
+            check.equals(equipment.requirements, { "skill_photons": 5 });
+            check.equals(equipment.effects, [new AttributeEffect("shield_capacity", 150)]);
+            check.equals(equipment.price, 807);
 
             equipment = template.generate(10);
-            expect(equipment.requirements).toEqual({ "skill_photons": 33 });
-            expect(equipment.effects).toEqual([new AttributeEffect("shield_capacity", 598)]);
-            expect(equipment.price).toEqual(10782);
+            check.equals(equipment.requirements, { "skill_photons": 33 });
+            check.equals(equipment.effects, [new AttributeEffect("shield_capacity", 598)]);
+            check.equals(equipment.price, 10782);
         });
 
-        it("generates GravitShield based on level", function () {
+        test.case("generates GravitShield based on level", check => {
             let template = new GravitShield();
 
             let equipment = template.generate(1);
-            expect(equipment.requirements).toEqual({ "skill_gravity": 2 });
-            expect(equipment.effects).toEqual([
+            check.equals(equipment.requirements, { "skill_gravity": 2 });
+            check.equals(equipment.effects, [
                 new AttributeEffect("shield_capacity", 60),
             ]);
-            expect(equipment.action).toEqual(new TriggerAction(equipment, [new RepelEffect(100)], 2, 0, 300));
-            expect(equipment.price).toEqual(140);
+            check.equals(equipment.action, new TriggerAction(equipment, [new RepelEffect(100)], 2, 0, 300));
+            check.equals(equipment.price, 140);
 
             equipment = template.generate(2);
-            expect(equipment.requirements).toEqual({ "skill_gravity": 5 });
-            expect(equipment.effects).toEqual([
+            check.equals(equipment.requirements, { "skill_gravity": 5 });
+            check.equals(equipment.effects, [
                 new AttributeEffect("shield_capacity", 84),
             ]);
-            expect(equipment.action).toEqual(new TriggerAction(equipment, [new RepelEffect(105)], 2, 0, 310));
-            expect(equipment.price).toEqual(490);
+            check.equals(equipment.action, new TriggerAction(equipment, [new RepelEffect(105)], 2, 0, 310));
+            check.equals(equipment.price, 490);
 
             equipment = template.generate(3);
-            expect(equipment.requirements).toEqual({ "skill_gravity": 8 });
-            expect(equipment.effects).toEqual([
+            check.equals(equipment.requirements, { "skill_gravity": 8 });
+            check.equals(equipment.effects, [
                 new AttributeEffect("shield_capacity", 112),
             ]);
-            expect(equipment.action).toEqual(new TriggerAction(equipment, [new RepelEffect(111)], 2, 0, 322));
-            expect(equipment.price).toEqual(1190);
+            check.equals(equipment.action, new TriggerAction(equipment, [new RepelEffect(111)], 2, 0, 322));
+            check.equals(equipment.price, 1190);
 
             equipment = template.generate(10);
-            expect(equipment.requirements).toEqual({ "skill_gravity": 50 });
-            expect(equipment.effects).toEqual([
+            check.equals(equipment.requirements, { "skill_gravity": 50 });
+            check.equals(equipment.effects, [
                 new AttributeEffect("shield_capacity", 448),
             ]);
-            expect(equipment.action).toEqual(new TriggerAction(equipment, [new RepelEffect(181)], 2, 0, 462));
-            expect(equipment.price).toEqual(15890);
+            check.equals(equipment.action, new TriggerAction(equipment, [new RepelEffect(181)], 2, 0, 462));
+            check.equals(equipment.price, 15890);
         });
 
-        it("generates InverterShield based on level", function () {
+        test.case("generates InverterShield based on level", check => {
             let template = new InverterShield();
 
             let equipment = template.generate(1);
-            expect(equipment.requirements).toEqual({ "skill_antimatter": 2, "skill_time": 1 });
-            expect(equipment.effects).toEqual([
+            check.equals(equipment.requirements, { "skill_antimatter": 2, "skill_time": 1 });
+            check.equals(equipment.effects, [
                 new AttributeEffect("shield_capacity", 140),
                 new AttributeEffect("power_capacity", -1),
             ]);
-            expect(equipment.price).toEqual(258);
+            check.equals(equipment.price, 258);
 
             equipment = template.generate(2);
-            expect(equipment.requirements).toEqual({ "skill_antimatter": 3, "skill_time": 2 });
-            expect(equipment.effects).toEqual([
+            check.equals(equipment.requirements, { "skill_antimatter": 3, "skill_time": 2 });
+            check.equals(equipment.effects, [
                 new AttributeEffect("shield_capacity", 196),
                 new AttributeEffect("power_capacity", -1),
             ]);
-            expect(equipment.price).toEqual(903);
+            check.equals(equipment.price, 903);
 
             equipment = template.generate(3);
-            expect(equipment.requirements).toEqual({ "skill_antimatter": 5, "skill_time": 3 });
-            expect(equipment.effects).toEqual([
+            check.equals(equipment.requirements, { "skill_antimatter": 5, "skill_time": 3 });
+            check.equals(equipment.effects, [
                 new AttributeEffect("shield_capacity", 263),
                 new AttributeEffect("power_capacity", -1),
             ]);
-            expect(equipment.price).toEqual(2193);
+            check.equals(equipment.price, 2193);
 
             equipment = template.generate(10);
-            expect(equipment.requirements).toEqual({ "skill_antimatter": 26, "skill_time": 17 });
-            expect(equipment.effects).toEqual([
+            check.equals(equipment.requirements, { "skill_antimatter": 26, "skill_time": 17 });
+            check.equals(equipment.effects, [
                 new AttributeEffect("shield_capacity", 1047),
                 new AttributeEffect("power_capacity", -4),
             ]);
-            expect(equipment.price).toEqual(29283);
+            check.equals(equipment.price, 29283);
         });
     });
 }

src/core/events/MoveEvent.spec.ts

@@ -1,9 +1,9 @@
 module TK.SpaceTac.Specs {
-    describe("MoveEvent", function () {
-        it("get reverse event", function () {
+    testing("MoveEvent", test => {
+        test.case("get reverse event", check => {
             let ship = new Ship();
             let event = new MoveEvent(ship, new ArenaLocationAngle(0, 0, 0), new ArenaLocationAngle(5, 10, 1.2));
-            expect(event.getReverse()).toEqual(new MoveEvent(ship, new ArenaLocationAngle(5, 10, 1.2), new ArenaLocationAngle(0, 0, 0)));
+            check.equals(event.getReverse(), new MoveEvent(ship, new ArenaLocationAngle(5, 10, 1.2), new ArenaLocationAngle(0, 0, 0)));
         });
     });
 }

src/core/events/ShipChangeEvent.spec.ts

@@ -1,10 +1,10 @@
 module TK.SpaceTac.Specs {
-    describe("ShipChangeEvent", function () {
-        it("get reverse event", function () {
+    testing("ShipChangeEvent", test => {
+        test.case("get reverse event", check => {
             let ship1 = new Ship();
             let ship2 = new Ship();
             let event = new ShipChangeEvent(ship1, ship2);
-            expect(event.getReverse()).toEqual(new ShipChangeEvent(ship2, ship1));
+            check.equals(event.getReverse(), new ShipChangeEvent(ship2, ship1));
         });
     });
 }

src/core/missions/ActiveMissions.spec.ts

@@ -1,17 +1,17 @@
 module TK.SpaceTac.Specs {
-    describe("ActiveMissions", () => {
-        it("starts the main story arc", function () {
+    testing("ActiveMissions", test => {
+        test.case("starts the main story arc", check => {
             let missions = new ActiveMissions();
-            expect(missions.main).toBeNull();
+            check.equals(missions.main, null);
 
             let session = new GameSession();
             session.startNewGame(true, false);
 
             missions.startMainStory(session.universe, session.player.fleet);
-            expect(missions.main).not.toBeNull();
+            check.notequals(missions.main, null);
         })
 
-        it("gets the current list of missions, and updates them", function () {
+        test.case("gets the current list of missions, and updates them", check => {
             let missions = new ActiveMissions();
             let universe = new Universe();
             let fleet = new Fleet();
@@ -25,7 +25,7 @@ module TK.SpaceTac.Specs {
             missions.secondary[0].addPart(new MissionPart(missions.secondary[0], "Maybe do something"));
             missions.secondary[1].addPart(new MissionPart(missions.secondary[1], "Surely do something"));
 
-            expect(missions.getCurrent().map(mission => mission.current_part.title)).toEqual([
+            check.equals(missions.getCurrent().map(mission => mission.current_part.title), [
                 "Do something",
                 "Maybe do something",
                 "Surely do something",
@@ -33,7 +33,7 @@ module TK.SpaceTac.Specs {
 
             missions.checkStatus();
 
-            expect(missions.getCurrent().map(mission => mission.current_part.title)).toEqual([
+            check.equals(missions.getCurrent().map(mission => mission.current_part.title), [
                 "Do something",
                 "Maybe do something",
                 "Surely do something",
@@ -42,7 +42,7 @@ module TK.SpaceTac.Specs {
             spyOn(missions.secondary[0].current_part, "checkCompleted").and.returnValue(true);
             missions.checkStatus();
 
-            expect(missions.getCurrent().map(mission => mission.current_part.title)).toEqual([
+            check.equals(missions.getCurrent().map(mission => mission.current_part.title), [
                 "Do something",
                 "Surely do something",
             ]);
@@ -50,13 +50,13 @@ module TK.SpaceTac.Specs {
             spyOn(missions.main.current_part, "checkCompleted").and.returnValue(true);
             missions.checkStatus();
 
-            expect(missions.getCurrent().map(mission => mission.current_part.title)).toEqual([
+            check.equals(missions.getCurrent().map(mission => mission.current_part.title), [
                 "Surely do something",
             ]);
-            expect(missions.main).toBeNull();
+            check.equals(missions.main, null);
         })
 
-        it("builds a hash to help monitor status changes", function () {
+        test.case("builds a hash to help monitor status changes", check => {
             let universe = new Universe();
             universe.generate(4);
             let fleet = new Fleet();
@@ -66,9 +66,9 @@ module TK.SpaceTac.Specs {
             let hash = missions.getHash();
             function checkChanged(info: string, expected = true) {
                 let new_hash = missions.getHash();
-                expect(new_hash != hash).toBe(expected, info);
+                check.same(new_hash != hash, expected, info);
                 hash = new_hash;
-                expect(missions.getHash()).toEqual(hash, "Stable after " + info);
+                check.equals(missions.getHash(), hash, "Stable after " + info);
             }
             checkChanged("Stable at init", false);
 
@@ -81,14 +81,14 @@ module TK.SpaceTac.Specs {
             missions.addSecondary(mission, fleet);
             checkChanged("Secondary mission accepted");
 
-            expect(mission.getIndex()).toBe(0);
+            check.equals(mission.getIndex(), 0);
             missions.checkStatus();
-            expect(mission.getIndex()).toBe(1);
+            check.equals(mission.getIndex(), 1);
             checkChanged("First conversation ended");
 
-            expect(missions.secondary.length).toBe(1);
+            check.equals(missions.secondary.length, 1);
             missions.checkStatus();
-            expect(missions.secondary.length).toBe(0);
+            check.equals(missions.secondary.length, 0);
             checkChanged("Second conversation ended - mission removed");
 
             nn(missions.main).current_part.forceComplete();

src/core/missions/MainStory.spec.ts

@@ -1,11 +1,11 @@
 module TK.SpaceTac.Specs {
-    describe("MainStory", () => {
+    testing("MainStory", test => {
         function checkPart(story: Mission, index: number, title: string, completed = false) {
             let result = story.checkStatus();
-            expect(story.parts.indexOf(story.current_part)).toBe(index);
+            test.check.same(story.parts.indexOf(story.current_part), index);
             expect(story.current_part.title).toMatch(title);
-            expect(story.completed).toBe(completed);
-            expect(result).toBe(!completed);
+            test.check.same(story.completed, completed);
+            test.check.same(result, !completed);
         }
 
         function goTo(fleet: Fleet, location: StarLocation, win_encounter = true) {
@@ -20,7 +20,7 @@ module TK.SpaceTac.Specs {
             }
         }
 
-        it("can be completed", function () {
+        test.case("can be completed", check => {
             let session = new GameSession();
             session.startNewGame(true, true);
             let fleet = nn(session.player.fleet);
@@ -39,18 +39,18 @@ module TK.SpaceTac.Specs {
             (<MissionPartConversation>story.current_part).skip();
 
             checkPart(story, 3, "^Go with .* in .* system$");
-            expect(fleet.ships.length).toBe(fleet_size + 1);
+            check.same(fleet.ships.length, fleet_size + 1);
             goTo(fleet, (<MissionPartEscort>story.current_part).destination);
 
             checkPart(story, 4, "^Listen to .*$");
             (<MissionPartConversation>story.current_part).skip();
-            expect(session.getBattle()).toBeNull();
+            check.equals(session.getBattle(), null);
 
             checkPart(story, 5, "^Fight the arrived fleet$");
-            expect(session.getBattle()).not.toBeNull();
+            check.notequals(session.getBattle(), null);
             nn(session.getBattle()).endBattle(fleet);
 
-            expect(story.checkStatus()).toBe(false, "story not complete");
+            check.same(story.checkStatus(), false, "story not complete");
         })
     })
 }

src/core/missions/Mission.spec.ts

@@ -1,50 +1,50 @@
 module TK.SpaceTac.Specs {
-    describe("Mission", () => {
-        it("check step status", function () {
+    testing("Mission", test => {
+        test.case("check step status", check => {
             let universe = new Universe();
             let fleet = new Fleet();
             let mission = new Mission(universe, fleet);
             mission.addPart(new MissionPart(mission, "Part 1"));
             mission.addPart(new MissionPart(mission, "Part 2"));
 
-            expect(mission.current_part).toBe(mission.parts[0]);
+            check.same(mission.current_part, mission.parts[0]);
 
             let result = mission.checkStatus();
-            expect(result).toBe(true);
-            expect(mission.current_part).toBe(mission.parts[0]);
+            check.equals(result, true);
+            check.same(mission.current_part, mission.parts[0]);
 
             spyOn(mission.parts[0], "checkCompleted").and.returnValues(false, true);
 
             result = mission.checkStatus();
-            expect(result).toBe(true);
-            expect(mission.current_part).toBe(mission.parts[0]);
+            check.equals(result, true);
+            check.same(mission.current_part, mission.parts[0]);
             result = mission.checkStatus();
-            expect(result).toBe(true);
-            expect(mission.current_part).toBe(mission.parts[1]);
+            check.equals(result, true);
+            check.same(mission.current_part, mission.parts[1]);
             result = mission.checkStatus();
-            expect(result).toBe(true);
-            expect(mission.current_part).toBe(mission.parts[1]);
+            check.equals(result, true);
+            check.same(mission.current_part, mission.parts[1]);
 
             spyOn(mission.parts[1], "checkCompleted").and.returnValue(true);
 
             result = mission.checkStatus();
-            expect(result).toBe(false);
-            expect(mission.current_part).toBe(mission.parts[1]);
+            check.equals(result, false);
+            check.same(mission.current_part, mission.parts[1]);
         })
 
-        it("stores a reward", function () {
+        test.case("stores a reward", check => {
             let mission = new Mission(new Universe());
-            expect(mission.getRewardText()).toEqual("-");
+            check.equals(mission.getRewardText(), "-");
 
             mission.reward = 720;
-            expect(mission.getRewardText()).toEqual("720 zotys");
+            check.equals(mission.getRewardText(), "720 zotys");
 
             mission.reward = new Equipment();
             mission.reward.name = "Super Equipment";
-            expect(mission.getRewardText()).toEqual("Super Equipment Mk1");
+            check.equals(mission.getRewardText(), "Super Equipment Mk1");
         })
 
-        it("gives the reward on completion", function () {
+        test.case("gives the reward on completion", check => {
             let fleet = new Fleet();
             let ship = fleet.addShip();
             ship.cargo_space = 5;
@@ -53,19 +53,19 @@ module TK.SpaceTac.Specs {
             let mission = new Mission(new Universe(), fleet);
             mission.reward = 75;
             mission.setCompleted();
-            expect(mission.completed).toBe(true);
-            expect(fleet.credits).toBe(225);
+            check.equals(mission.completed, true);
+            check.equals(fleet.credits, 225);
 
             mission.setCompleted();
-            expect(fleet.credits).toBe(225);
+            check.equals(fleet.credits, 225);
 
             mission = new Mission(new Universe(), fleet);
             mission.reward = new Equipment();
-            expect(ship.cargo).toEqual([]);
+            check.equals(ship.cargo, []);
             mission.setCompleted();
-            expect(mission.completed).toBe(true);
-            expect(fleet.credits).toBe(225);
-            expect(ship.cargo).toEqual([mission.reward]);
+            check.equals(mission.completed, true);
+            check.equals(fleet.credits, 225);
+            check.equals(ship.cargo, [mission.reward]);
         })
     })
 }

src/core/missions/MissionGenerator.spec.ts

@@ -1,6 +1,6 @@
 module TK.SpaceTac.Specs {
-    describe("MissionGenerator", function () {
-        it("generates escort missions", function () {
+    testing("MissionGenerator", test => {
+        test.case("generates escort missions", check => {
             let universe = new Universe();
             let star1 = universe.addStar(1);
             let loc1 = star1.locations[0];
@@ -11,17 +11,17 @@ module TK.SpaceTac.Specs {
             let generator = new MissionGenerator(universe, loc1);
             let mission = generator.generateEscort();
 
-            expect(mission.title).toBe("Escort a ship to a level 2 system");
-            expect(mission.parts.length).toBe(3);
-            expect(mission.parts[0] instanceof MissionPartConversation).toBe(true);
-            expect(mission.parts[1] instanceof MissionPartEscort).toBe(true);
+            check.equals(mission.title, "Escort a ship to a level 2 system");
+            check.equals(mission.parts.length, 3);
+            check.equals(mission.parts[0] instanceof MissionPartConversation, true);
+            check.equals(mission.parts[1] instanceof MissionPartEscort, true);
             let escort = <MissionPartEscort>mission.parts[1];
-            expect(escort.destination).toBe(loc2);
-            expect(escort.ship.level.get()).toBe(2);
-            expect(mission.parts[2] instanceof MissionPartConversation).toBe(true);
+            check.same(escort.destination, loc2);
+            check.equals(escort.ship.level.get(), 2);
+            check.equals(mission.parts[2] instanceof MissionPartConversation, true);
         })
 
-        it("generates location cleaning missions", function () {
+        test.case("generates location cleaning missions", check => {
             let universe = new Universe();
             let star1 = universe.addStar(1, "TTX");
             let loc1 = star1.locations[0];
@@ -30,77 +30,77 @@ module TK.SpaceTac.Specs {
             let generator = new MissionGenerator(universe, loc1);
             let mission = generator.generateCleanLocation();
 
-            expect(mission.title).toBe("Defeat a level 1 fleet in this system");
-            expect(mission.parts.length).toBe(4);
-            expect(mission.parts[0] instanceof MissionPartConversation).toBe(true);
-            expect(mission.parts[1] instanceof MissionPartCleanLocation).toBe(true);
+            check.equals(mission.title, "Defeat a level 1 fleet in this system");
+            check.equals(mission.parts.length, 4);
+            check.equals(mission.parts[0] instanceof MissionPartConversation, true);
+            check.equals(mission.parts[1] instanceof MissionPartCleanLocation, true);
             let part1 = <MissionPartCleanLocation>mission.parts[1];
-            expect(part1.destination).toBe(loc2);
-            expect(part1.title).toEqual("Clean a planet in TTX system");
-            expect(mission.parts[2] instanceof MissionPartGoTo).toBe(true);
+            check.same(part1.destination, loc2);
+            check.equals(part1.title, "Clean a planet in TTX system");
+            check.equals(mission.parts[2] instanceof MissionPartGoTo, true);
             let part2 = <MissionPartGoTo>mission.parts[2];
-            expect(part2.destination).toBe(loc1);
-            expect(part2.title).toEqual("Go back to collect your reward");
-            expect(mission.parts[3] instanceof MissionPartConversation).toBe(true);
+            check.same(part2.destination, loc1);
+            check.equals(part2.title, "Go back to collect your reward");
+            check.equals(mission.parts[3] instanceof MissionPartConversation, true);
         })
 
-        it("helps to evaluate mission difficulty", function () {
+        test.case("helps to evaluate mission difficulty", check => {
             let generator = new MissionGenerator(new Universe(), new StarLocation());
             let mission = new Mission(generator.universe);
-            expect(mission.difficulty).toBe(MissionDifficulty.normal);
-            expect(mission.value).toBe(0);
+            check.same(mission.difficulty, MissionDifficulty.normal);
+            check.equals(mission.value, 0);
 
             generator.setDifficulty(mission, 1000, 1);
-            expect(mission.difficulty).toBe(MissionDifficulty.normal);
-            expect(mission.value).toBe(1000);
+            check.same(mission.difficulty, MissionDifficulty.normal);
+            check.equals(mission.value, 1000);
 
             generator.setDifficulty(mission, 1000, 2);
-            expect(mission.difficulty).toBe(MissionDifficulty.hard);
-            expect(mission.value).toBe(2200);
+            check.same(mission.difficulty, MissionDifficulty.hard);
+            check.equals(mission.value, 2200);
 
             generator.setDifficulty(mission, 1000, 3);
-            expect(mission.difficulty).toBe(MissionDifficulty.hard);
-            expect(mission.value).toBe(3600);
+            check.same(mission.difficulty, MissionDifficulty.hard);
+            check.equals(mission.value, 3600);
 
             generator.around.star.level = 10;
 
             generator.setDifficulty(mission, 1000, 10);
-            expect(mission.difficulty).toBe(MissionDifficulty.normal);
-            expect(mission.value).toBe(10000);
+            check.same(mission.difficulty, MissionDifficulty.normal);
+            check.equals(mission.value, 10000);
 
             generator.setDifficulty(mission, 1000, 9);
-            expect(mission.difficulty).toBe(MissionDifficulty.easy);
-            expect(mission.value).toBe(8100);
+            check.same(mission.difficulty, MissionDifficulty.easy);
+            check.equals(mission.value, 8100);
 
             generator.setDifficulty(mission, 1000, 8);
-            expect(mission.difficulty).toBe(MissionDifficulty.easy);
-            expect(mission.value).toBe(6400);
+            check.same(mission.difficulty, MissionDifficulty.easy);
+            check.equals(mission.value, 6400);
         })
 
-        it("generates equipment reward", function () {
+        test.case("generates equipment reward", check => {
             let generator = new MissionGenerator(new Universe(), new StarLocation());
             let template = new LootTemplate(SlotType.Weapon, "Test Weapon");
             generator.equipment_generator.templates = [template];
 
             template.price = irepeat(350);
             let result = generator.tryGenerateEquipmentReward(500);
-            expect(result).toBeNull();
+            check.equals(result, null);
 
             template.price = irepeat(800);
             result = generator.tryGenerateEquipmentReward(500);
-            expect(result).toBeNull();
+            check.equals(result, null);
 
             template.price = irepeat(500);
             result = generator.tryGenerateEquipmentReward(500);
-            expect(result).not.toBeNull();
+            check.notequals(result, null);
         })
 
-        it("falls back to money reward when no suitable equipment have been generated", function () {
+        test.case("falls back to money reward when no suitable equipment have been generated", check => {
             let generator = new MissionGenerator(new Universe(), new StarLocation());
             generator.equipment_generator.templates = [];
 
             let result = generator.generateReward(15000);
-            expect(result).toBe(15000);
+            check.equals(result, 15000);
 
             let template = new LootTemplate(SlotType.Weapon, "Test Weapon");
             template.price = irepeat(15000);
@@ -108,7 +108,7 @@ module TK.SpaceTac.Specs {
 
             generator.random = new SkewedRandomGenerator([0], true);
             result = generator.generateReward(15000);
-            expect(result instanceof Equipment).toBe(true);
+            check.equals(result instanceof Equipment, true);
         })
     });
 }

src/core/missions/MissionPartCleanLocation.spec.ts

@@ -1,6 +1,6 @@
 module TK.SpaceTac.Specs {
-    describe("MissionPartEscort", () => {
-        it("completes when the fleet is at location, and the encounter is clean", function () {
+    testing("MissionPartEscort", test => {
+        test.case("completes when the fleet is at location, and the encounter is clean", check => {
             let destination = new StarLocation(new Star(null, 0, 0, "Atanax"));
             destination.clearEncounter();
 
@@ -8,21 +8,21 @@ module TK.SpaceTac.Specs {
             let fleet = new Fleet();
             let part = new MissionPartCleanLocation(new Mission(universe, fleet), destination);
 
-            expect(part.title).toEqual("Clean a planet in Atanax system");
-            expect(part.checkCompleted()).toBe(false, "Init location");
+            check.equals(part.title, "Clean a planet in Atanax system");
+            check.same(part.checkCompleted(), false, "Init location");
 
-            expect(destination.isClear()).toBe(true);
+            check.equals(destination.isClear(), true);
             part.onStarted();
-            expect(destination.isClear()).toBe(false);
+            check.equals(destination.isClear(), false);
 
             fleet.setLocation(destination, true);
-            expect(part.checkCompleted()).toBe(false, "Encounter not clear");
+            check.same(part.checkCompleted(), false, "Encounter not clear");
 
             destination.clearEncounter();
-            expect(part.checkCompleted()).toBe(true, "Encouter cleared");
+            check.same(part.checkCompleted(), true, "Encouter cleared");
         })
 
-        it("generates the battle immediately if the fleet is already at the destination", function () {
+        test.case("generates the battle immediately if the fleet is already at the destination", check => {
             let destination = new StarLocation(new Star(null, 0, 0, "Atanax"));
             destination.clearEncounter();
 
@@ -31,11 +31,11 @@ module TK.SpaceTac.Specs {
             fleet.setLocation(destination, true);
             let part = new MissionPartCleanLocation(new Mission(universe, fleet), destination);
 
-            expect(fleet.battle).toBeNull();
+            check.equals(fleet.battle, null);
             part.onStarted();
-            expect(fleet.battle).not.toBeNull();
-            expect(nn(fleet.battle).fleets).toEqual([fleet, nn(destination.encounter)]);
-            expect(part.checkCompleted()).toBe(false);
+            check.notequals(fleet.battle, null);
+            check.equals(nn(fleet.battle).fleets, [fleet, nn(destination.encounter)]);
+            check.equals(part.checkCompleted(), false);
         })
     })
 }

src/core/missions/MissionPartConversation.spec.ts

@@ -1,38 +1,38 @@
 module TK.SpaceTac.Specs {
-    describe("MissionPartConversation", () => {
-        it("advances through conversation", function () {
+    testing("MissionPartConversation", test => {
+        test.case("advances through conversation", check => {
             let universe = new Universe();
             let fleet = new Fleet();
             let ship1 = new Ship(null, "Tim");
             let ship2 = new Ship(null, "Ben");
             let part = new MissionPartConversation(new Mission(universe, fleet), [ship1, ship2], "Talk to Tim");
 
-            expect(part.title).toEqual("Talk to Tim");
-            expect(part.checkCompleted()).toBe(true, "No dialog piece");
+            check.equals(part.title, "Talk to Tim");
+            check.same(part.checkCompleted(), true, "No dialog piece");
 
             part.addPiece(ship1, "Hi !");
             part.addPiece(ship2, "Indeed, hi !");
             part.addPiece(null, "Hum, hello.");
-            expect(part.checkCompleted()).toBe(false, "Dialog pieces added");
-            expect(part.getCurrent()).toEqual({ interlocutor: ship1, message: "Hi !" });
+            check.same(part.checkCompleted(), false, "Dialog pieces added");
+            check.equals(part.getCurrent(), { interlocutor: ship1, message: "Hi !" });
 
             part.next();
-            expect(part.checkCompleted()).toBe(false, "Second piece");
-            expect(part.getCurrent()).toEqual({ interlocutor: ship2, message: "Indeed, hi !" });
+            check.same(part.checkCompleted(), false, "Second piece");
+            check.equals(part.getCurrent(), { interlocutor: ship2, message: "Indeed, hi !" });
 
             part.next();
-            expect(part.checkCompleted()).toBe(false, "Last piece");
-            expect(part.getCurrent()).toEqual({ interlocutor: null, message: "Hum, hello." });
+            check.same(part.checkCompleted(), false, "Last piece");
+            check.equals(part.getCurrent(), { interlocutor: null, message: "Hum, hello." });
 
             let ship = fleet.addShip();
-            expect(part.getCurrent()).toEqual({ interlocutor: ship, message: "Hum, hello." });
+            check.equals(part.getCurrent(), { interlocutor: ship, message: "Hum, hello." });
 
             part.next();
-            expect(part.checkCompleted()).toBe(true, "Dialog ended");
-            expect(part.getCurrent()).toEqual({ interlocutor: null, message: "" });
+            check.same(part.checkCompleted(), true, "Dialog ended");
+            check.equals(part.getCurrent(), { interlocutor: null, message: "" });
         })
 
-        it("force completes", function () {
+        test.case("force completes", check => {
             let universe = new Universe();
             let fleet = new Fleet();
             let ship = new Ship(null, "Tim");
@@ -40,13 +40,13 @@ module TK.SpaceTac.Specs {
             part.addPiece(null, "Hello !");
             part.addPiece(ship, "Hiya !");
 
-            expect(part.title).toEqual("Speak with Tim");
-            expect(part.checkCompleted()).toBe(false);
-            expect(part.getCurrent()).toEqual({ interlocutor: null, message: "Hello !" });
+            check.equals(part.title, "Speak with Tim");
+            check.equals(part.checkCompleted(), false);
+            check.equals(part.getCurrent(), { interlocutor: null, message: "Hello !" });
 
             part.forceComplete();
-            expect(part.checkCompleted()).toBe(true);
-            expect(part.getCurrent()).toEqual({ interlocutor: null, message: "" });
+            check.equals(part.checkCompleted(), true);
+            check.equals(part.getCurrent(), { interlocutor: null, message: "" });
         });
     })
 }

src/core/missions/MissionPartEscort.spec.ts

@@ -1,6 +1,6 @@
 module TK.SpaceTac.Specs {
-    describe("MissionPartEscort", () => {
-        it("completes when the fleet is at location, with its escort", function () {
+    testing("MissionPartEscort", test => {
+        test.case("completes when the fleet is at location, with its escort", check => {
             let destination = new StarLocation(new Star(null, 0, 0, "Atanax"));
             destination.encounter_random = new SkewedRandomGenerator([0], true);
 
@@ -9,31 +9,31 @@ module TK.SpaceTac.Specs {
             let ship = new Ship(null, "Zybux");
             let part = new MissionPartEscort(new Mission(universe, fleet), destination, ship);
 
-            expect(fleet.ships).not.toContain(ship);
-            expect(part.title).toEqual("Escort Zybux to Atanax system");
-            expect(part.checkCompleted()).toBe(false, "Init location");
+            check.notcontains(fleet.ships, ship);
+            check.equals(part.title, "Escort Zybux to Atanax system");
+            check.same(part.checkCompleted(), false, "Init location");
 
             part.onStarted();
-            expect(fleet.ships).toContain(ship);
+            check.contains(fleet.ships, ship);
 
             fleet.setLocation(destination, true);
-            expect(part.checkCompleted()).toBe(false, "Encounter not clear");
+            check.same(part.checkCompleted(), false, "Encounter not clear");
 
             destination.clearEncounter();
-            expect(part.checkCompleted()).toBe(true, "Encouter cleared");
+            check.same(part.checkCompleted(), true, "Encouter cleared");
 
             fleet.setLocation(new StarLocation(), true);
-            expect(part.checkCompleted()).toBe(false, "Went to another system");
+            check.same(part.checkCompleted(), false, "Went to another system");
 
             fleet.setLocation(destination, true);
-            expect(part.checkCompleted()).toBe(true, "Back at destination");
-            expect(fleet.ships).toContain(ship);
+            check.same(part.checkCompleted(), true, "Back at destination");
+            check.contains(fleet.ships, ship);
 
             part.onEnded();
-            expect(fleet.ships).not.toContain(ship);
+            check.notcontains(fleet.ships, ship);
         })
 
-        it("sets the escorted ship as critical in battles", function () {
+        test.case("sets the escorted ship as critical in battles", check => {
             let universe = new Universe();
             let fleet = new Fleet();
             let ship1 = fleet.addShip();
@@ -43,25 +43,25 @@ module TK.SpaceTac.Specs {
             let part = new MissionPartEscort(new Mission(universe, fleet), destination, ship);
 
             part.onStarted();
-            expect(fleet.ships).toContain(ship);
+            check.contains(fleet.ships, ship);
 
             let enemy = new Fleet();
             enemy.addShip();
             let battle = new Battle(fleet, enemy);
             battle.start();
             battle.checkEndBattle();
-            expect(battle.ended).toBe(false);
+            check.equals(battle.ended, false);
 
             // if a fleet member dies, it is not over
             ship1.setDead();
             battle.checkEndBattle();
-            expect(battle.ended).toBe(false);
+            check.equals(battle.ended, false);
 
             // if the critical ship dies, it is defeat
             ship.setDead();
             battle.checkEndBattle();
-            expect(battle.ended).toBe(true);
-            expect(battle.outcome.winner).not.toBe(fleet);
+            check.equals(battle.ended, true);
+            check.notsame(battle.outcome.winner, fleet);
         })
     })
 }

src/core/missions/MissionPartGoTo.spec.ts

@@ -1,6 +1,6 @@
 module TK.SpaceTac.Specs {
-    describe("MissionPartGoTo", () => {
-        it("completes when the fleet is at location, without encounter", function () {
+    testing("MissionPartGoTo", test => {
+        test.case("completes when the fleet is at location, without encounter", check => {
             let destination = new StarLocation(new Star(null, 0, 0, "Atanax"));
             destination.encounter_random = new SkewedRandomGenerator([0], true);
 
@@ -8,23 +8,23 @@ module TK.SpaceTac.Specs {
             let fleet = new Fleet();
             let part = new MissionPartGoTo(new Mission(universe, fleet), destination);
 
-            expect(part.title).toEqual("Go to Atanax system");
-            expect(part.checkCompleted()).toBe(false, "Init location");
+            check.equals(part.title, "Go to Atanax system");
+            check.same(part.checkCompleted(), false, "Init location");
 
             fleet.setLocation(destination, true);
-            expect(part.checkCompleted()).toBe(false, "Encounter not clear");
+            check.same(part.checkCompleted(), false, "Encounter not clear");
 
             destination.clearEncounter();
-            expect(part.checkCompleted()).toBe(true, "Encouter cleared");
+            check.same(part.checkCompleted(), true, "Encouter cleared");
 
             fleet.setLocation(new StarLocation(), true);
-            expect(part.checkCompleted()).toBe(false, "Went to another system");
+            check.same(part.checkCompleted(), false, "Went to another system");
 
             fleet.setLocation(destination, true);
-            expect(part.checkCompleted()).toBe(true, "Back at destination");
+            check.same(part.checkCompleted(), true, "Back at destination");
         })
 
-        it("force completes", function () {
+        test.case("force completes", check => {
             let destination = new StarLocation(new Star(null, 0, 0, "Atanax"));
             destination.encounter_random = new SkewedRandomGenerator([0], true);
 
@@ -32,10 +32,10 @@ module TK.SpaceTac.Specs {
             let fleet = new Fleet();
             let part = new MissionPartGoTo(new Mission(universe, fleet), destination, "Investigate");
 
-            expect(part.title).toEqual("Investigate");
-            expect(part.checkCompleted()).toBe(false);
+            check.equals(part.title, "Investigate");
+            check.equals(part.checkCompleted(), false);
             part.forceComplete();
-            expect(part.checkCompleted()).toBe(true);
+            check.equals(part.checkCompleted(), true);
         });
     })
 }

src/multi/Connection.spec.ts

@@ -5,14 +5,14 @@ module TK.SpaceTac.Multi.Specs {
             let connection = new Connection("test", storage);
 
             let token = await connection.getUnusedToken(5);
-            expect(token.length).toBe(5);
+            check.equals(token.length, 5);
 
             await storage.upsert("sessioninfo", { token: token }, {});
 
             spyOn(connection, "generateToken").and.returnValues(token, "123456");
 
             let other = await connection.getUnusedToken(5);
-            expect(other).toEqual("123456");
+            check.equals(other, "123456");
         });
 
         test.acase("loads a session by its id", async check => {
@@ -22,24 +22,24 @@ module TK.SpaceTac.Multi.Specs {
             let connection = new Connection("test", storage);
 
             let result = await connection.loadById("abc");
-            expect(result).toBeNull();
+            check.equals(result, null);
 
             await storage.upsert("session", { ref: "abc" }, { data: serializer.serialize(session) });
 
             result = await connection.loadById("abc");
-            expect(result).toEqual(session);
+            check.equals(result, session);
             result = await connection.loadById("abcd");
-            expect(result).toBeNull();
+            check.equals(result, null);
 
             // even from another device
             let other = new Connection("notest", storage);
             result = await other.loadById("abc");
-            expect(result).toEqual(session);
+            check.equals(result, session);
 
             // do not load if it is not a GameSession
             await storage.upsert("session", { ref: "abcd" }, { data: serializer.serialize(new Player()) });
             result = await connection.loadById("abcd");
-            expect(result).toBeNull();
+            check.equals(result, null);
         });
 
         test.acase("lists saves from a device", async check => {
@@ -47,14 +47,14 @@ module TK.SpaceTac.Multi.Specs {
             let connection = new Connection("test", storage);
 
             let result = await connection.listSaves();
-            expect(result).toEqual({});
+            check.equals(result, {});
 
             await storage.upsert("sessioninfo", { device: "test", ref: "abc" }, { info: "ABC" });
             await storage.upsert("sessioninfo", { device: "other", ref: "abcd" }, { info: "ABCD" });
             await storage.upsert("sessioninfo", { device: "test", ref: "cba" }, { info: "CBA" });
 
             result = await connection.listSaves();
-            expect(result).toEqual({ abc: "ABC", cba: "CBA" });
+            check.equals(result, { abc: "ABC", cba: "CBA" });
         });
 
         test.acase("publishes saves and retrieves them by token", async check => {
@@ -63,24 +63,24 @@ module TK.SpaceTac.Multi.Specs {
             let connection = new Connection("test", storage);
 
             let saves = await connection.listSaves();
-            expect(items(saves).length).toEqual(0);
+            check.equals(items(saves).length, 0);
 
             let token = await connection.publish(session, "TEST");
 
             saves = await connection.listSaves();
-            expect(items(saves).length).toEqual(1);
+            check.equals(items(saves).length, 1);
 
             let loaded = await connection.loadByToken(token);
-            expect(loaded).toEqual(session);
+            check.equals(loaded, session);
 
             let newtoken = await connection.publish(nn(loaded), "TEST");
-            expect(token).toEqual(newtoken);
+            check.equals(token, newtoken);
 
             loaded = await connection.loadByToken(token);
-            expect(loaded).toEqual(session);
+            check.equals(loaded, session);
 
             saves = await connection.listSaves();
-            expect(items(saves).length).toEqual(1);
+            check.equals(items(saves).length, 1);
         });
     });
 }

src/multi/Exchange.spec.ts

@@ -17,35 +17,35 @@ module TK.SpaceTac.Multi.Specs {
             spyOn(console, "log").and.stub();
         });
 
-        test.acase("says hello on start", async function () {
+        test.acase("says hello on start", async check => {
             let [storage, peer1, peer2] = newExchange("abc");
             spyOn(peer1, "getNextId").and.returnValues("1A", "1B", "1C");
             spyOn(peer2, "getNextId").and.returnValues("2A", "2B", "2C");
 
-            expect(peer1.next).toEqual("hello");
-            expect(peer2.next).toEqual("hello");
-            expect(peer1.remotepeer).toBeNull();
-            expect(peer2.remotepeer).toBeNull();
-            expect(peer1.writing).toBe(true);
-            expect(peer2.writing).toBe(false);
-            expect(peer1.count).toBe(0);
-            expect(peer2.count).toBe(0);
+            check.equals(peer1.next, "hello");
+            check.equals(peer2.next, "hello");
+            check.equals(peer1.remotepeer, null);
+            check.equals(peer2.remotepeer, null);
+            check.equals(peer1.writing, true);
+            check.equals(peer2.writing, false);
+            check.equals(peer1.count, 0);
+            check.equals(peer2.count, 0);
 
             await Promise.all([peer1.start(), peer2.start()]);
 
-            expect(storage.collections["exchange"]).toEqual([
+            check.equals(storage.collections["exchange"], [
                 { peer: "peer1", current: "hello", next: "1A", count: 0, token: "abc", over: true, data: null },
                 { peer: "peer2", current: "1A", next: "2A", count: 1, token: "abc", over: true, data: null },
             ]);
 
-            expect(peer1.next).toEqual("2A");
-            expect(peer2.next).toEqual("2A");
-            expect(peer1.remotepeer).toBe("peer2");
-            expect(peer2.remotepeer).toBe("peer1");
-            expect(peer1.writing).toBe(true);
-            expect(peer2.writing).toBe(false);
-            expect(peer1.count).toBe(2);
-            expect(peer2.count).toBe(2);
+            check.equals(peer1.next, "2A");
+            check.equals(peer2.next, "2A");
+            check.equals(peer1.remotepeer, "peer2");
+            check.equals(peer2.remotepeer, "peer1");
+            check.equals(peer1.writing, true);
+            check.equals(peer2.writing, false);
+            check.equals(peer1.count, 2);
+            check.equals(peer2.count, 2);
 
             // same peers, new message chain
             [storage, peer1, peer2] = newExchange("abc", storage);
@@ -54,7 +54,7 @@ module TK.SpaceTac.Multi.Specs {
 
             await Promise.all([peer1.start(), peer2.start()]);
 
-            expect(storage.collections["exchange"]).toEqual([
+            check.equals(storage.collections["exchange"], [
                 { peer: "peer1", current: "hello", next: "1R", count: 0, token: "abc", over: true, data: null },
                 { peer: "peer2", current: "1A", next: "2A", count: 1, token: "abc", over: true, data: null },
                 { peer: "peer2", current: "1R", next: "2R", count: 1, token: "abc", over: true, data: null },

src/multi/RemoteStorage.spec.ts

@@ -1,51 +1,51 @@
 module TK.SpaceTac.Multi.Specs {
     testing("FakeRemoteStorage", test => {
-        test.acase("can fetch a single record", async function () {
+        test.acase("can fetch a single record", async check => {
             let storage = new FakeRemoteStorage();
 
             let result = await storage.find("test", { key: 5 });
-            expect(result).toBeNull();
+            check.equals(result, null);
 
             await storage.upsert("test", { key: 5 }, { text: "thingy" });
 
             result = await storage.find("test", { key: 5 });
-            expect(result).toEqual({ key: 5, text: "thingy" });
+            check.equals(result, { key: 5, text: "thingy" });
 
             result = await storage.find("test", { key: 6 });
-            expect(result).toBeNull();
+            check.equals(result, null);
 
             result = await storage.find("test", { key: 5, text: "thingy" });
-            expect(result).toEqual({ key: 5, text: "thingy" });
+            check.equals(result, { key: 5, text: "thingy" });
 
             result = await storage.find("notest", { key: 5 });
-            expect(result).toBeNull();
+            check.equals(result, null);
         });
 
-        test.acase("inserts or updates objects", async function () {
+        test.acase("inserts or updates objects", async check => {
             let storage = new FakeRemoteStorage();
 
             let result = await storage.search("test", { key: 5 });
-            expect(result).toEqual([]);
+            check.equals(result, []);
 
             await storage.upsert("test", { key: 5 }, {});
 
             result = await storage.search("test", { key: 5 });
-            expect(result).toEqual([{ key: 5 }]);
+            check.equals(result, [{ key: 5 }]);
 
             await storage.upsert("test", { key: 5 }, { text: "thingy" });
 
             result = await storage.search("test", { key: 5 });
-            expect(result).toEqual([{ key: 5, text: "thingy" }]);
+            check.equals(result, [{ key: 5, text: "thingy" }]);
 
             await storage.upsert("test", { key: 5 }, { text: "other thingy" });
 
             result = await storage.search("test", { key: 5 });
-            expect(result).toEqual([{ key: 5, text: "other thingy" }]);
+            check.equals(result, [{ key: 5, text: "other thingy" }]);
 
             await storage.upsert("test", { key: 5, text: "things" }, {});
 
             result = await storage.search("test", { key: 5 });
-            expect(sortedBy(result, (x: any) => x.text)).toEqual([{ key: 5, text: "other thingy" }, { key: 5, text: "things" }]);
+            check.equals(sortedBy(result, (x: any) => x.text), [{ key: 5, text: "other thingy" }, { key: 5, text: "things" }]);
         });
     });
 }

src/ui/AssetLoading.spec.ts

@@ -1,18 +1,18 @@
 /// <reference path="TestGame.ts" />
 
 module TK.SpaceTac.UI.Specs {
-    describe("AssetLoading", () => {
+    testing("AssetLoading", test => {
         let testgame = setupSingleView(() => [new AssetLoading(), []]);
 
-        it("loads correctly", function () {
-            expect(testgame.ui.state.current).toEqual("test");
+        test.case("loads correctly", check => {
+            check.equals(testgame.ui.state.current, "test");
             // TODO test asset loading
         });
 
-        it("builds cache keys from path", function () {
-            expect(AssetLoading.getKey("dir/file-path")).toEqual("dir-file-path");
-            expect(AssetLoading.getKey("dir/file-path.ext")).toEqual("dir-file-path");
-            expect(AssetLoading.getKey("dir/file-path.mp3")).toEqual("dir-file-path");
+        test.case("builds cache keys from path", check => {
+            check.equals(AssetLoading.getKey("dir/file-path"), "dir-file-path");
+            check.equals(AssetLoading.getKey("dir/file-path.ext"), "dir-file-path");
+            check.equals(AssetLoading.getKey("dir/file-path.mp3"), "dir-file-path");
         });
     });
 }

src/ui/BaseView.spec.ts

@@ -1,19 +1,19 @@
 /// <reference path="TestGame.ts" />
 
 module TK.SpaceTac.UI.Specs {
-    describe("BaseView", function () {
+    testing("BaseView", test => {
         let testgame = setupEmptyView();
 
-        it("initializes variables", function () {
+        test.case("initializes variables", check => {
             let view = <BaseView>testgame.ui.state.getCurrentState();
 
-            expect(view.messages instanceof Messages).toBe(true);
-            expect(view.inputs instanceof InputManager).toBe(true);
+            check.equals(view.messages instanceof Messages, true);
+            check.equals(view.inputs instanceof InputManager, true);
 
-            expect(view.getWidth()).toEqual(1920);
-            expect(view.getHeight()).toEqual(1080);
-            expect(view.getMidWidth()).toEqual(960);
-            expect(view.getMidHeight()).toEqual(540);
+            check.equals(view.getWidth(), 1920);
+            check.equals(view.getHeight(), 1080);
+            check.equals(view.getMidWidth(), 960);
+            check.equals(view.getMidHeight(), 540);
         });
     });
 }

src/ui/Boot.spec.ts

@@ -2,12 +2,12 @@
 /// <reference path="Boot.ts" />
 
 module TK.SpaceTac.UI.Specs {
-    describe("Boot", () => {
+    testing("Boot", test => {
         let testgame = setupSingleView(() => [new Boot(), []]);
 
-        it("places empty loading background", function () {
-            expect(testgame.ui.world.children.length).toBe(1);
-            expect(testgame.ui.world.children[0] instanceof Phaser.Image).toBe(true);
+        test.case("places empty loading background", check => {
+            check.equals(testgame.ui.world.children.length, 1);
+            check.equals(testgame.ui.world.children[0] instanceof Phaser.Image, true);
         });
     });
 }

src/ui/Router.spec.ts

@@ -2,11 +2,11 @@
 /// <reference path="Router.ts" />
 
 module TK.SpaceTac.UI.Specs {
-    describe("Router", () => {
+    testing("Router", test => {
         let testgame = setupSingleView(() => [new Router(), []]);
 
-        it("loads correctly", function () {
-            expect(testgame.ui.state.current).toEqual("test");
+        test.case("loads correctly", check => {
+            check.equals(testgame.ui.state.current, "test");
             // TODO test routing
         });
     });

src/ui/TestGame.ts

@@ -1,3 +1,5 @@
+/// <reference path="../common/Testing.ts" />
+
 module TK.SpaceTac.UI.Specs {
     let test_ui: MainUI;
 
@@ -11,6 +13,7 @@ module TK.SpaceTac.UI.Specs {
         view: T;
         multistorage: Multi.FakeRemoteStorage;
         state: string;
+        clock: FakeClock;
     }
 
     /**
@@ -23,8 +26,6 @@ module TK.SpaceTac.UI.Specs {
             spyOn(console, "log").and.stub();
             spyOn(console, "warn").and.stub();
 
-            jasmine.clock().install();
-
             if (!test_ui) {
                 test_ui = new MainUI(true);
 
@@ -67,10 +68,6 @@ module TK.SpaceTac.UI.Specs {
             testgame.view = state;
         });
 
-        afterEach(function () {
-            jasmine.clock().uninstall();
-        });
-
         return testgame;
     }
 
@@ -114,23 +111,23 @@ module TK.SpaceTac.UI.Specs {
     /**
      * Check a given text node
      */
-    export function checkText(node: any, content: string): void {
-        expect(node instanceof Phaser.Text).toBe(true);
+    export function checkText(check: TestContext, node: any, content: string): void {
+        check.equals(node instanceof Phaser.Text, true);
 
         let tnode = <Phaser.Text>node;
-        expect(tnode.text).toEqual(content);
+        check.equals(tnode.text, content);
     }
 
     /**
      * Check that a layer contains the given component at a given index
      */
-    export function checkComponentInLayer(layer: Phaser.Group, index: number, component: UIComponent) {
+    export function checkComponentInLayer(check: TestContext, layer: Phaser.Group, index: number, component: UIComponent) {
         if (index >= layer.children.length) {
-            fail(`Not enough children in group ${layer.name} for ${component} at index ${index}`);
+            check.fail(`Not enough children in group ${layer.name} for ${component} at index ${index}`);
         } else {
             let child = layer.children[index];
             if (child !== (<any>component).container) {
-                fail(`${component} is not at index ${index} in ${layer.name}`);
+                check.fail(`${component} is not at index ${index} in ${layer.name}`);
             }
         }
     }

src/ui/battle/ActionBar.spec.ts

@@ -1,49 +1,49 @@
 /// <reference path="../TestGame.ts"/>
 
 module TK.SpaceTac.UI.Specs {
-    describe("ActionBar", function () {
+    testing("ActionBar", test => {
         let testgame = setupBattleview();
 
-        it("lists available actions for selected ship", function () {
+        test.case("lists available actions for selected ship", check => {
             var bar = testgame.view.action_bar;
 
             // Ship not owned by current battleview player
             var ship = new Ship();
             bar.setShip(ship);
-            expect(bar.action_icons.length).toBe(0);
+            check.equals(bar.action_icons.length, 0);
 
             // Ship with no equipment (only endturn action)
             testgame.view.player = ship.getPlayer();
             bar.setShip(ship);
-            expect(bar.action_icons.length).toBe(1);
-            expect(bar.action_icons[0].action.code).toEqual("endturn");
+            check.equals(bar.action_icons.length, 1);
+            check.equals(bar.action_icons[0].action.code, "endturn");
 
             // Add an engine, with move action
             TestTools.addEngine(ship, 50);
             bar.setShip(ship);
-            expect(bar.action_icons.length).toBe(2);
-            expect(bar.action_icons[0].action.code).toEqual("move");
+            check.equals(bar.action_icons.length, 2);
+            check.equals(bar.action_icons[0].action.code, "move");
 
             // Add a weapon, with fire action
             TestTools.addWeapon(ship, 10, 1, 100);
             bar.setShip(ship);
-            expect(bar.action_icons.length).toBe(3);
-            expect(bar.action_icons[1].action.code).toEqual("fire-equipment");
+            check.equals(bar.action_icons.length, 3);
+            check.equals(bar.action_icons[1].action.code, "fire-equipment");
         });
 
-        it("updates power points display", function () {
+        test.case("updates power points display", check => {
             let bar = testgame.view.action_bar;
 
-            function check(available = 0, using = 0, used = 0) {
-                expect(bar.power_icons.children.length).toBe(available + using + used);
+            function checkpoints(available = 0, using = 0, used = 0) {
+                check.same(bar.power_icons.children.length, available + using + used);
                 bar.power_icons.children.forEach((child, idx) => {
                     let img = <Phaser.Image>child;
                     if (idx < available) {
-                        expect(img.name).toEqual("battle-actionbar-power-available");
+                        check.equals(img.name, "battle-actionbar-power-available");
                     } else if (idx < available + using) {
-                        expect(img.name).toEqual("battle-actionbar-power-move");
+                        check.equals(img.name, "battle-actionbar-power-move");
                     } else {
-                        expect(img.name).toEqual("battle-actionbar-power-used");
+                        check.equals(img.name, "battle-actionbar-power-used");
                     }
                 });
             }
@@ -52,26 +52,26 @@ module TK.SpaceTac.UI.Specs {
             let ship = new Ship();
             TestTools.setShipAP(ship, 8);
             bar.setShip(ship);
-            check();
+            checkpoints();
 
             // owned ship
             ship.fleet = testgame.view.player.fleet;
             bar.setShip(ship);
-            check(8);
+            checkpoints(8);
 
             // used points
             ship.setValue("power", 6);
             testgame.view.log_processor.jumpToEnd();
-            check(6, 0, 2);
+            checkpoints(6, 0, 2);
 
             // using points
             bar.updatePower(5);
-            check(1, 5, 2);
+            checkpoints(1, 5, 2);
 
             // decrease
             ship.setAttribute("power_capacity", 3);
             testgame.view.log_processor.jumpToEnd();
-            check(3);
+            checkpoints(3);
         });
     });
 }

src/ui/battle/ActionIcon.spec.ts

@@ -1,64 +1,64 @@
 /// <reference path="../TestGame.ts"/>
 
 module TK.SpaceTac.UI.Specs {
-    describe("ActionIcon", function () {
+    testing("ActionIcon", test => {
         let testgame = setupBattleview();
 
-        it("displays power usage", function () {
+        test.case("displays power usage", check => {
             let bar = testgame.view.action_bar;
             let ship = new Ship();
             let action = new BaseAction("something", "Do something");
             let icon = new ActionIcon(bar, ship, action, 0);
-            expect(icon.img_power.visible).toBe(false, "initial state");
+            check.same(icon.img_power.visible, false, "initial state");
 
             icon.refresh();
-            expect(icon.img_power.visible).toBe(false, "no change");
+            check.same(icon.img_power.visible, false, "no change");
 
             spyOn(action, "getActionPointsUsage").and.returnValue(3);
             icon.refresh();
-            expect(icon.img_power.visible).toBe(true);
-            expect(icon.text_power.text).toBe("3");
+            check.equals(icon.img_power.visible, true);
+            check.equals(icon.text_power.text, "3");
         })
 
-        it("displays disabled and fading states", function () {
+        test.case("displays disabled and fading states", check => {
             let bar = testgame.view.action_bar;
             let ship = new Ship();
             TestTools.setShipAP(ship, 5);
             let action = nn(TestTools.addWeapon(ship, 50, 3).action);
             let icon = new ActionIcon(bar, ship, action, 0);
 
-            expect(icon.container.name).toBe("battle-actionbar-frame-enabled", "5/5");
-            expect(icon.img_power.name).toBe("battle-actionbar-consumption-enabled", "5/5");
-            expect(icon.img_power.visible).toBe(true, "5/5");
-            expect(icon.img_bottom.name).toBe("battle-actionbar-bottom-enabled", "5/5");
+            check.equals(icon.container.name, "battle-actionbar-frame-enabled", "5/5");
+            check.equals(icon.img_power.name, "battle-actionbar-consumption-enabled", "5/5");
+            check.same(icon.img_power.visible, true, "5/5");
+            check.equals(icon.img_bottom.name, "battle-actionbar-bottom-enabled", "5/5");
 
             icon.refresh(null, 1);
-            expect(icon.container.name).toBe("battle-actionbar-frame-enabled", "4/5");
-            expect(icon.img_power.name).toBe("battle-actionbar-consumption-enabled", "4/5");
-            expect(icon.img_power.visible).toBe(true, "4/5");
-            expect(icon.img_bottom.name).toBe("battle-actionbar-bottom-enabled", "4/5");
+            check.equals(icon.container.name, "battle-actionbar-frame-enabled", "4/5");
+            check.equals(icon.img_power.name, "battle-actionbar-consumption-enabled", "4/5");
+            check.same(icon.img_power.visible, true, "4/5");
+            check.equals(icon.img_bottom.name, "battle-actionbar-bottom-enabled", "4/5");
 
             icon.refresh(null, 4);
-            expect(icon.container.name).toBe("battle-actionbar-frame-fading", "1/5");
-            expect(icon.img_power.name).toBe("battle-actionbar-consumption-enabled", "1/5");
-            expect(icon.img_power.visible).toBe(true, "1/5");
-            expect(icon.img_bottom.name).toBe("battle-actionbar-bottom-enabled", "1/5");
+            check.equals(icon.container.name, "battle-actionbar-frame-fading", "1/5");
+            check.equals(icon.img_power.name, "battle-actionbar-consumption-enabled", "1/5");
+            check.same(icon.img_power.visible, true, "1/5");
+            check.equals(icon.img_bottom.name, "battle-actionbar-bottom-enabled", "1/5");
 
             ship.setValue("power", 2);
             icon.refresh();
-            expect(icon.container.name).toBe("battle-actionbar-frame-disabled", "2/2");
-            expect(icon.img_power.name).toBe("battle-actionbar-consumption-disabled", "2/2");
-            expect(icon.img_power.visible).toBe(true, "2/2");
-            expect(icon.img_bottom.name).toBe("battle-actionbar-bottom-disabled", "2/2");
+            check.equals(icon.container.name, "battle-actionbar-frame-disabled", "2/2");
+            check.equals(icon.img_power.name, "battle-actionbar-consumption-disabled", "2/2");
+            check.same(icon.img_power.visible, true, "2/2");
+            check.equals(icon.img_bottom.name, "battle-actionbar-bottom-disabled", "2/2");
 
             icon.refresh(null, 6);
-            expect(icon.container.name).toBe("battle-actionbar-frame-disabled", "0/2");
-            expect(icon.img_power.name).toBe("battle-actionbar-consumption-disabled", "0/2");
-            expect(icon.img_power.visible).toBe(true, "0/2");
-            expect(icon.img_bottom.name).toBe("battle-actionbar-bottom-disabled", "0/2");
+            check.equals(icon.container.name, "battle-actionbar-frame-disabled", "0/2");
+            check.equals(icon.img_power.name, "battle-actionbar-consumption-disabled", "0/2");
+            check.same(icon.img_power.visible, true, "0/2");
+            check.equals(icon.img_bottom.name, "battle-actionbar-bottom-disabled", "0/2");
         })
 
-        it("displays toggle state", function () {
+        test.case("displays toggle state", check => {
             let bar = testgame.view.action_bar;
             let ship = new Ship();
             TestTools.setShipAP(ship, 5);
@@ -68,50 +68,50 @@ module TK.SpaceTac.UI.Specs {
             equipment.action = action;
             let icon = new ActionIcon(bar, ship, action, 0);
 
-            expect(icon.img_bottom.name).toBe("battle-actionbar-bottom-enabled", "initial");
-            expect(icon.img_power.name).toBe("battle-actionbar-consumption-enabled", "initial");
-            expect(icon.img_sticky.name).toBe("battle-actionbar-sticky-untoggled", "initial");
-            expect(icon.img_sticky.visible).toBe(true, "initial");
+            check.equals(icon.img_bottom.name, "battle-actionbar-bottom-enabled", "initial");
+            check.equals(icon.img_power.name, "battle-actionbar-consumption-enabled", "initial");
+            check.equals(icon.img_sticky.name, "battle-actionbar-sticky-untoggled", "initial");
+            check.same(icon.img_sticky.visible, true, "initial");
 
             action.activated = true;
             icon.refresh();
-            expect(icon.img_bottom.name).toBe("battle-actionbar-bottom-toggled", "initial");
-            expect(icon.img_power.name).toBe("battle-actionbar-consumption-toggled", "initial");
-            expect(icon.img_sticky.name).toBe("battle-actionbar-sticky-toggled", "initial");
-            expect(icon.img_sticky.visible).toBe(true, "initial");
+            check.equals(icon.img_bottom.name, "battle-actionbar-bottom-toggled", "initial");
+            check.equals(icon.img_power.name, "battle-actionbar-consumption-toggled", "initial");
+            check.equals(icon.img_sticky.name, "battle-actionbar-sticky-toggled", "initial");
+            check.same(icon.img_sticky.visible, true, "initial");
         })
 
-        it("displays overheat/cooldown", function () {
+        test.case("displays overheat/cooldown", check => {
             let bar = testgame.view.action_bar;
             let ship = new Ship();
             TestTools.setShipAP(ship, 5);
             let action = nn(TestTools.addWeapon(ship, 50, 3).action);
             action.cooldown.configure(1, 3);
             let icon = new ActionIcon(bar, ship, action, 0);
-            expect(icon.img_sticky.visible).toBe(false, "initial");
-            expect(icon.img_sticky.name).toBe("battle-actionbar-sticky-untoggled", "initial");
-            expect(icon.img_sticky.children.length).toBe(0, "initial");
+            check.same(icon.img_sticky.visible, false, "initial");
+            check.equals(icon.img_sticky.name, "battle-actionbar-sticky-untoggled", "initial");
+            check.same(icon.img_sticky.children.length, 0, "initial");
 
             icon.refresh(action);
-            expect(icon.img_sticky.visible).toBe(true, "overheat");
-            expect(icon.img_sticky.name).toBe("battle-actionbar-sticky-overheat", "overheat");
-            expect(icon.img_sticky.children.length).toBe(3, "overheat");
+            check.same(icon.img_sticky.visible, true, "overheat");
+            check.equals(icon.img_sticky.name, "battle-actionbar-sticky-overheat", "overheat");
+            check.same(icon.img_sticky.children.length, 3, "overheat");
 
             action.cooldown.configure(1, 12);
             icon.refresh(action);
-            expect(icon.img_sticky.visible).toBe(true, "superheat");
-            expect(icon.img_sticky.name).toBe("battle-actionbar-sticky-overheat", "superheat");
-            expect(icon.img_sticky.children.length).toBe(5, "superheat");
+            check.same(icon.img_sticky.visible, true, "superheat");
+            check.equals(icon.img_sticky.name, "battle-actionbar-sticky-overheat", "superheat");
+            check.same(icon.img_sticky.children.length, 5, "superheat");
 
             action.cooldown.configure(1, 4);
             action.cooldown.use();
             icon.refresh(action);
-            expect(icon.img_sticky.visible).toBe(true, "cooling");
-            expect(icon.img_sticky.name).toBe("battle-actionbar-sticky-disabled", "cooling");
-            expect(icon.img_sticky.children.length).toBe(4, "cooling");
+            check.same(icon.img_sticky.visible, true, "cooling");
+            check.equals(icon.img_sticky.name, "battle-actionbar-sticky-disabled", "cooling");
+            check.same(icon.img_sticky.children.length, 4, "cooling");
         })
 
-        it("displays currently targetting", function () {
+        test.case("displays currently targetting", check => {
             testgame.view.animations.setImmediate();
 
             let bar = testgame.view.action_bar;
@@ -119,13 +119,13 @@ module TK.SpaceTac.UI.Specs {
             TestTools.setShipAP(ship, 5);
             let action = nn(TestTools.addWeapon(ship, 50, 3).action);
             let icon = new ActionIcon(bar, ship, action, 0);
-            expect(icon.img_targetting.visible).toBe(false, "initial");
+            check.same(icon.img_targetting.visible, false, "initial");
 
             icon.refresh(action);
-            expect(icon.img_targetting.visible).toBe(true, "selected");
+            check.same(icon.img_targetting.visible, true, "selected");
 
             icon.refresh(new BaseAction("other", "Other action"));
-            expect(icon.img_targetting.visible).toBe(false, "other");
+            check.same(icon.img_targetting.visible, false, "other");
         })
     });
 }

src/ui/battle/ActionTooltip.spec.ts

@@ -1,10 +1,10 @@
 /// <reference path="../TestGame.ts"/>
 
 module TK.SpaceTac.UI.Specs {
-    describe("ActionTooltip", function () {
+    testing("ActionTooltip", test => {
         let testgame = setupEmptyView();
 
-        it("displays action information", () => {
+        test.case("displays action information", check => {
             let tooltip = new Tooltip(testgame.view);
             let ship = new Ship();
             TestTools.setShipAP(ship, 10);
@@ -19,23 +19,23 @@ module TK.SpaceTac.UI.Specs {
             action3.name = "End turn";
 
             ActionTooltip.fill(tooltip.getFiller(), ship, action1, 0);
-            checkText((<any>tooltip).container.content.children[1], "Engine");
-            checkText((<any>tooltip).container.content.children[2], "Cost: 1 power per 0km");
-            checkText((<any>tooltip).container.content.children[3], "Move: 0km per power point (safety: 120km)");
-            checkText((<any>tooltip).container.content.children[4], "[ 1 ]");
+            checkText(check, (<any>tooltip).container.content.children[1], "Engine");
+            checkText(check, (<any>tooltip).container.content.children[2], "Cost: 1 power per 0km");
+            checkText(check, (<any>tooltip).container.content.children[3], "Move: 0km per power point (safety: 120km)");
+            checkText(check, (<any>tooltip).container.content.children[4], "[ 1 ]");
 
             tooltip.hide();
             ActionTooltip.fill(tooltip.getFiller(), ship, action2, 1);
-            checkText((<any>tooltip).container.content.children[1], "Weapon");
-            checkText((<any>tooltip).container.content.children[2], "Cost: 2 power");
-            checkText((<any>tooltip).container.content.children[3], "Fire (power usage 2, max range 50km):\n• do 12 damage on target");
-            checkText((<any>tooltip).container.content.children[4], "[ 2 ]");
+            checkText(check, (<any>tooltip).container.content.children[1], "Weapon");
+            checkText(check, (<any>tooltip).container.content.children[2], "Cost: 2 power");
+            checkText(check, (<any>tooltip).container.content.children[3], "Fire (power usage 2, max range 50km):\n• do 12 damage on target");
+            checkText(check, (<any>tooltip).container.content.children[4], "[ 2 ]");
 
             tooltip.hide();
             ActionTooltip.fill(tooltip.getFiller(), ship, action3, 2);
-            checkText((<any>tooltip).container.content.children[1], "End turn");
-            checkText((<any>tooltip).container.content.children[2], "End the current ship's turn.\nWill also generate power and cool down equipments.");
-            checkText((<any>tooltip).container.content.children[3], "[ space ]");
+            checkText(check, (<any>tooltip).container.content.children[1], "End turn");
+            checkText(check, (<any>tooltip).container.content.children[2], "End the current ship's turn.\nWill also generate power and cool down equipments.");
+            checkText(check, (<any>tooltip).container.content.children[3], "[ space ]");
         });
     });
 }

src/ui/battle/ArenaShip.spec.ts

@@ -1,45 +1,45 @@
 /// <reference path="../TestGame.ts"/>
 
 module TK.SpaceTac.UI.Specs {
-    describe("ArenaShip", function () {
+    testing("ArenaShip", test => {
         let testgame = setupBattleview();
 
-        it("adds effects display", function () {
+        test.case("adds effects display", check => {
             let ship = nn(testgame.view.battle.playing_ship);
             let sprite = nn(testgame.view.arena.findShipSprite(ship));
 
-            expect(sprite.effects_messages.children.length).toBe(0);
+            check.equals(sprite.effects_messages.children.length, 0);
 
             sprite.displayValueChanged(new ValueChangeEvent(ship, ship.attributes.power_generation, -4));
 
-            expect(sprite.effects_messages.children.length).toBe(1);
+            check.equals(sprite.effects_messages.children.length, 1);
             let t1 = <Phaser.Text>sprite.effects_messages.getChildAt(0);
-            expect(t1.text).toBe("power generation -4");
+            check.equals(t1.text, "power generation -4");
 
             sprite.displayValueChanged(new ValueChangeEvent(ship, ship.values.shield, 12));
 
-            expect(sprite.effects_messages.children.length).toBe(2);
+            check.equals(sprite.effects_messages.children.length, 2);
             let t2 = <Phaser.Text>sprite.effects_messages.getChildAt(1);
-            expect(t2.text).toBe("shield +12");
+            check.equals(t2.text, "shield +12");
         });
 
-        it("adds sticky effects display", function () {
+        test.case("adds sticky effects display", check => {
             let ship = nn(testgame.view.battle.playing_ship);
             let sprite = nn(testgame.view.arena.findShipSprite(ship));
 
-            expect(sprite.active_effects_display.children.length).toBe(0);
+            check.equals(sprite.active_effects_display.children.length, 0);
 
             ship.addStickyEffect(new StickyEffect(new BaseEffect("test")));
             testgame.view.log_processor.jumpToEnd();
-            expect(sprite.active_effects_display.children.length).toBe(1);
+            check.equals(sprite.active_effects_display.children.length, 1);
 
             ship.addStickyEffect(new StickyEffect(new BaseEffect("test")));
             testgame.view.log_processor.jumpToEnd();
-            expect(sprite.active_effects_display.children.length).toBe(2);
+            check.equals(sprite.active_effects_display.children.length, 2);
 
             ship.cleanStickyEffects();
             testgame.view.log_processor.jumpToEnd();
-            expect(sprite.active_effects_display.children.length).toBe(0);
+            check.equals(sprite.active_effects_display.children.length, 0);
         });
     });
 }

src/ui/battle/BattleView.spec.ts

@@ -1,51 +1,51 @@
 /// <reference path="../TestGame.ts"/>
 
 module TK.SpaceTac.UI.Specs {
-    describe("BattleView", function () {
+    testing("BattleView", test => {
         let testgame = setupBattleview();
 
-        it("handles ship hovering to display tooltip", function () {
+        test.case("handles ship hovering to display tooltip", check => {
             let battleview = testgame.view;
             expect(battleview.ship_hovered).toBeNull("initial state");
 
             let ship = nn(battleview.battle.playing_ship);
             battleview.cursorHovered(ship.location, ship);
-            expect(battleview.ship_hovered).toBe(ship, "ship1 hovered");
+            check.same(battleview.ship_hovered, ship, "ship1 hovered");
 
             ship = nn(battleview.battle.play_order[1]);
             battleview.cursorHovered(ship.location, ship);
-            expect(battleview.ship_hovered).toBe(ship, "ship2 hovered");
+            check.same(battleview.ship_hovered, ship, "ship2 hovered");
 
             battleview.cursorHovered(new ArenaLocation(0, 0), null);
             expect(battleview.ship_hovered).toBeNull("out");
 
             battleview.cursorOnShip(ship);
-            expect(battleview.ship_hovered).toBe(ship, "force on");
+            check.same(battleview.ship_hovered, ship, "force on");
 
             battleview.cursorOffShip(battleview.battle.play_order[2]);
-            expect(battleview.ship_hovered).toBe(ship, "force off on wrong ship");
+            check.same(battleview.ship_hovered, ship, "force off on wrong ship");
 
             battleview.cursorOffShip(ship);
             expect(battleview.ship_hovered).toBeNull("force off");
         });
 
-        it("forwards cursor hovering and click to targetting", function () {
+        test.case("forwards cursor hovering and click to targetting", check => {
             let battleview = testgame.view;
-            expect(battleview.targetting.active).toBe(false);
+            check.equals(battleview.targetting.active, false);
             battleview.setInteractionEnabled(true);
 
             let weapon = TestTools.addWeapon(nn(battleview.battle.playing_ship), 10);
             battleview.enterTargettingMode(nn(weapon.action), ActionTargettingMode.SPACE);
-            expect(battleview.targetting.active).toBe(true);
+            check.equals(battleview.targetting.active, true);
 
             battleview.cursorHovered(new ArenaLocation(5, 8), null);
-            expect(battleview.targetting.target).toEqual(Target.newFromLocation(5, 8));
-            expect(battleview.ship_hovered).toBeNull();
+            check.equals(battleview.targetting.target, Target.newFromLocation(5, 8));
+            check.equals(battleview.ship_hovered, null);
 
             let ship = battleview.battle.play_order[3];
             battleview.cursorHovered(ship.location, ship);
-            expect(battleview.targetting.target).toEqual(Target.newFromLocation(ship.arena_x, ship.arena_y));
-            expect(battleview.ship_hovered).toBeNull();
+            check.equals(battleview.targetting.target, Target.newFromLocation(ship.arena_x, ship.arena_y));
+            check.equals(battleview.ship_hovered, null);
 
             spyOn(battleview.targetting, "validate").and.stub();
 
@@ -54,37 +54,37 @@ module TK.SpaceTac.UI.Specs {
             expect(battleview.targetting.validate).toHaveBeenCalledTimes(1);
 
             battleview.exitTargettingMode();
-            expect(battleview.targetting.active).toBe(false);
+            check.equals(battleview.targetting.active, false);
 
             battleview.cursorHovered(new ArenaLocation(5, 8), null);
-            expect(battleview.targetting.target).toBeNull();
-            expect(battleview.ship_hovered).toBeNull();
+            check.equals(battleview.targetting.target, null);
+            check.equals(battleview.ship_hovered, null);
 
             battleview.cursorHovered(ship.location, ship);
-            expect(battleview.targetting.target).toBeNull();
-            expect(battleview.ship_hovered).toBe(ship);
+            check.equals(battleview.targetting.target, null);
+            check.same(battleview.ship_hovered, ship);
         });
 
-        it("allows to choose an action and a target with shortcut keys", function () {
+        test.case("allows to choose an action and a target with shortcut keys", check => {
             let battleview = testgame.view;
             battleview.setInteractionEnabled(true);
             let action_icon = battleview.action_bar.action_icons[0];
 
-            expect(battleview.targetting.active).toBe(false);
-            expect(battleview.action_bar.hasActionSelected()).toBe(false);
+            check.equals(battleview.targetting.active, false);
+            check.equals(battleview.action_bar.hasActionSelected(), false);
             battleview.numberPressed(battleview.action_bar.action_icons.indexOf(action_icon) + 1);
-            expect(battleview.action_bar.hasActionSelected()).toBe(true);
-            expect(battleview.targetting.active).toBe(true);
-            expect(battleview.targetting.action).toBe(action_icon.action);
-            expect(battleview.targetting.target).toEqual(action_icon.action.getDefaultTarget(action_icon.ship));
+            check.equals(battleview.action_bar.hasActionSelected(), true);
+            check.equals(battleview.targetting.active, true);
+            check.same(battleview.targetting.action, action_icon.action);
+            check.equals(battleview.targetting.target, action_icon.action.getDefaultTarget(action_icon.ship));
             battleview.numberPressed(3);
-            expect(battleview.targetting.active).toBe(true);
-            expect(battleview.targetting.action).toBe(action_icon.action);
-            expect(battleview.targetting.target).toEqual(Target.newFromShip(battleview.battle.play_order[3]));
+            check.equals(battleview.targetting.active, true);
+            check.same(battleview.targetting.action, action_icon.action);
+            check.equals(battleview.targetting.target, Target.newFromShip(battleview.battle.play_order[3]));
             battleview.numberPressed(4);
-            expect(battleview.targetting.active).toBe(true);
-            expect(battleview.targetting.action).toBe(action_icon.action);
-            expect(battleview.targetting.target).toEqual(Target.newFromShip(battleview.battle.play_order[4]));
+            check.equals(battleview.targetting.active, true);
+            check.same(battleview.targetting.action, action_icon.action);
+            check.equals(battleview.targetting.target, Target.newFromShip(battleview.battle.play_order[4]));
         });
     });
 }

src/ui/battle/LogProcessor.spec.ts

@@ -20,10 +20,10 @@ module TK.SpaceTac.UI.Specs {
         }
     }
 
-    describe("LogProcessor", function () {
+    testing("LogProcessor", test => {
         let testgame = setupBattleview();
 
-        it("steps forward and backward in time", function () {
+        test.case("steps forward and backward in time", check => {
             let battle = testgame.view.battle;
             battle.log.clear();
             let processor = new LogProcessor(testgame.view);
@@ -31,44 +31,44 @@ module TK.SpaceTac.UI.Specs {
                 event.apply(battle);
                 return 0;
             });
-            expect(battle.cycle).toBe(1);
-            expect(processor.atStart()).toBe(true);
-            expect(processor.atEnd()).toBe(true);
+            check.equals(battle.cycle, 1);
+            check.equals(processor.atStart(), true);
+            check.equals(processor.atEnd(), true);
 
             processor.stepForward();
-            expect(battle.cycle).toBe(1);
-            expect(processor.atStart()).toBe(true);
-            expect(processor.atEnd()).toBe(true);
+            check.equals(battle.cycle, 1);
+            check.equals(processor.atStart(), true);
+            check.equals(processor.atEnd(), true);
 
             battle.log.add(new FakeEvent());
-            expect(battle.cycle).toBe(1);
-            expect(processor.atStart()).toBe(true);
-            expect(processor.atEnd()).toBe(false);
+            check.equals(battle.cycle, 1);
+            check.equals(processor.atStart(), true);
+            check.equals(processor.atEnd(), false);
 
             processor.stepForward();
-            expect(battle.cycle).toBe(2);
-            expect(processor.atStart()).toBe(false);
-            expect(processor.atEnd()).toBe(true);
+            check.equals(battle.cycle, 2);
+            check.equals(processor.atStart(), false);
+            check.equals(processor.atEnd(), true);
 
             processor.stepForward();
-            expect(battle.cycle).toBe(2);
-            expect(processor.atStart()).toBe(false);
-            expect(processor.atEnd()).toBe(true);
+            check.equals(battle.cycle, 2);
+            check.equals(processor.atStart(), false);
+            check.equals(processor.atEnd(), true);
 
             processor.stepBackward();
-            expect(battle.cycle).toBe(1);
-            expect(processor.atStart()).toBe(true);
-            expect(processor.atEnd()).toBe(false);
+            check.equals(battle.cycle, 1);
+            check.equals(processor.atStart(), true);
+            check.equals(processor.atEnd(), false);
 
             processor.stepBackward();
-            expect(battle.cycle).toBe(1);
-            expect(processor.atStart()).toBe(true);
-            expect(processor.atEnd()).toBe(false);
+            check.equals(battle.cycle, 1);
+            check.equals(processor.atStart(), true);
+            check.equals(processor.atEnd(), false);
 
             processor.stepForward();
-            expect(battle.cycle).toBe(2);
-            expect(processor.atStart()).toBe(false);
-            expect(processor.atEnd()).toBe(true);
+            check.equals(battle.cycle, 2);
+            check.equals(processor.atStart(), false);
+            check.equals(processor.atEnd(), true);
         })
     })
 }

src/ui/battle/ShipTooltip.spec.ts

@@ -1,8 +1,8 @@
 module TK.SpaceTac.UI.Specs {
-    describe("ShipTooltip", function () {
+    testing("ShipTooltip", test => {
         let testgame = setupBattleview();
 
-        it("fills ship details", function () {
+        test.case("fills ship details", check => {
             let tooltip = new ShipTooltip(testgame.view);
             let ship = testgame.view.battle.play_order[2];
             ship.fleet.player.name = "Phil";
@@ -22,17 +22,17 @@ module TK.SpaceTac.UI.Specs {
             tooltip.setShip(ship);
 
             let content = (<any>tooltip).container.content;
-            expect(content.children[0].name).toBe("ship-fake-portrait");
-            expect(content.children[1].text).toBe("Phil's Level 1 Fury");
-            expect(content.children[2].text).toBe("Plays in 2 turns");
-            expect(content.children[3].text).toBe("Hull\n58/58");
-            expect(content.children[4].text).toBe("Shield\n140/140");
-            expect(content.children[5].text).toBe("Power\n12/12");
-            expect(content.children[6].text).toBe("Active effects");
-            expect(content.children[7].text).toBe("• limit precision to 10");
-            expect(content.children[8].text).toBe("• damage -15% for 3 turns");
-            expect(content.children[9].text).toBe("Weapons");
-            expect(content.children[10].text).toBe("• equipment Mk1");
+            check.equals(content.children[0].name, "ship-fake-portrait");
+            check.equals(content.children[1].text, "Phil's Level 1 Fury");
+            check.equals(content.children[2].text, "Plays in 2 turns");
+            check.equals(content.children[3].text, "Hull\n58/58");
+            check.equals(content.children[4].text, "Shield\n140/140");
+            check.equals(content.children[5].text, "Power\n12/12");
+            check.equals(content.children[6].text, "Active effects");
+            check.equals(content.children[7].text, "• limit precision to 10");
+            check.equals(content.children[8].text, "• damage -15% for 3 turns");
+            check.equals(content.children[9].text, "Weapons");
+            check.equals(content.children[10].text, "• equipment Mk1");
         });
     });
 }

src/ui/battle/Targetting.spec.ts

@@ -1,5 +1,5 @@
 module TK.SpaceTac.UI.Specs {
-    describe("Targetting", function () {
+    testing("Targetting", test => {
         let testgame = setupBattleview();
 
         function newTargetting(): Targetting {
@@ -9,7 +9,7 @@ module TK.SpaceTac.UI.Specs {
                 testgame.view.arena.range_hint);
         }
 
-        it("draws simulation parts", function () {
+        test.case("draws simulation parts", check => {
             let targetting = newTargetting();
 
             let ship = nn(testgame.view.battle.playing_ship);
@@ -41,7 +41,7 @@ module TK.SpaceTac.UI.Specs {
             expect(drawvector).toHaveBeenCalledWith(0xe09c47, 10, 20, 50, 30, 12);
         })
 
-        it("updates impact indicators on ships inside the blast radius", function () {
+        test.case("updates impact indicators on ships inside the blast radius", check => {
             let targetting = newTargetting();
             let ship = nn(testgame.view.battle.playing_ship);
             let impacts = targetting.impact_indicators;
@@ -55,24 +55,24 @@ module TK.SpaceTac.UI.Specs {
 
             expect(collect).toHaveBeenCalledTimes(1);
             expect(collect).toHaveBeenCalledWith(ship, new Target(20, 10), ship.location);
-            expect(targetting.impact_indicators.children.length).toBe(3);
-            expect(targetting.impact_indicators.visible).toBe(true);
+            check.equals(targetting.impact_indicators.children.length, 3);
+            check.equals(targetting.impact_indicators.visible, true);
 
             targetting.updateImpactIndicators(impacts, ship, action, new Target(20, 11));
 
             expect(collect).toHaveBeenCalledTimes(2);
             expect(collect).toHaveBeenCalledWith(ship, new Target(20, 11), ship.location);
-            expect(targetting.impact_indicators.children.length).toBe(2);
-            expect(targetting.impact_indicators.visible).toBe(true);
+            check.equals(targetting.impact_indicators.children.length, 2);
+            check.equals(targetting.impact_indicators.visible, true);
 
             targetting.updateImpactIndicators(impacts, ship, action, new Target(20, 12));
 
             expect(collect).toHaveBeenCalledTimes(3);
             expect(collect).toHaveBeenCalledWith(ship, new Target(20, 12), ship.location);
-            expect(targetting.impact_indicators.visible).toBe(false);
+            check.equals(targetting.impact_indicators.visible, false);
         })
 
-        it("updates graphics from simulation", function () {
+        test.case("updates graphics from simulation", check => {
             let targetting = newTargetting();
             let ship = nn(testgame.view.battle.playing_ship);
 
@@ -99,19 +99,19 @@ module TK.SpaceTac.UI.Specs {
             });
             targetting.update();
 
-            expect(targetting.container.visible).toBe(true);
-            expect(targetting.drawn_info.visible).toBe(true);
-            expect(targetting.fire_arrow.visible).toBe(true);
-            expect(targetting.fire_arrow.position).toEqual(jasmine.objectContaining({ x: 156, y: 65 }));
-            expect(targetting.fire_arrow.rotation).toBeCloseTo(0.534594, 5);
-            expect(targetting.impact_area.visible).toBe(true);
-            expect(targetting.impact_area.position).toEqual(jasmine.objectContaining({ x: 156, y: 65 }));
-            expect(targetting.move_ghost.visible).toBe(true);
-            expect(targetting.move_ghost.position).toEqual(jasmine.objectContaining({ x: 80, y: 20 }));
-            expect(targetting.move_ghost.rotation).toBeCloseTo(0.534594, 5);
+            check.equals(targetting.container.visible, true);
+            check.equals(targetting.drawn_info.visible, true);
+            check.equals(targetting.fire_arrow.visible, true);
+            check.containing(targetting.fire_arrow.position, { x: 156, y: 65 });
+            check.nears(targetting.fire_arrow.rotation, 0.534594, 5);
+            check.equals(targetting.impact_area.visible, true);
+            check.containing(targetting.impact_area.position, { x: 156, y: 65 });
+            check.equals(targetting.move_ghost.visible, true);
+            check.containing(targetting.move_ghost.position, { x: 80, y: 20 });
+            check.nears(targetting.move_ghost.rotation, 0.534594, 5);
         })
 
-        it("snaps on ships according to targetting mode", function () {
+        test.case("snaps on ships according to targetting mode", check => {
             let targetting = newTargetting();
             let playing_ship = nn(testgame.view.battle.playing_ship);
             let action = TestTools.addWeapon(playing_ship).action;
@@ -123,28 +123,28 @@ module TK.SpaceTac.UI.Specs {
 
             targetting.setAction(action, ActionTargettingMode.SPACE);
             targetting.setTargetFromLocation({ x: 8000, y: 60 });
-            expect(targetting.target).toEqual(Target.newFromLocation(8000, 60), "space");
+            check.equals(targetting.target, Target.newFromLocation(8000, 60), "space");
 
             targetting.setAction(action, ActionTargettingMode.SHIP);
             targetting.setTargetFromLocation({ x: 8000, y: 60 });
-            expect(targetting.target).toEqual(Target.newFromShip(ship1), "ship 1");
+            check.equals(targetting.target, Target.newFromShip(ship1), "ship 1");
             targetting.setTargetFromLocation({ x: 8100, y: 200 });
-            expect(targetting.target).toEqual(Target.newFromShip(ship2), "ship 2");
+            check.equals(targetting.target, Target.newFromShip(ship2), "ship 2");
 
             targetting.setAction(action, ActionTargettingMode.SURROUNDINGS);
             targetting.setTargetFromLocation({ x: 8000, y: 60 });
-            expect(targetting.target).toEqual(Target.newFromLocation(8000, 60), "surroundings 1");
+            check.equals(targetting.target, Target.newFromLocation(8000, 60), "surroundings 1");
             targetting.setTargetFromLocation({ x: playing_ship.arena_x + 10, y: playing_ship.arena_y - 20 });
-            expect(targetting.target).toEqual(Target.newFromShip(playing_ship), "surroundings 2");
+            check.equals(targetting.target, Target.newFromShip(playing_ship), "surroundings 2");
 
             targetting.setAction(action, ActionTargettingMode.SELF);
             targetting.setTargetFromLocation({ x: 8000, y: 60 });
-            expect(targetting.target).toEqual(Target.newFromShip(playing_ship), "self 1");
+            check.equals(targetting.target, Target.newFromShip(playing_ship), "self 1");
             targetting.setTargetFromLocation({ x: 0, y: 0 });
-            expect(targetting.target).toEqual(Target.newFromShip(playing_ship), "self 2");
+            check.equals(targetting.target, Target.newFromShip(playing_ship), "self 2");
         })
 
-        it("updates the range hint display", function () {
+        test.case("updates the range hint display", check => {
             let targetting = newTargetting();
             let ship = nn(testgame.view.battle.playing_ship);
             ship.setArenaPosition(0, 0);
@@ -159,17 +159,17 @@ module TK.SpaceTac.UI.Specs {
             // move action
             targetting.setAction(move);
             targetting.setTargetFromLocation({ x: 200, y: 0 });
-            expect(last_call).toEqual([ship, move, 800]);
+            check.equals(last_call, [ship, move, 800]);
 
             // fire action
             targetting.setAction(fire);
             targetting.setTargetFromLocation({ x: 200, y: 0 });
-            expect(last_call).toEqual([ship, fire, undefined]);
+            check.equals(last_call, [ship, fire, undefined]);
 
             // move+fire
             targetting.setAction(fire);
             targetting.setTargetFromLocation({ x: 400, y: 0 });
-            expect(last_call).toEqual([ship, move, 600]);
+            check.equals(last_call, [ship, move, 600]);
         });
     });
 }

src/ui/battle/WeaponEffect.spec.ts

@@ -1,18 +1,19 @@
 module TK.SpaceTac.UI.Specs {
-    describe("WeaponEffect", function () {
+    testing("WeaponEffect", test => {
         let testgame = setupBattleview();
+        let clock = test.clock();
 
         function checkEmitters(step: string, expected: number) {
-            expect(testgame.view.arena.layer_weapon_effects.children.length).toBe(expected, `${step} - layer children`);
-            expect(keys(testgame.view.game.particles.emitters).length).toBe(expected, `${step} - registered emitters`);
+            test.check.same(testgame.view.arena.layer_weapon_effects.children.length, expected, `${step} - layer children`);
+            test.check.same(keys(testgame.view.game.particles.emitters).length, expected, `${step} - registered emitters`);
         }
 
         function fastForward(milliseconds: number) {
-            jasmine.clock().tick(milliseconds);
+            clock.forward(milliseconds);
             testgame.ui.updateLogic(milliseconds);
         }
 
-        it("displays shield hit effect", function () {
+        test.case("displays shield hit effect", check => {
             let battleview = testgame.view;
             battleview.timer = new Timer();
 
@@ -20,16 +21,16 @@ module TK.SpaceTac.UI.Specs {
             effect.shieldImpactEffect({ x: 10, y: 10 }, { x: 20, y: 15 }, 1000, 3000, true);
 
             let layer = battleview.arena.layer_weapon_effects;
-            expect(layer.children.length).toBe(2);
+            check.equals(layer.children.length, 2);
 
-            expect(layer.children[0] instanceof Phaser.Image).toBe(true);
-            expect(layer.children[0].rotation).toBeCloseTo(-2.677945044588987, 10);
-            expect(layer.children[0].position).toEqual(jasmine.objectContaining({ x: 20, y: 15 }));
+            check.equals(layer.children[0] instanceof Phaser.Image, true);
+            check.nears(layer.children[0].rotation, -2.677945044588987, 10);
+            check.containing(layer.children[0].position, { x: 20, y: 15 });
 
-            expect(layer.children[1] instanceof Phaser.Particles.Arcade.Emitter).toBe(true);
+            check.equals(layer.children[1] instanceof Phaser.Particles.Arcade.Emitter, true);
         });
 
-        it("displays gatling gun effect", function () {
+        test.case("displays gatling gun effect", check => {
             let battleview = testgame.view;
             battleview.timer = new Timer();
 
@@ -38,11 +39,11 @@ module TK.SpaceTac.UI.Specs {
             effect.gunEffect();
 
             let layer = battleview.arena.layer_weapon_effects;
-            expect(layer.children.length).toBe(1);
-            expect(layer.children[0] instanceof Phaser.Particles.Arcade.Emitter).toBe(true);
+            check.equals(layer.children.length, 1);
+            check.equals(layer.children[0] instanceof Phaser.Particles.Arcade.Emitter, true);
         });
 
-        it("displays shield and hull effect on impacted ships", function () {
+        test.case("displays shield and hull effect on impacted ships", check => {
             let battleview = testgame.view;
             battleview.timer = new Timer();
 
@@ -75,7 +76,7 @@ module TK.SpaceTac.UI.Specs {
             expect(mock_hull_impact).toHaveBeenCalledTimes(1);
         });
 
-        it("removes particle emitters when done", function () {
+        test.case("removes particle emitters when done", check => {
             let battleview = testgame.view;
             battleview.timer = new Timer();
 
@@ -92,30 +93,30 @@ module TK.SpaceTac.UI.Specs {
             checkEmitters("hull effect ended", 0);
         });
 
-        it("adds a laser effect", function () {
+        test.case("adds a laser effect", check => {
             let battleview = testgame.view;
             battleview.timer = new Timer();
 
             let effect = new WeaponEffect(battleview.arena, new Ship(), Target.newFromLocation(31, 49), new Equipment());
 
             let result = effect.angularLaser({ x: 20, y: 30 }, 300, Math.PI / 4, -Math.PI / 2, 5);
-            expect(result).toBe(200);
+            check.equals(result, 200);
 
             let layer = battleview.arena.layer_weapon_effects;
-            expect(layer.children.length).toBe(1);
-            expect(layer.children[0] instanceof Phaser.Image).toBe(true, "is image");
+            check.equals(layer.children.length, 1);
+            check.same(layer.children[0] instanceof Phaser.Image, true, "is image");
             let image = <Phaser.Image>layer.children[0];
-            expect(image.name).toEqual("battle-effects-laser");
-            //expect(image.width).toBe(300);
-            expect(image.x).toEqual(20);
-            expect(image.y).toEqual(30);
-            expect(image.rotation).toBeCloseTo(Math.PI / 4, 0.000001);
+            check.equals(image.name, "battle-effects-laser");
+            //check.equals(image.width, 300);
+            check.equals(image.x, 20);
+            check.equals(image.y, 30);
+            check.nears(image.rotation, Math.PI / 4);
 
             let values = battleview.animations.simulate(image, "rotation", 4, result);
-            expect(values[0]).toBeCloseTo(Math.PI / 4, 0.000001);
-            expect(values[1]).toBeCloseTo(0, 0.000001);
-            expect(values[2]).toBeCloseTo(-Math.PI / 4, 0.000001);
-            expect(values[3]).toBeCloseTo(-Math.PI / 2, 0.000001);
+            check.nears(values[0], Math.PI / 4);
+            check.nears(values[1], 0);
+            check.nears(values[2], -Math.PI / 4);
+            check.nears(values[3], -Math.PI / 2);
         });
     });
 }

src/ui/character/CharacterCargo.spec.ts

@@ -1,8 +1,8 @@
 module TK.SpaceTac.UI.Specs {
-    describe("CharacterCargo", function () {
+    testing("CharacterCargo", test => {
         let testgame = setupEmptyView();
 
-        it("checks conditions for adding/removing equipment", function () {
+        test.case("checks conditions for adding/removing equipment", check => {
             let view = testgame.view;
             let sheet = new CharacterSheet(view);
             let ship = new Ship();
@@ -12,18 +12,18 @@ module TK.SpaceTac.UI.Specs {
             let equipment = new CharacterEquipment(sheet, new Equipment(), source);
 
             let destination = new CharacterCargo(sheet, 0, 0);
-            expect(destination.addEquipment(equipment, null, true)).toEqual({ success: false, info: 'put in cargo', error: 'not enough cargo space' });
+            check.equals(destination.addEquipment(equipment, null, true), { success: false, info: 'put in cargo', error: 'not enough cargo space' });
             ship.setCargoSpace(1);
-            expect(destination.addEquipment(equipment, null, true)).toEqual({ success: true, info: 'put in cargo' });
+            check.equals(destination.addEquipment(equipment, null, true), { success: true, info: 'put in cargo' });
             ship.critical = true;
-            expect(destination.addEquipment(equipment, null, true)).toEqual({ success: false, info: 'put in cargo', error: 'not a fleet member' });
+            check.equals(destination.addEquipment(equipment, null, true), { success: false, info: 'put in cargo', error: 'not a fleet member' });
             ship.critical = false;
 
-            expect(source.removeEquipment(equipment, null, true)).toEqual({ success: false, info: 'remove from cargo', error: 'not in cargo!' });
+            check.equals(source.removeEquipment(equipment, null, true), { success: false, info: 'remove from cargo', error: 'not in cargo!' });
             ship.addCargo(equipment.item);
-            expect(source.removeEquipment(equipment, null, true)).toEqual({ success: true, info: 'remove from cargo' });
+            check.equals(source.removeEquipment(equipment, null, true), { success: true, info: 'remove from cargo' });
             ship.critical = true;
-            expect(source.removeEquipment(equipment, null, true)).toEqual({ success: false, info: 'remove from cargo', error: 'not a fleet member' });
+            check.equals(source.removeEquipment(equipment, null, true), { success: false, info: 'remove from cargo', error: 'not a fleet member' });
         });
     });
 }

src/ui/character/CharacterEquipment.spec.ts

@@ -1,5 +1,5 @@
 module TK.SpaceTac.UI.Specs {
-    describe("CharacterEquipment", function () {
+    testing("CharacterEquipment", test => {
         let testgame = setupEmptyView();
 
         class FakeContainer implements CharacterEquipmentContainer {
@@ -60,43 +60,43 @@ module TK.SpaceTac.UI.Specs {
             return [sheet, equipment, containers, refresh];
         }
 
-        it("handles drag-and-drop to move equipment", function () {
+        test.case("handles drag-and-drop to move equipment", check => {
             let [sheet, equipment, [container1, container2, container3], refresh] = createBasicCase([0, 100, 200]);
 
-            expect(equipment.inputEnabled).toBe(true, "Input should be enabled");
-            expect(equipment.input.draggable).toBe(true, "Equipment should be draggable");
-            expect(equipment.container).toBe(container1);
-            expect(equipment.x).toBe(0);
-            expect(equipment.scale.x).toBe(0.25);
+            check.same(equipment.inputEnabled, true, "Input should be enabled");
+            check.same(equipment.input.draggable, true, "Equipment should be draggable");
+            check.same(equipment.container, container1);
+            check.equals(equipment.x, 0);
+            check.equals(equipment.scale.x, 0.25);
 
             // drop on nothing
-            expect(equipment.alpha).toBe(1);
+            check.equals(equipment.alpha, 1);
             equipment.events.onDragStart.dispatch();
-            expect(equipment.alpha).toBe(0.8);
+            check.equals(equipment.alpha, 0.8);
             equipment.x = 812;
             equipment.events.onDragStop.dispatch();
-            expect(equipment.container).toBe(container1);
-            expect(equipment.x).toBe(0);
+            check.same(equipment.container, container1);
+            check.equals(equipment.x, 0);
             expect(refresh).toHaveBeenCalledTimes(0);
 
             // drop on accepting destination
             equipment.events.onDragStart.dispatch();
             equipment.x = 100;
             equipment.events.onDragStop.dispatch();
-            expect(equipment.container).toBe(container2);
-            expect(equipment.x).toBe(100);
-            expect(container1.inside).toBeNull();
-            expect(container2.inside).toBe(equipment);
+            check.same(equipment.container, container2);
+            check.equals(equipment.x, 100);
+            check.equals(container1.inside, null);
+            check.same(container2.inside, equipment);
             expect(refresh).toHaveBeenCalledTimes(1);
 
             // drop on refusing destination
             equipment.events.onDragStart.dispatch();
             equipment.x = 200;
             equipment.events.onDragStop.dispatch();
-            expect(equipment.container).toBe(container2);
-            expect(equipment.x).toBe(100);
-            expect(container2.inside).toBe(equipment);
-            expect(container3.inside).toBe(null);
+            check.same(equipment.container, container2);
+            check.equals(equipment.x, 100);
+            check.same(container2.inside, equipment);
+            check.equals(container3.inside, null);
             expect(refresh).toHaveBeenCalledTimes(1);
 
             // broken destination, should return to source
@@ -105,8 +105,8 @@ module TK.SpaceTac.UI.Specs {
             equipment.events.onDragStart.dispatch();
             equipment.x = 200;
             equipment.events.onDragStop.dispatch();
-            expect(equipment.container).toBe(container2);
-            expect(equipment.x).toBe(100);
+            check.same(equipment.container, container2);
+            check.equals(equipment.x, 100);
             expect(refresh).toHaveBeenCalledTimes(1);
             expect(log).toHaveBeenCalledWith('Destination container refused to accept equipment', equipment, container2, container3);
 
@@ -115,13 +115,13 @@ module TK.SpaceTac.UI.Specs {
             equipment.events.onDragStart.dispatch();
             equipment.x = 200;
             equipment.events.onDragStop.dispatch();
-            expect(equipment.container).toBe(container3);
-            expect(equipment.x).toBe(200);
+            check.same(equipment.container, container3);
+            check.equals(equipment.x, 200);
             expect(refresh).toHaveBeenCalledTimes(2);
             expect(log).toHaveBeenCalledWith('Equipment lost in bad exchange!', equipment, container2, container3);
         });
 
-        it("defines the sheet's action message", function () {
+        test.case("defines the sheet's action message", check => {
             let [sheet, equipment, [container1, container2], refresh] = createBasicCase([0, 1]);
 
             spyOn(container1, "removeEquipment").and.returnValues(
@@ -137,18 +137,18 @@ module TK.SpaceTac.UI.Specs {
                 { success: false, info: "attach", error: "cannot attach" }
             )
 
-            expect(sheet.action_message.text).toEqual("");
+            check.equals(sheet.action_message.text, "");
             equipment.events.onDragStart.dispatch();
-            expect(sheet.action_message.text).toEqual("");
+            check.equals(sheet.action_message.text, "");
             equipment.x = 1;
             equipment.events.onDragUpdate.dispatch();
-            expect(sheet.action_message.text).toEqual("Detach, attach");
+            check.equals(sheet.action_message.text, "Detach, attach");
             equipment.events.onDragUpdate.dispatch();
-            expect(sheet.action_message.text).toEqual("Detach, attach (cannot detach)");
+            check.equals(sheet.action_message.text, "Detach, attach (cannot detach)");
             equipment.events.onDragUpdate.dispatch();
-            expect(sheet.action_message.text).toEqual("Detach, attach (cannot attach)");
+            check.equals(sheet.action_message.text, "Detach, attach (cannot attach)");
             equipment.events.onDragUpdate.dispatch();
-            expect(sheet.action_message.text).toEqual("Detach, attach (cannot detach)");
+            check.equals(sheet.action_message.text, "Detach, attach (cannot detach)");
         });
     });
 }

src/ui/character/CharacterFleetMember.spec.ts

@@ -1,8 +1,8 @@
 module TK.SpaceTac.UI.Specs {
-    describe("CharacterFleetMember", function () {
+    testing("CharacterFleetMember", test => {
         let testgame = setupEmptyView();
 
-        it("transfers equipment to another ship", function () {
+        test.case("transfers equipment to another ship", check => {
             let view = testgame.view;
             let sheet = new CharacterSheet(view);
 
@@ -20,49 +20,49 @@ module TK.SpaceTac.UI.Specs {
             ship2.setCargoSpace(1);
 
             sheet.show(ship1);
-            expect(sheet.portraits.length).toBe(2);
-            expect(sheet.layer_equipments.length).toBe(3);
-            expect(sheet.ship_cargo.length).toBe(3);
+            check.equals(sheet.portraits.length, 2);
+            check.equals(sheet.layer_equipments.length, 3);
+            check.equals(sheet.ship_cargo.length, 3);
 
             // First item fits in the free slot
             let source = <CharacterCargo>sheet.ship_cargo.children[0];
             let dest = <CharacterFleetMember>sheet.portraits.children[1];
             let equ = <CharacterEquipment>sheet.layer_equipments.children[0];
-            expect(dest.ship).toBe(ship2);
-            expect(equ.item).toBe(equ1);
-            expect(ship1.cargo).toContain(equ1);
-            expect(ship2engine.attached).toBe(null);
+            check.same(dest.ship, ship2);
+            check.same(equ.item, equ1);
+            check.contains(ship1.cargo, equ1);
+            check.equals(ship2engine.attached, null);
             equ.applyDragDrop(source, dest, false);
-            expect(ship1.cargo).not.toContain(equ1);
-            expect(ship2engine.attached).toBe(equ1);
+            check.notcontains(ship1.cargo, equ1);
+            check.same(ship2engine.attached, equ1);
 
             // Second item goes to cargo
             source = <CharacterCargo>sheet.ship_cargo.children[0];
             dest = <CharacterFleetMember>sheet.portraits.children[1];
             equ = <CharacterEquipment>sheet.layer_equipments.children[1];
-            expect(dest.ship).toBe(ship2);
-            expect(equ.item).toBe(equ2);
-            expect(ship1.cargo).toContain(equ2);
-            expect(ship2.cargo).not.toContain(equ2);
+            check.same(dest.ship, ship2);
+            check.same(equ.item, equ2);
+            check.contains(ship1.cargo, equ2);
+            check.notcontains(ship2.cargo, equ2);
             equ.applyDragDrop(source, dest, false);
-            expect(ship1.cargo).not.toContain(equ2);
-            expect(ship2.cargo).toContain(equ2);
+            check.notcontains(ship1.cargo, equ2);
+            check.contains(ship2.cargo, equ2);
 
             // Third item has no more room
             source = <CharacterCargo>sheet.ship_cargo.children[0];
             dest = <CharacterFleetMember>sheet.portraits.children[1];
             equ = <CharacterEquipment>sheet.layer_equipments.children[2];
-            expect(dest.ship).toBe(ship2);
-            expect(equ.item).toBe(equ3);
-            expect(ship1.cargo).toContain(equ3);
+            check.same(dest.ship, ship2);
+            check.same(equ.item, equ3);
+            check.contains(ship1.cargo, equ3);
             equ.applyDragDrop(source, dest, false);
-            expect(ship1.cargo).toContain(equ3);
+            check.contains(ship1.cargo, equ3);
 
             // Cannot transfer to escorted ship
             ship2.setCargoSpace(2);
-            expect(equ.applyDragDrop(source, dest, true)).toEqual({ success: true, info: 'remove from cargo, transfer to unnamed', error: undefined });
+            check.equals(equ.applyDragDrop(source, dest, true), { success: true, info: 'remove from cargo, transfer to unnamed', error: undefined });
             ship2.critical = true;
-            expect(equ.applyDragDrop(source, dest, true)).toEqual({ success: false, info: 'remove from cargo, transfer to unnamed', error: 'not a fleet member' });
+            check.equals(equ.applyDragDrop(source, dest, true), { success: false, info: 'remove from cargo, transfer to unnamed', error: 'not a fleet member' });
         });
     });
 }

src/ui/character/CharacterLootSlot.spec.ts

@@ -1,8 +1,8 @@
 module TK.SpaceTac.UI.Specs {
-    describe("CharacterLootSlot", function () {
+    testing("CharacterLootSlot", test => {
         let testgame = setupEmptyView();
 
-        it("takes or discard loot", function () {
+        test.case("takes or discard loot", check => {
             let view = testgame.view;
             let sheet = new CharacterSheet(view);
 
@@ -17,27 +17,27 @@ module TK.SpaceTac.UI.Specs {
             sheet.setLoot(loot);
             sheet.show(ship);
 
-            expect(ship.cargo).toEqual([equ1]);
-            expect(loot).toEqual([equ2]);
+            check.equals(ship.cargo, [equ1]);
+            check.equals(loot, [equ2]);
 
             let cargo_slot = <CharacterCargo>sheet.ship_cargo.children[0];
-            expect(cargo_slot instanceof CharacterCargo).toBe(true);
+            check.equals(cargo_slot instanceof CharacterCargo, true);
             let loot_slot = <CharacterLootSlot>sheet.loot_slots.children[0];
-            expect(loot_slot instanceof CharacterLootSlot).toBe(true);
+            check.equals(loot_slot instanceof CharacterLootSlot, true);
 
             // loot to cargo
             let equ2s = <CharacterEquipment>sheet.layer_equipments.children[1];
-            expect(equ2s.item).toBe(equ2);
+            check.same(equ2s.item, equ2);
             equ2s.applyDragDrop(loot_slot, cargo_slot, false);
-            expect(ship.cargo).toEqual([equ1, equ2]);
-            expect(loot).toEqual([]);
+            check.equals(ship.cargo, [equ1, equ2]);
+            check.equals(loot, []);
 
             // discard to cargo
             let equ1s = <CharacterEquipment>sheet.layer_equipments.children[0];
-            expect(equ1s.item).toBe(equ1);
+            check.same(equ1s.item, equ1);
             equ1s.applyDragDrop(cargo_slot, loot_slot, false);
-            expect(ship.cargo).toEqual([equ2]);
-            expect(loot).toEqual([equ1]);
+            check.equals(ship.cargo, [equ2]);
+            check.equals(loot, [equ1]);
         });
     });
 }

src/ui/character/CharacterSheet.spec.ts

@@ -1,14 +1,14 @@
 module TK.SpaceTac.UI.Specs {
-    describe("CharacterSheet", function () {
+    testing("CharacterSheet", test => {
 
-        describe("in UI", function () {
+        testing("in UI", test => {
             let testgame = setupEmptyView();
 
-            it("displays fleet and ship information", function () {
+            test.case("displays fleet and ship information", check => {
                 let view = testgame.view;
                 let sheet = new CharacterSheet(view, -1000);
 
-                expect(sheet.x).toEqual(-1000);
+                check.equals(sheet.x, -1000);
 
                 let fleet = new Fleet();
                 let ship1 = fleet.addShip();
@@ -25,22 +25,22 @@ module TK.SpaceTac.UI.Specs {
 
                 sheet.show(ship1, false);
 
-                expect(sheet.x).toEqual(0);
-                expect(sheet.portraits.length).toBe(2);
+                check.equals(sheet.x, 0);
+                check.equals(sheet.portraits.length, 2);
 
-                expect(sheet.ship_name.text).toEqual("Player's Level 1 Ship 1");
-                expect(sheet.ship_slots.length).toBe(4);
-                expect(sheet.ship_cargo.length).toBe(3);
+                check.equals(sheet.ship_name.text, "Player's Level 1 Ship 1");
+                check.equals(sheet.ship_slots.length, 4);
+                check.equals(sheet.ship_cargo.length, 3);
 
                 let portrait = <Phaser.Button>sheet.portraits.getChildAt(1);
                 portrait.onInputUp.dispatch();
 
-                expect(sheet.ship_name.text).toEqual("Player's Level 1 Ship 2");
-                expect(sheet.ship_slots.length).toBe(1);
-                expect(sheet.ship_cargo.length).toBe(2);
+                check.equals(sheet.ship_name.text, "Player's Level 1 Ship 2");
+                check.equals(sheet.ship_slots.length, 1);
+                check.equals(sheet.ship_cargo.length, 2);
             });
 
-            it("moves equipment around", function () {
+            test.case("moves equipment around", check => {
                 let fleet = new Fleet();
                 let ship = fleet.addShip();
                 ship.setCargoSpace(2);
@@ -55,13 +55,13 @@ module TK.SpaceTac.UI.Specs {
                 let sheet = new CharacterSheet(testgame.view);
                 sheet.show(ship, false);
 
-                expect(sheet.loot_slots.visible).toBe(false);
-                expect(sheet.layer_equipments.children.length).toBe(2);
+                check.equals(sheet.loot_slots.visible, false);
+                check.equals(sheet.layer_equipments.children.length, 2);
 
                 sheet.setLoot(loot);
 
-                expect(sheet.loot_slots.visible).toBe(true);
-                expect(sheet.layer_equipments.children.length).toBe(4);
+                check.equals(sheet.loot_slots.visible, true);
+                check.equals(sheet.layer_equipments.children.length, 4);
 
                 let findsprite = (equ: Equipment) => nn(first(<CharacterEquipment[]>sheet.layer_equipments.children, sp => sp.item == equ));
                 let draddrop = (sp: CharacterEquipment, dest: CharacterCargo | CharacterSlot) => {
@@ -70,64 +70,64 @@ module TK.SpaceTac.UI.Specs {
 
                 // Unequip
                 let sprite = findsprite(equ1);
-                expect(equ1.attached_to).not.toBeNull();
-                expect(ship.cargo.length).toBe(1);
+                check.notequals(equ1.attached_to, null);
+                check.equals(ship.cargo.length, 1);
                 draddrop(sprite, <CharacterCargo>sheet.ship_cargo.children[0]);
-                expect(equ1.attached_to).toBeNull();
-                expect(ship.cargo.length).toBe(2);
-                expect(ship.cargo).toContain(equ1);
+                check.equals(equ1.attached_to, null);
+                check.equals(ship.cargo.length, 2);
+                check.contains(ship.cargo, equ1);
 
                 // Equip
                 sprite = findsprite(equ2);
-                expect(equ2.attached_to).toBeNull();
-                expect(ship.cargo).toContain(equ2);
+                check.equals(equ2.attached_to, null);
+                check.contains(ship.cargo, equ2);
                 draddrop(sprite, <CharacterSlot>sheet.ship_slots.children[0]);
-                expect(equ2.attached_to).toBe(ship.slots[1]);
-                expect(ship.cargo).not.toContain(equ2);
+                check.same(equ2.attached_to, ship.slots[1]);
+                check.notcontains(ship.cargo, equ2);
 
                 // Loot
                 sprite = findsprite(equ3);
-                expect(equ3.attached_to).toBeNull();
-                expect(ship.cargo).not.toContain(equ3);
-                expect(loot).toContain(equ3);
+                check.equals(equ3.attached_to, null);
+                check.notcontains(ship.cargo, equ3);
+                check.contains(loot, equ3);
                 draddrop(sprite, <CharacterCargo>sheet.ship_cargo.children[0]);
-                expect(equ3.attached_to).toBeNull();
-                expect(ship.cargo).toContain(equ3);
-                expect(loot).not.toContain(equ3);
+                check.equals(equ3.attached_to, null);
+                check.contains(ship.cargo, equ3);
+                check.notcontains(loot, equ3);
 
                 // Can't loop - no cargo space available
                 sprite = findsprite(equ4);
-                expect(ship.cargo).not.toContain(equ4);
-                expect(loot).toContain(equ4);
+                check.notcontains(ship.cargo, equ4);
+                check.contains(loot, equ4);
                 draddrop(sprite, <CharacterCargo>sheet.ship_cargo.children[0]);
-                expect(ship.cargo).not.toContain(equ4);
-                expect(loot).toContain(equ4);
+                check.notcontains(ship.cargo, equ4);
+                check.contains(loot, equ4);
 
                 // Discard
                 sprite = findsprite(equ1);
-                expect(ship.cargo).toContain(equ1);
-                expect(loot).not.toContain(equ1);
+                check.contains(ship.cargo, equ1);
+                check.notcontains(loot, equ1);
                 draddrop(sprite, <CharacterCargo>sheet.ship_cargo.children[0]);
-                expect(equ1.attached_to).toBeNull();
-                expect(loot).not.toContain(equ1);
+                check.equals(equ1.attached_to, null);
+                check.notcontains(loot, equ1);
 
                 // Can't equip - no slot available
                 sprite = findsprite(equ3);
-                expect(equ3.attached_to).toBeNull();
+                check.equals(equ3.attached_to, null);
                 draddrop(sprite, <CharacterSlot>sheet.ship_slots.children[0]);
-                expect(equ3.attached_to).toBeNull();
+                check.equals(equ3.attached_to, null);
             });
         });
 
-        it("fits slots in area", function () {
+        test.case("fits slots in area", check => {
             let result = CharacterSheet.getSlotPositions(6, 300, 200, 100, 100);
-            expect(result).toEqual({
+            check.equals(result, {
                 positions: [{ x: 0, y: 0 }, { x: 100, y: 0 }, { x: 200, y: 0 }, { x: 0, y: 100 }, { x: 100, y: 100 }, { x: 200, y: 100 }],
                 scaling: 1
             });
 
             result = CharacterSheet.getSlotPositions(6, 299, 199, 100, 100);
-            expect(result).toEqual({
+            check.equals(result, {
                 positions: [{ x: 0, y: 0 }, { x: 100, y: 0 }, { x: 200, y: 0 }, { x: 0, y: 100 }, { x: 100, y: 100 }, { x: 200, y: 100 }],
                 scaling: 0.99
             });

src/ui/character/CharacterShopSlot.spec.ts

@@ -1,8 +1,8 @@
 module TK.SpaceTac.UI.Specs {
-    describe("CharacterShopSlot", function () {
+    testing("CharacterShopSlot", test => {
         let testgame = setupEmptyView();
 
-        it("buys and sell if bound to a shop", function () {
+        test.case("buys and sell if bound to a shop", check => {
             let view = testgame.view;
             let sheet = new CharacterSheet(view);
 
@@ -19,38 +19,38 @@ module TK.SpaceTac.UI.Specs {
             sheet.setShop(shop);
             sheet.show(ship);
 
-            expect(ship.cargo).toEqual([equ1]);
-            expect(shop.stock).toEqual([equ2]);
-            expect(fleet.credits).toBe(100);
+            check.equals(ship.cargo, [equ1]);
+            check.equals(shop.stock, [equ2]);
+            check.equals(fleet.credits, 100);
 
             let cargo_slot = <CharacterCargo>sheet.ship_cargo.children[0];
-            expect(cargo_slot instanceof CharacterCargo).toBe(true);
+            check.equals(cargo_slot instanceof CharacterCargo, true);
             let shop_slot = <CharacterShopSlot>sheet.loot_slots.children[0];
-            expect(shop_slot instanceof CharacterShopSlot).toBe(true);
+            check.equals(shop_slot instanceof CharacterShopSlot, true);
 
             // sell
             let equ1s = <CharacterEquipment>sheet.layer_equipments.children[0];
-            expect(equ1s.item).toBe(equ1);
+            check.same(equ1s.item, equ1);
             equ1s.applyDragDrop(cargo_slot, shop_slot, false);
-            expect(ship.cargo).toEqual([]);
-            expect(shop.stock).toEqual([equ2, equ1]);
-            expect(fleet.credits).toBe(220);
+            check.equals(ship.cargo, []);
+            check.equals(shop.stock, [equ2, equ1]);
+            check.equals(fleet.credits, 220);
 
             // buy
             let equ2s = <CharacterEquipment>sheet.layer_equipments.children[1];
-            expect(equ2s.item).toBe(equ2);
+            check.same(equ2s.item, equ2);
             equ2s.applyDragDrop(shop_slot, cargo_slot, false);
-            expect(ship.cargo).toEqual([equ2]);
-            expect(shop.stock).toEqual([equ1]);
-            expect(fleet.credits).toBe(100);
+            check.equals(ship.cargo, [equ2]);
+            check.equals(shop.stock, [equ1]);
+            check.equals(fleet.credits, 100);
 
             // not enough money
             equ1s = <CharacterEquipment>sheet.layer_equipments.children[0];
-            expect(equ1s.item).toBe(equ1);
+            check.same(equ1s.item, equ1);
             equ1s.applyDragDrop(shop_slot, cargo_slot, false);
-            expect(ship.cargo).toEqual([equ2]);
-            expect(shop.stock).toEqual([equ1]);
-            expect(fleet.credits).toBe(100);
+            check.equals(ship.cargo, [equ2]);
+            check.equals(shop.stock, [equ1]);
+            check.equals(fleet.credits, 100);
         });
     });
 }

src/ui/character/CharacterSlot.spec.ts

@@ -1,8 +1,8 @@
 module TK.SpaceTac.UI.Specs {
-    describe("CharacterSlot", function () {
+    testing("CharacterSlot", test => {
         let testgame = setupEmptyView();
 
-        it("allows dragging equipment", function () {
+        test.case("allows dragging equipment", check => {
             let view = testgame.view;
             let ship = new Ship();
             ship.addSlot(SlotType.Hull);
@@ -13,35 +13,35 @@ module TK.SpaceTac.UI.Specs {
             let equipment = new CharacterEquipment(sheet, new Equipment(SlotType.Engine), source);
 
             let slot = new CharacterSlot(sheet, 0, 0, SlotType.Engine);
-            expect(slot.addEquipment(equipment, source, true)).toEqual({ success: false, info: 'equip in engine slot', error: 'no free slot' });
-            expect(slot.removeEquipment(equipment, source, true)).toEqual({ success: false, info: 'unequip from engine slot', error: 'not equipped!' });
+            check.equals(slot.addEquipment(equipment, source, true), { success: false, info: 'equip in engine slot', error: 'no free slot' });
+            check.equals(slot.removeEquipment(equipment, source, true), { success: false, info: 'unequip from engine slot', error: 'not equipped!' });
 
             ship.addSlot(SlotType.Engine);
-            expect(slot.addEquipment(equipment, source, true)).toEqual({ success: true, info: 'equip in engine slot' });
+            check.equals(slot.addEquipment(equipment, source, true), { success: true, info: 'equip in engine slot' });
 
             equipment.item.requirements["skill_time"] = 1;
-            expect(slot.addEquipment(equipment, source, true)).toEqual({ success: false, info: 'equip in engine slot', error: 'missing skills' });
+            check.equals(slot.addEquipment(equipment, source, true), { success: false, info: 'equip in engine slot', error: 'missing skills' });
 
             ship.upgradeSkill("skill_time");
-            expect(slot.addEquipment(equipment, source, true)).toEqual({ success: true, info: 'equip in engine slot' });
+            check.equals(slot.addEquipment(equipment, source, true), { success: true, info: 'equip in engine slot' });
 
             ship.critical = true;
-            expect(slot.addEquipment(equipment, source, true)).toEqual({ success: false, info: 'equip in engine slot', error: 'not a fleet member' });
+            check.equals(slot.addEquipment(equipment, source, true), { success: false, info: 'equip in engine slot', error: 'not a fleet member' });
             ship.critical = false;
 
-            expect(ship.listEquipment(SlotType.Engine)).toEqual([]);
+            check.equals(ship.listEquipment(SlotType.Engine), []);
             let result = slot.addEquipment(equipment, source, false);
-            expect(result).toEqual({ success: true, info: 'equip in engine slot' });
-            expect(ship.listEquipment(SlotType.Engine)).toEqual([equipment.item]);
+            check.equals(result, { success: true, info: 'equip in engine slot' });
+            check.equals(ship.listEquipment(SlotType.Engine), [equipment.item]);
 
-            expect(slot.removeEquipment(equipment, source, true)).toEqual({ success: true, info: 'unequip from engine slot' });
+            check.equals(slot.removeEquipment(equipment, source, true), { success: true, info: 'unequip from engine slot' });
             ship.critical = true;
-            expect(slot.removeEquipment(equipment, source, true)).toEqual({ success: false, info: 'unequip from engine slot', error: 'not a fleet member' });
+            check.equals(slot.removeEquipment(equipment, source, true), { success: false, info: 'unequip from engine slot', error: 'not a fleet member' });
             ship.critical = false;
 
             result = slot.removeEquipment(equipment, source, false);
-            expect(result).toEqual({ success: true, info: 'unequip from engine slot' });
-            expect(ship.listEquipment(SlotType.Engine)).toEqual([]);
+            check.equals(result, { success: true, info: 'unequip from engine slot' });
+            check.equals(ship.listEquipment(SlotType.Engine), []);
 
         });
     });

src/ui/character/FleetCreationView.spec.ts

@@ -4,50 +4,50 @@ module TK.SpaceTac.UI.Specs {
     testing("FleetCreationView", test => {
         let testgame = setupSingleView(() => [new FleetCreationView, []]);
 
-        test.case("has a basic equipment shop with infinite stock", function () {
+        test.case("has a basic equipment shop with infinite stock", check => {
             let shop = testgame.view.infinite_shop;
             let itemcount = shop.getStock().length;
-            expect(unique(shop.getStock().map(equ => equ.code)).length).toEqual(itemcount);
+            check.equals(unique(shop.getStock().map(equ => equ.code)).length, itemcount);
 
             let fleet = new Fleet();
             fleet.credits = 100000;
             let item = shop.getStock()[0];
             shop.sellToFleet(item, fleet);
-            expect(fleet.credits).toBe(100000 - item.getPrice());
-            expect(shop.getStock().length).toBe(itemcount);
+            check.same(fleet.credits, 100000 - item.getPrice());
+            check.same(shop.getStock().length, itemcount);
 
             shop.buyFromFleet(item, fleet);
-            expect(fleet.credits).toBe(100000);
-            expect(shop.getStock().length).toBe(itemcount);
+            check.equals(fleet.credits, 100000);
+            check.same(shop.getStock().length, itemcount);
         })
 
-        test.acase("validates the fleet creation", async function () {
-            expect(testgame.ui.session.isFleetCreated()).toBe(false, "no fleet created");
-            expect(testgame.ui.session.player.fleet.ships.length).toBe(0, "empty session fleet");
-            expect(testgame.view.dialogs_layer.children.length).toBe(0, "no dialogs");
-            expect(testgame.view.character_sheet.fleet).toBe(testgame.view.built_fleet);
-            expect(testgame.view.built_fleet.ships.length).toBe(2, "initial fleet should have two ships");
+        test.acase("validates the fleet creation", async check => {
+            check.same(testgame.ui.session.isFleetCreated(), false, "no fleet created");
+            check.same(testgame.ui.session.player.fleet.ships.length, 0, "empty session fleet");
+            check.same(testgame.view.dialogs_layer.children.length, 0, "no dialogs");
+            check.same(testgame.view.character_sheet.fleet, testgame.view.built_fleet);
+            check.same(testgame.view.built_fleet.ships.length, 2, "initial fleet should have two ships");
 
             // close sheet
             testClick(testgame.view.character_sheet.close_button);
-            expect(testgame.view.dialogs_opened.length).toBe(1, "confirmation dialog opened");
-            expect(testgame.ui.session.isFleetCreated()).toBe(false, "still no fleet created");
+            check.same(testgame.view.dialogs_opened.length, 1, "confirmation dialog opened");
+            check.same(testgame.ui.session.isFleetCreated(), false, "still no fleet created");
 
             // click on no in confirmation dialog
             let dialog = <UIConfirmDialog>testgame.view.dialogs_opened[0];
             await dialog.forceResult(false);
-            expect(testgame.view.dialogs_opened.length).toBe(0, "confirmation dialog destroyed after 'no'");
-            expect(testgame.ui.session.isFleetCreated()).toBe(false, "still no fleet created after 'no'");
-            expect(testgame.state).toEqual("test_initial");
+            check.same(testgame.view.dialogs_opened.length, 0, "confirmation dialog destroyed after 'no'");
+            check.same(testgame.ui.session.isFleetCreated(), false, "still no fleet created after 'no'");
+            check.equals(testgame.state, "test_initial");
 
             // close sheet, click on yes in confirmation dialog
             testClick(testgame.view.character_sheet.close_button);
             dialog = <UIConfirmDialog>testgame.view.dialogs_opened[0];
             await dialog.forceResult(true);
-            expect(testgame.view.dialogs_opened.length).toBe(0, "confirmation dialog destroyed after 'yes'");
-            expect(testgame.ui.session.isFleetCreated()).toBe(true, "fleet created");
-            expect(testgame.ui.session.player.fleet.ships.length).toBe(2, "session fleet now has two ships");
-            expect(testgame.state).toEqual("router");
+            check.same(testgame.view.dialogs_opened.length, 0, "confirmation dialog destroyed after 'yes'");
+            check.same(testgame.ui.session.isFleetCreated(), true, "fleet created");
+            check.same(testgame.ui.session.player.fleet.ships.length, 2, "session fleet now has two ships");
+            check.equals(testgame.state, "router");
         })
     })
 }

src/ui/common/Animations.spec.ts

@@ -1,64 +1,64 @@
 module TK.SpaceTac.UI.Specs {
-    describe("Animations", () => {
+    testing("Animations", test => {
         let testgame = setupEmptyView();
 
-        it("shows and hides objects", function () {
+        test.case("shows and hides objects", check => {
             let obj = { visible: false, alpha: 0.5 };
 
-            expect(testgame.view.animations.simulate(obj, 'alpha')).toEqual([]);
+            check.equals(testgame.view.animations.simulate(obj, 'alpha'), []);
 
             testgame.view.animations.show(obj);
 
-            expect(obj.visible).toBe(true);
-            expect(obj.alpha).toBe(0);
-            expect(testgame.view.animations.simulate(obj, 'alpha')).toEqual([0, 0.25, 0.5, 0.75, 1]);
+            check.equals(obj.visible, true);
+            check.equals(obj.alpha, 0);
+            check.equals(testgame.view.animations.simulate(obj, 'alpha'), [0, 0.25, 0.5, 0.75, 1]);
 
             obj.alpha = 1;
             testgame.view.animations.hide(obj);
 
-            expect(obj.visible).toBe(true);
-            expect(obj.alpha).toBe(1);
-            expect(testgame.view.animations.simulate(obj, 'alpha')).toEqual([1, 0.75, 0.5, 0.25, 0]);
+            check.equals(obj.visible, true);
+            check.equals(obj.alpha, 1);
+            check.equals(testgame.view.animations.simulate(obj, 'alpha'), [1, 0.75, 0.5, 0.25, 0]);
 
             obj.alpha = 0.2;
             testgame.view.animations.setVisible(obj, true, 1000, 0.6);
 
-            expect(obj.visible).toBe(true);
-            expect(obj.alpha).toBe(0.2);
-            expect(testgame.view.animations.simulate(obj, 'alpha')).toEqual([0.2, 0.3, 0.4, 0.5, 0.6]);
+            check.equals(obj.visible, true);
+            check.equals(obj.alpha, 0.2);
+            check.equals(testgame.view.animations.simulate(obj, 'alpha'), [0.2, 0.3, 0.4, 0.5, 0.6]);
 
             obj.alpha = 0.6;
             testgame.view.animations.setVisible(obj, false, 1000, 0.6, 0.2);
 
-            expect(obj.visible).toBe(true);
-            expect(obj.alpha).toBe(0.6);
-            expect(testgame.view.animations.simulate(obj, 'alpha')).toEqual([0.6, 0.5, 0.4, 0.3, 0.2]);
+            check.equals(obj.visible, true);
+            check.equals(obj.alpha, 0.6);
+            check.equals(testgame.view.animations.simulate(obj, 'alpha'), [0.6, 0.5, 0.4, 0.3, 0.2]);
         });
 
-        it("blocks input while object is hidden", function () {
+        test.case("blocks input while object is hidden", check => {
             let obj = { visible: true, alpha: 1, input: { enabled: true }, changeStateFrame: jasmine.createSpy("changeStateFrame"), freezeFrames: false };
 
             testgame.view.animations.setVisible(obj, false, 0);
-            expect(obj.visible).toBe(false);
-            expect(obj.alpha).toBe(0);
-            expect(obj.input.enabled).toBe(false);
+            check.equals(obj.visible, false);
+            check.equals(obj.alpha, 0);
+            check.equals(obj.input.enabled, false);
             expect(obj.changeStateFrame).toHaveBeenCalledWith("Out");
-            expect(obj.freezeFrames).toBe(true);
+            check.equals(obj.freezeFrames, true);
 
             testgame.view.animations.setVisible(obj, true, 0);
-            expect(obj.visible).toBe(true);
-            expect(obj.alpha).toBe(1);
-            expect(obj.input.enabled).toBe(true);
+            check.equals(obj.visible, true);
+            check.equals(obj.alpha, 1);
+            check.equals(obj.input.enabled, true);
             expect(obj.changeStateFrame).toHaveBeenCalledTimes(1);
-            expect(obj.freezeFrames).toBe(false);
+            check.equals(obj.freezeFrames, false);
         });
 
-        it("animates rotation", function () {
+        test.case("animates rotation", check => {
             let obj = { rotation: -Math.PI * 2.5 };
             let tween = testgame.ui.tweens.create(obj);
             let result = Animations.rotationTween(tween, Math.PI * 0.25, 1, Phaser.Easing.Linear.None);
-            expect(result).toEqual(750);
-            expect(tween.generateData(4)).toEqual([
+            check.equals(result, 750);
+            check.equals(tween.generateData(4), [
                 { rotation: -Math.PI * 0.25 },
                 { rotation: 0 },
                 { rotation: Math.PI * 0.25 },

src/ui/common/InputManager.spec.ts

@@ -1,8 +1,9 @@
 module TK.SpaceTac.UI.Specs {
-    describe("InputManager", function () {
+    testing("InputManager", test => {
         let testgame = setupEmptyView();
+        let clock = test.clock();
 
-        it("handles hover and click on desktops and mobile targets", function (done) {
+        test.case("handles hover and click on desktops and mobile targets", check => {
             let inputs = testgame.view.inputs;
 
             let pointer = new Phaser.Pointer(testgame.ui, 0);
@@ -46,7 +47,7 @@ module TK.SpaceTac.UI.Specs {
             // Leaves on destroy
             [button, funcs] = newButton();
             press(button);
-            jasmine.clock().tick(150);
+            clock.forward(150);
             expect(funcs.enter).toHaveBeenCalledTimes(1);
             expect(funcs.leave).toHaveBeenCalledTimes(0);
             expect(funcs.click).toHaveBeenCalledTimes(0);
@@ -64,7 +65,7 @@ module TK.SpaceTac.UI.Specs {
             let [button1, funcs1] = newButton();
             let [button2, funcs2] = newButton();
             enter(button1);
-            jasmine.clock().tick(150);
+            clock.forward(150);
             expect(funcs1.enter).toHaveBeenCalledTimes(1);
             expect(funcs1.leave).toHaveBeenCalledTimes(0);
             expect(funcs1.click).toHaveBeenCalledTimes(0);
@@ -75,7 +76,7 @@ module TK.SpaceTac.UI.Specs {
             expect(funcs2.enter).toHaveBeenCalledTimes(0);
             expect(funcs2.leave).toHaveBeenCalledTimes(0);
             expect(funcs2.click).toHaveBeenCalledTimes(0);
-            jasmine.clock().tick(150);
+            clock.forward(150);
             expect(funcs1.enter).toHaveBeenCalledTimes(1);
             expect(funcs1.leave).toHaveBeenCalledTimes(1);
             expect(funcs1.click).toHaveBeenCalledTimes(0);
@@ -84,57 +85,54 @@ module TK.SpaceTac.UI.Specs {
             expect(funcs2.click).toHaveBeenCalledTimes(0);
 
             // Hold to hover on mobile
-            jasmine.clock().uninstall();
             [button, funcs] = newButton();
             button.onInputDown.dispatch(button, pointer);
-            Timer.global.schedule(150, () => {
-                expect(funcs.enter).toHaveBeenCalledTimes(1);
-                expect(funcs.leave).toHaveBeenCalledTimes(0);
-                expect(funcs.click).toHaveBeenCalledTimes(0);
-                button.onInputUp.dispatch(button, pointer);
-                expect(funcs.enter).toHaveBeenCalledTimes(1);
-                expect(funcs.leave).toHaveBeenCalledTimes(1);
-                expect(funcs.click).toHaveBeenCalledTimes(0);
-                done();
-            });
+            clock.forward(150);
+            expect(funcs.enter).toHaveBeenCalledTimes(1);
+            expect(funcs.leave).toHaveBeenCalledTimes(0);
+            expect(funcs.click).toHaveBeenCalledTimes(0);
+            button.onInputUp.dispatch(button, pointer);
+            expect(funcs.enter).toHaveBeenCalledTimes(1);
+            expect(funcs.leave).toHaveBeenCalledTimes(1);
+            expect(funcs.click).toHaveBeenCalledTimes(0);
         });
 
-        it("handles drag and drop", function () {
+        test.case("handles drag and drop", check => {
             let builder = new UIBuilder(testgame.view);
             let button = builder.button("test", 0, 0, () => null, "test tooltip");
             let tooltip = (<any>testgame.view.tooltip).container;
 
-            expect(button.inputEnabled).toBe(true, "input should be enabled initially");
-            expect(button.input.draggable).toBe(false, "dragging should be disabled initially");
+            check.same(button.inputEnabled, true, "input should be enabled initially");
+            check.same(button.input.draggable, false, "dragging should be disabled initially");
 
             let x = 0;
             testgame.view.inputs.setDragDrop(button, () => x += 1, () => x -= 1);
 
-            expect(button.inputEnabled).toBe(true, "input should still be enabled");
-            expect(button.input.draggable).toBe(true, "dragging should be enabled");
+            check.same(button.inputEnabled, true, "input should still be enabled");
+            check.same(button.input.draggable, true, "dragging should be enabled");
 
-            expect(tooltip.visible).toBe(false, "tooltip hidden initially");
-            expect(button.onInputOver.dispatch(button, testgame.ui.input.pointer1));
-            jasmine.clock().tick(1000);
-            expect(tooltip.visible).toBe(true, "tooltip shown");
+            check.same(tooltip.visible, false, "tooltip hidden initially");
+            button.onInputOver.dispatch(button, testgame.ui.input.pointer1);
+            clock.forward(1000);
+            check.same(tooltip.visible, true, "tooltip shown");
 
-            expect(x).toBe(0, "initial state");
+            check.same(x, 0, "initial state");
             button.events.onDragStart.dispatch();
-            expect(x).toBe(1, "dragged");
-            expect(tooltip.visible).toBe(false, "tooltip hidden on dragging");
+            check.same(x, 1, "dragged");
+            check.same(tooltip.visible, false, "tooltip hidden on dragging");
             button.events.onDragStop.dispatch();
-            expect(x).toBe(0, "dropped");
+            check.same(x, 0, "dropped");
 
             testgame.view.inputs.setDragDrop(button);
 
             button.events.onDragStart.dispatch();
-            expect(x).toBe(0, "drag signal should be disabled");
-            expect(button.inputEnabled).toBe(true, "input should remain enabled");
-            expect(button.input.draggable).toBe(false, "dragging should be disabled at the end");
+            check.same(x, 0, "drag signal should be disabled");
+            check.same(button.inputEnabled, true, "input should remain enabled");
+            check.same(button.input.draggable, false, "dragging should be disabled at the end");
 
             testgame.view.inputs.setDragDrop(button, () => x += 1, () => x -= 1);
             button.events.onDragStart.dispatch();
-            expect(x).toBe(1, "drag signal should be dispatch once");
+            check.same(x, 1, "drag signal should be dispatch once");
         });
     });
 }

src/ui/common/InputManager.ts

@@ -176,7 +176,7 @@ module TK.SpaceTac.UI {
          * Returns functions that may be used to force the behavior
          */
         setHoverClick(obj: Phaser.Button, enter = nop, leave = nop, click = nop, hovertime = 300, holdtime = 600) {
-            let holdstart = new Date();
+            let holdstart = Timer.nowMs();
             let enternext: Function | null = null;
             let entercalled = false;
             let cursorinside = false;
@@ -251,7 +251,7 @@ module TK.SpaceTac.UI {
                 if (destroyed) return;
 
                 if (obj.visible && obj.alpha) {
-                    holdstart = new Date();
+                    holdstart = Timer.nowMs();
                     if (!cursorinside && !enternext) {
                         enternext = Timer.global.schedule(holdtime, effectiveenter);
                     }
@@ -265,7 +265,7 @@ module TK.SpaceTac.UI {
                     effectiveleave();
                 }
 
-                if (new Date().getTime() - holdstart.getTime() < holdtime) {
+                if (Timer.fromMs(holdstart) < holdtime) {
                     if (!cursorinside) {
                         effectiveenter();
                     }

src/ui/common/ParticleBuilder.spec.ts

@@ -1,33 +1,33 @@
 module TK.SpaceTac.UI.Specs {
-    describe("ParticleBuilder", () => {
+    testing("ParticleBuilder", test => {
         let testgame = setupEmptyView();
 
-        it("builds composed particles", function () {
+        test.case("builds composed particles", check => {
             let builder = new ParticleBuilder(testgame.view);
             let particle = builder.build([
                 new ParticleConfig(ParticleShape.ROUND, ParticleColor.BLUE, 2, 1, 45, 10, -20),
                 new ParticleConfig(ParticleShape.DISK_HALO, ParticleColor.WHITE, 0.5, 1, 0, 5, 0)
             ]);
 
-            expect(particle instanceof Phaser.Image).toBe(true);
-            expect(particle.data.frame).toEqual(4);
-            expect(particle.data.key).toEqual("common-particles");
-            expect(particle.scale.x).toEqual(2);
-            expect(particle.scale.y).toEqual(2);
-            expect(particle.x).toEqual(10);
-            expect(particle.y).toEqual(-20);
-            expect(particle.angle).toEqual(45);
+            check.equals(particle instanceof Phaser.Image, true);
+            check.equals(particle.data.frame, 4);
+            check.equals(particle.data.key, "common-particles");
+            check.equals(particle.scale.x, 2);
+            check.equals(particle.scale.y, 2);
+            check.equals(particle.x, 10);
+            check.equals(particle.y, -20);
+            check.equals(particle.angle, 45);
 
-            expect(particle.children.length).toEqual(1);
+            check.equals(particle.children.length, 1);
             let subparticle = <Phaser.Image>particle.getChildAt(0);
-            expect(subparticle instanceof Phaser.Image).toBe(true);
-            expect(subparticle.data.frame).toEqual(16);
-            expect(subparticle.data.key).toEqual("common-particles");
-            expect(subparticle.scale.x).toEqual(0.25);
-            expect(subparticle.scale.y).toEqual(0.25);
-            expect(subparticle.x).toEqual(2.5);
-            expect(subparticle.y).toEqual(0);
-            expect(subparticle.angle).toEqual(-45);
+            check.equals(subparticle instanceof Phaser.Image, true);
+            check.equals(subparticle.data.frame, 16);
+            check.equals(subparticle.data.key, "common-particles");
+            check.equals(subparticle.scale.x, 0.25);
+            check.equals(subparticle.scale.y, 0.25);
+            check.equals(subparticle.x, 2.5);
+            check.equals(subparticle.y, 0);
+            check.equals(subparticle.angle, -45);
         });
     });
 }

src/ui/common/Tooltip.spec.ts

@@ -1,8 +1,9 @@
 module TK.SpaceTac.UI.Specs {
-    describe("Tooltip", () => {
+    testing("Tooltip", test => {
         let testgame = setupEmptyView();
+        let clock = test.clock();
 
-        it("shows near the hovered button", function () {
+        test.case("shows near the hovered button", check => {
             let button = testgame.view.add.button();
             spyOn(button, "getBounds").and.returnValue({ x: 100, y: 50, width: 50, height: 25 });
 
@@ -11,19 +12,19 @@ module TK.SpaceTac.UI.Specs {
 
             let container = <Phaser.Group>(<any>tooltip).container;
             spyOn((<any>container).content, "getBounds").and.returnValue({ x: 0, y: 0, width: 32, height: 32 });
-            expect(container.visible).toBe(false);
+            check.equals(container.visible, false);
 
             button.onInputOver.dispatch();
-            expect(container.visible).toBe(false);
+            check.equals(container.visible, false);
 
-            jasmine.clock().tick(1000);
+            clock.forward(1000);
             container.update();
-            expect(container.visible).toBe(true);
-            expect(container.x).toEqual(109);
-            expect(container.y).toEqual(91);
+            check.equals(container.visible, true);
+            check.equals(container.x, 109);
+            check.equals(container.y, 91);
 
             button.onInputOut.dispatch();
-            expect(container.visible).toBe(false);
+            check.equals(container.visible, false);
         });
     });
 }