diff options
Diffstat (limited to 'src/scripts/tests/util.spec.ts')
| -rw-r--r-- | src/scripts/tests/util.spec.ts | 326 |
1 files changed, 326 insertions, 0 deletions
diff --git a/src/scripts/tests/util.spec.ts b/src/scripts/tests/util.spec.ts new file mode 100644 index 00000000..74d62dfa --- /dev/null +++ b/src/scripts/tests/util.spec.ts @@ -0,0 +1,326 @@ +///<reference path="../util.ts" /> +///<reference path="../../../typings/globals/jasmine/index.d.ts" /> +import {Util} from "../util"; + + +class TestUtils { + /** + * Checks whether the two (three-dimensional) wall lists are equivalent in content. + * + * This is a set-compare method, meaning that the order of the elements does not matter, but that they are present + * in both arrays. + * + * Example of such a list: [[[1, 1], [2, 1]], [[3, 1], [0, 0]]] + * + * @param list1 The first list + * @param list2 The second list + */ + public static wallListEquals(list1: IRoomWall[], list2: IRoomWall[]): void { + let current, found, counter; + + counter = 0; + while (list1.length > 0) { + current = list1.pop(); + found = false; + list2.forEach((e: IRoomWall) => { + if (current.startPos[0] === e.startPos[0] && current.startPos[1] === e.startPos[1] && + current.horizontal === e.horizontal && current.length === e.length) { + counter++; + found = true; + } + }); + if (!found) { + fail(); + } + } + expect(list2.length).toEqual(counter); + } + + /** + * Does the same as wallList3DEquals, only for two lists of tiles. + * + * @param expected + * @param actual + */ + public static positionListEquals(expected: IGridPosition[], actual: IGridPosition[]): void { + let current, found; + let counter = 0; + + while (expected.length > 0) { + current = expected.pop(); + found = false; + actual.forEach((e) => { + if (current.x === e.x && current.y === e.y) { + counter++; + found = true; + } + }); + if (!found) { + fail(); + } + } + + expect(actual.length).toEqual(counter); + } + + public static boundsEquals(actual: IBounds, expected: IBounds): void { + expect(actual.min[0]).toBe(expected.min[0]); + expect(actual.min[1]).toBe(expected.min[1]); + expect(actual.center[0]).toBe(expected.center[0]); + expect(actual.center[1]).toBe(expected.center[1]); + expect(actual.max[0]).toBe(expected.max[0]); + expect(actual.max[1]).toBe(expected.max[1]); + } +} + +describe("Deriving wall locations", () => { + it("should generate walls around a single tile", () => { + let room = { + id: -1, + datacenterId: -1, + name: "testroom", + roomType: "none", + tiles: [{ + id: -1, + roomId: -1, + position: {x: 1, y: 1} + }] + }; + + let result = Util.deriveWallLocations([ + room + ]); + let expected: IRoomWall[] = [ + { + startPos: [1, 1], + horizontal: false, + length: 1 + }, + { + startPos: [2, 1], + horizontal: false, + length: 1 + }, + { + startPos: [1, 1], + horizontal: true, + length: 1 + }, + { + startPos: [1, 2], + horizontal: true, + length: 1 + } + ]; + + TestUtils.wallListEquals(expected, result); + } + ); + + it("should generate walls around two tiles connected by an edge", () => { + let room = { + id: -1, + datacenterId: -1, + name: "testroom", + roomType: "none", + tiles: [ + { + id: -1, + roomId: -1, + position: {x: 1, y: 1} + }, { + id: -1, + roomId: -1, + position: {x: 1, y: 2} + } + ] + }; + + let result = Util.deriveWallLocations([ + room + ]); + let expected: IRoomWall[] = [ + { + startPos: [1, 1], + horizontal: false, + length: 2 + }, + { + startPos: [2, 1], + horizontal: false, + length: 2 + }, + { + startPos: [1, 1], + horizontal: true, + length: 1 + }, + { + startPos: [1, 3], + horizontal: true, + length: 1 + } + ]; + + TestUtils.wallListEquals(expected, result); + } + ); + + it("should generate walls around two independent rooms with one tile each", () => { + let room1 = { + id: -1, + datacenterId: -1, + name: "testroom", + roomType: "none", + tiles: [ + { + id: -1, + roomId: -1, + position: {x: 1, y: 1} + } + ] + }; + + let room2 = { + id: -1, + datacenterId: -1, + name: "testroom", + roomType: "none", + tiles: [{ + id: -1, + roomId: -1, + position: {x: 1, y: 3} + } + ] + }; + + let result = Util.deriveWallLocations([ + room1, room2 + ]); + let expected: IRoomWall[] = [ + { + startPos: [1, 1], + horizontal: false, + length: 1 + }, + { + startPos: [1, 3], + horizontal: false, + length: 1 + }, + { + startPos: [2, 1], + horizontal: false, + length: 1 + }, + { + startPos: [2, 3], + horizontal: false, + length: 1 + }, + { + startPos: [1, 1], + horizontal: true, + length: 1 + }, + { + startPos: [1, 2], + horizontal: true, + length: 1 + }, + { + startPos: [1, 3], + horizontal: true, + length: 1 + }, + { + startPos: [1, 4], + horizontal: true, + length: 1 + } + ]; + + TestUtils.wallListEquals(expected, result); + } + ); +}); + +describe("Deriving valid next tile positions", () => { + it("should derive correctly 4 valid tile positions around 1 selected tile with no other rooms", () => { + let result = Util.deriveValidNextTilePositions([], [{ + id: -1, + roomId: -1, + position: {x: 1, y: 1} + }]); + let expected = [ + {x: 1, y: 0}, {x: 2, y: 1}, {x: 1, y: 2}, {x: 0, y: 1} + ]; + + TestUtils.positionListEquals(expected, result); + }); + + it("should derive correctly 6 valid tile positions around 2 selected tiles with no other rooms", () => { + let result = Util.deriveValidNextTilePositions([], [{ + id: -1, + roomId: -1, + position: {x: 1, y: 1} + }, { + id: -1, + roomId: -1, + position: {x: 2, y: 1} + }]); + let expected = [ + {x: 1, y: 0}, {x: 2, y: 0}, {x: 3, y: 1}, {x: 1, y: 2}, {x: 2, y: 2}, {x: 0, y: 1} + ]; + + TestUtils.positionListEquals(expected, result); + }); + + it("should derive correctly 3 valid tile positions around 1 selected tiles with 1 adjacent room", () => { + let room = { + id: -1, + datacenterId: -1, + name: "testroom", + roomType: "none", + tiles: [{ + id: -1, + roomId: -1, + position: {x: 0, y: 1} + }] + }; + let result = Util.deriveValidNextTilePositions([room], [{ + id: -1, + roomId: -1, + position: {x: 1, y: 1} + }]); + let expected = [ + {x: 1, y: 0}, {x: 2, y: 1}, {x: 1, y: 2} + ]; + + TestUtils.positionListEquals(expected, result); + }); +}); + +describe("Calculating the bounds and average point of a list of rooms", () => { + it("should calculate correctly the bounds of a 1-tile room", () => { + let room = { + id: -1, + datacenterId: -1, + name: "testroom", + roomType: "none", + tiles: [{ + id: -1, + roomId: -1, + position: {x: 1, y: 1} + }] + }; + let result = Util.calculateRoomListBounds([room]); + let expected = { + min: [1, 1], + center: [1.5, 1.5], + max: [2, 2] + }; + + TestUtils.boundsEquals(result, expected); + }); +}); |