#include "tileset/TileMap.h"
#include "unittest/TestSuite.h"
#include <stdio.h>

static void assertTilesClear(TileMap * tileMap, TileID tileID, unsigned int line) {
	unsigned int tileCount = tileMap->width * tileMap->height;
	for (unsigned int tileIndex = 0; tileIndex < tileCount; tileIndex++) {
		if (tileMap->tiles[tileIndex] != tileID) {
			TestCase_assert(false, "TileID mismatch on line %u, at %u, %u; expected all to be %u, but found %u", line, tileIndex / tileMap->width, tileIndex % tileMap->width, tileID, tileMap->tiles[tileIndex]);
		}
	}
	TestCase_assert(true, NULL);
}

static void printTiles(const TileID * tiles, unsigned int width, unsigned int height) {
	for (unsigned int rowIndex = 0; rowIndex < height; rowIndex++) {
		fprintf(stderr, "  ");
		for (unsigned int columnIndex = 0; columnIndex < width; columnIndex++) {
			fprintf(stderr, "%u ", tiles[rowIndex * width + columnIndex]);
		}
		fputc('\n', stderr);
	}
}

static void assertTilesEqual(TileMap * tileMap, const TileID * expectedTiles, unsigned int line) {
	unsigned int width = tileMap->width;
	unsigned int height = tileMap->height;
	for (unsigned int rowIndex = 0; rowIndex < height; rowIndex++) {
		for (unsigned int columnIndex = 0; columnIndex < width; columnIndex++) {
			if (tileMap->tiles[rowIndex * width + columnIndex] != expectedTiles[rowIndex * width + columnIndex]) {
				fprintf(stderr, "Expected tiles:\n");
				printTiles(expectedTiles, width, height);
				fprintf(stderr, "Actual tiles:\n");
				printTiles(tileMap->tiles, width, height);
				TestCase_assert(false, "Tile data mismatch at %u, %u (line %u)", columnIndex, rowIndex, line);
				return;
			}
		}
	}
	TestCase_assert(true, NULL);
}

static void testCreate(void) {
	TileMap * tileMap = TileMap_create(1, 1);
	TestCase_assertPointerNonNULL(tileMap);
	TestCase_assertUIntEqual(tileMap->width, 1);
	TestCase_assertUIntEqual(tileMap->height, 1);
	assertTilesClear(tileMap, 0, __LINE__);
	TileMap_dispose(tileMap);
	
	tileMap = TileMap_create(2, 3);
	TestCase_assertPointerNonNULL(tileMap);
	TestCase_assertUIntEqual(tileMap->width, 2);
	TestCase_assertUIntEqual(tileMap->height, 3);
	assertTilesClear(tileMap, 0, __LINE__);
	TileMap_dispose(tileMap);
	
	TileID tiles[] = {
		1, 2,
		3, 4,
		5, 6
	};
	tileMap = TileMap_createWithTiles(2, 3, tiles);
	TestCase_assertPointerNonNULL(tileMap);
	TestCase_assertUIntEqual(tileMap->width, 2);
	TestCase_assertUIntEqual(tileMap->height, 3);
	assertTilesEqual(tileMap, tiles, __LINE__);
	TileMap_dispose(tileMap);
}

static void testCopy(void) {
	TileMap * tileMap = TileMap_create(1, 1);
	TileMap * copy = TileMap_copy(tileMap);
	TestCase_assertPointerNonNULL(copy);
	TestCase_assertPointerUnequal(copy, tileMap);
	TestCase_assertUIntEqual(copy->width, tileMap->width);
	TestCase_assertUIntEqual(copy->height, tileMap->height);
	TestCase_assertUIntEqual(copy->tiles[0], tileMap->tiles[0]);
	TileMap_dispose(copy);
	TileMap_dispose(tileMap);
	
	TileID tiles[] = {
		1, 2,
		3, 4,
		5, 6
	};
	tileMap = TileMap_createWithTiles(2, 3, tiles);
	copy = TileMap_copy(tileMap);
	TestCase_assertPointerNonNULL(copy);
	TestCase_assertPointerUnequal(copy, tileMap);
	TestCase_assertUIntEqual(copy->width, tileMap->width);
	TestCase_assertUIntEqual(copy->height, tileMap->height);
	assertTilesEqual(copy, tiles, __LINE__);
	TileMap_dispose(copy);
	TileMap_dispose(tileMap);
}

static void testLoadString(void) {
	TileMapStringKeyEntry key[] = {
		{'a', 1},
		{'b', 2},
		{'c', 4}
	};
	TileMap * tileMap = TileMap_loadString("", 0, 0, NULL, 0);
	TestCase_assertPointerNonNULL(tileMap);
	TestCase_assertUIntEqual(tileMap->width, 0);
	TestCase_assertUIntEqual(tileMap->height, 0);
	TileMap_dispose(tileMap);
	
	tileMap = TileMap_loadString("", 3, 2, NULL, 0);
	TestCase_assertPointerNonNULL(tileMap);
	TestCase_assertUIntEqual(tileMap->width, 3);
	TestCase_assertUIntEqual(tileMap->height, 2);
	TestCase_assertUIntEqual(tileMap->tiles[0], 0);
	TestCase_assertUIntEqual(tileMap->tiles[1], 0);
	TestCase_assertUIntEqual(tileMap->tiles[2], 0);
	TestCase_assertUIntEqual(tileMap->tiles[3], 0);
	TestCase_assertUIntEqual(tileMap->tiles[4], 0);
	TestCase_assertUIntEqual(tileMap->tiles[5], 0);
	TileMap_dispose(tileMap);
	
	tileMap = TileMap_loadString("abc", 0, 0, NULL, 0);
	TestCase_assertPointerNonNULL(tileMap);
	TestCase_assertUIntEqual(tileMap->width, 3);
	TestCase_assertUIntEqual(tileMap->height, 1);
	TestCase_assertUIntEqual(tileMap->tiles[0], 0);
	TestCase_assertUIntEqual(tileMap->tiles[1], 0);
	TestCase_assertUIntEqual(tileMap->tiles[2], 0);
	TileMap_dispose(tileMap);
	
	tileMap = TileMap_loadString("abc", 0, 0, key, sizeof(key) / sizeof(key[0]));
	TestCase_assertPointerNonNULL(tileMap);
	TestCase_assertUIntEqual(tileMap->width, 3);
	TestCase_assertUIntEqual(tileMap->height, 1);
	TestCase_assertUIntEqual(tileMap->tiles[0], 1);
	TestCase_assertUIntEqual(tileMap->tiles[1], 2);
	TestCase_assertUIntEqual(tileMap->tiles[2], 4);
	TileMap_dispose(tileMap);
	
	tileMap = TileMap_loadString("abc", 4, 2, key, sizeof(key) / sizeof(key[0]));
	TestCase_assertPointerNonNULL(tileMap);
	TestCase_assertUIntEqual(tileMap->width, 4);
	TestCase_assertUIntEqual(tileMap->height, 2);
	TestCase_assertUIntEqual(tileMap->tiles[0], 1);
	TestCase_assertUIntEqual(tileMap->tiles[1], 2);
	TestCase_assertUIntEqual(tileMap->tiles[2], 4);
	TestCase_assertUIntEqual(tileMap->tiles[3], 0);
	TestCase_assertUIntEqual(tileMap->tiles[4], 0);
	TestCase_assertUIntEqual(tileMap->tiles[5], 0);
	TestCase_assertUIntEqual(tileMap->tiles[6], 0);
	TestCase_assertUIntEqual(tileMap->tiles[7], 0);
	TileMap_dispose(tileMap);
	
	tileMap = TileMap_loadString(" a\nbca\nb ", 0, 0, key, sizeof(key) / sizeof(key[0]));
	TestCase_assertPointerNonNULL(tileMap);
	TestCase_assertUIntEqual(tileMap->width, 3);
	TestCase_assertUIntEqual(tileMap->height, 3);
	TestCase_assertUIntEqual(tileMap->tiles[0], 0);
	TestCase_assertUIntEqual(tileMap->tiles[1], 1);
	TestCase_assertUIntEqual(tileMap->tiles[2], 0);
	TestCase_assertUIntEqual(tileMap->tiles[3], 2);
	TestCase_assertUIntEqual(tileMap->tiles[4], 4);
	TestCase_assertUIntEqual(tileMap->tiles[5], 1);
	TestCase_assertUIntEqual(tileMap->tiles[6], 2);
	TestCase_assertUIntEqual(tileMap->tiles[7], 0);
	TestCase_assertUIntEqual(tileMap->tiles[8], 0);
	TileMap_dispose(tileMap);
	
	tileMap = TileMap_loadString(" a\nbca\nb ", 2, 2, key, sizeof(key) / sizeof(key[0]));
	TestCase_assertPointerNonNULL(tileMap);
	TestCase_assertUIntEqual(tileMap->width, 2);
	TestCase_assertUIntEqual(tileMap->height, 2);
	TestCase_assertUIntEqual(tileMap->tiles[0], 0);
	TestCase_assertUIntEqual(tileMap->tiles[1], 1);
	TestCase_assertUIntEqual(tileMap->tiles[2], 2);
	TestCase_assertUIntEqual(tileMap->tiles[3], 4);
	TileMap_dispose(tileMap);
	
	tileMap = TileMap_loadString(" a\nbca\nb ", 4, 4, key, sizeof(key) / sizeof(key[0]));
	TestCase_assertPointerNonNULL(tileMap);
	TestCase_assertUIntEqual(tileMap->width, 4);
	TestCase_assertUIntEqual(tileMap->height, 4);
	TestCase_assertUIntEqual(tileMap->tiles[0], 0);
	TestCase_assertUIntEqual(tileMap->tiles[1], 1);
	TestCase_assertUIntEqual(tileMap->tiles[2], 0);
	TestCase_assertUIntEqual(tileMap->tiles[3], 0);
	TestCase_assertUIntEqual(tileMap->tiles[4], 2);
	TestCase_assertUIntEqual(tileMap->tiles[5], 4);
	TestCase_assertUIntEqual(tileMap->tiles[6], 1);
	TestCase_assertUIntEqual(tileMap->tiles[7], 0);
	TestCase_assertUIntEqual(tileMap->tiles[8], 2);
	TestCase_assertUIntEqual(tileMap->tiles[9], 0);
	TestCase_assertUIntEqual(tileMap->tiles[10], 0);
	TestCase_assertUIntEqual(tileMap->tiles[11], 0);
	TestCase_assertUIntEqual(tileMap->tiles[12], 0);
	TestCase_assertUIntEqual(tileMap->tiles[13], 0);
	TestCase_assertUIntEqual(tileMap->tiles[14], 0);
	TestCase_assertUIntEqual(tileMap->tiles[15], 0);
	TileMap_dispose(tileMap);
}

static void testLoadRGB(void) {
	TileMapColorKeyEntry key1[] = {
		{0xFF, 0x00, 0x00, 1},
		{0x00, 0xFF, 0x00, 2},
		{0x00, 0x00, 0x7F, 4}
	};
	TileMap * tileMap = TileMap_loadRGB(NULL, 0, 0, NULL, 0);
	TestCase_assertPointerNonNULL(tileMap);
	TestCase_assertUIntEqual(tileMap->width, 0);
	TestCase_assertUIntEqual(tileMap->height, 0);
	TileMap_dispose(tileMap);
	
	uint8_t image1[] = {
		0x00,0x00,0x00, 0xFF,0x00,0x00,
		0x00,0x00,0x7F, 0x00,0xFF,0x00
	};
	tileMap = TileMap_loadRGB(image1, 2, 2, key1, sizeof(key1) / sizeof(key1[0]));
	TestCase_assertPointerNonNULL(tileMap);
	TestCase_assertUIntEqual(tileMap->width, 2);
	TestCase_assertUIntEqual(tileMap->height, 2);
	TestCase_assertUIntEqual(tileMap->tiles[0], 0);
	TestCase_assertUIntEqual(tileMap->tiles[1], 1);
	TestCase_assertUIntEqual(tileMap->tiles[2], 4);
	TestCase_assertUIntEqual(tileMap->tiles[3], 2);
	TileMap_dispose(tileMap);
	
	uint8_t image2[] = {
		0xFF,0x00,0xFF, 0xFF,0x00,0x00, 0x7F,0x7F,0x7F,
		0x00,0xFF,0x00, 0xFF,0xFF,0xFF, 0x00,0x00,0x7F,
		0xFF,0x00,0xFF, 0xFF,0x00,0x00, 0xFF,0x00,0xFF
	};
	tileMap = TileMap_loadRGB(image2, 3, 3, key1, sizeof(key1) / sizeof(key1[0]));
	TestCase_assertPointerNonNULL(tileMap);
	TestCase_assertUIntEqual(tileMap->width, 3);
	TestCase_assertUIntEqual(tileMap->height, 3);
	TestCase_assertUIntEqual(tileMap->tiles[0], 0);
	TestCase_assertUIntEqual(tileMap->tiles[1], 1);
	TestCase_assertUIntEqual(tileMap->tiles[2], 0);
	TestCase_assertUIntEqual(tileMap->tiles[3], 2);
	TestCase_assertUIntEqual(tileMap->tiles[4], 0);
	TestCase_assertUIntEqual(tileMap->tiles[5], 4);
	TestCase_assertUIntEqual(tileMap->tiles[6], 0);
	TestCase_assertUIntEqual(tileMap->tiles[7], 1);
	TestCase_assertUIntEqual(tileMap->tiles[8], 0);
	TileMap_dispose(tileMap);
	
	TileMapColorKeyEntry key2[] = {
		{0xFF, 0x00, 0xFF, 3},
		{0xFF, 0xFF, 0xFF, 5},
		{0x7F, 0x7F, 0x7F, 7}
	};
	tileMap = TileMap_loadRGB(image2, 3, 3, key2, sizeof(key2) / sizeof(key2[0]));
	TestCase_assertPointerNonNULL(tileMap);
	TestCase_assertUIntEqual(tileMap->width, 3);
	TestCase_assertUIntEqual(tileMap->height, 3);
	TestCase_assertUIntEqual(tileMap->tiles[0], 3);
	TestCase_assertUIntEqual(tileMap->tiles[1], 0);
	TestCase_assertUIntEqual(tileMap->tiles[2], 7);
	TestCase_assertUIntEqual(tileMap->tiles[3], 0);
	TestCase_assertUIntEqual(tileMap->tiles[4], 5);
	TestCase_assertUIntEqual(tileMap->tiles[5], 0);
	TestCase_assertUIntEqual(tileMap->tiles[6], 3);
	TestCase_assertUIntEqual(tileMap->tiles[7], 0);
	TestCase_assertUIntEqual(tileMap->tiles[8], 3);
	TileMap_dispose(tileMap);
}

static void testWriteString(void) {
	TileMap * tileMap = TileMap_create(2, 3);
	tileMap->tiles[0] = 5;
	tileMap->tiles[1] = 3;
	tileMap->tiles[2] = 1;
	tileMap->tiles[3] = 0;
	tileMap->tiles[4] = 4;
	tileMap->tiles[5] = 5;
	
	TileMapStringKeyEntry key1[] = {
		{'A', 5},
		{'B', 3},
		{'C', 4}
	};
	char result[9];
	memset(result, 0x00, sizeof(result));
	TileMap_writeString(tileMap, result, key1, sizeof(key1) / sizeof(key1[0]), ' ');
	TestCase_assertStringEqual(result, "AB\n  \nCA");
	
	memset(result, 0x00, sizeof(result));
	TileMap_writeString(tileMap, result, key1, sizeof(key1) / sizeof(key1[0]), '*');
	TestCase_assertStringEqual(result, "AB\n**\nCA");
	
	TileMapStringKeyEntry key2[] = {
		{'1', 1},
		{'2', 2},
		{'3', 3},
		{'4', 4},
		{'5', 5}
	};
	memset(result, 0x00, sizeof(result));
	TileMap_writeString(tileMap, result, key2, sizeof(key2) / sizeof(key2[0]), '.');
	TestCase_assertStringEqual(result, "53\n1.\n45");
	
	tileMap->width = 3;
	tileMap->height = 2;
	memset(result, 0x00, sizeof(result));
	TileMap_writeString(tileMap, result, key2, sizeof(key2) / sizeof(key2[0]), '.');
	TestCase_assertStringEqual(result, "531\n.45");
}

static void testWriteRGB(void) {
	TileMap * tileMap = TileMap_create(2, 3);
	tileMap->tiles[0] = 5;
	tileMap->tiles[1] = 3;
	tileMap->tiles[2] = 1;
	tileMap->tiles[3] = 0;
	tileMap->tiles[4] = 4;
	tileMap->tiles[5] = 5;
	
	TileMapColorKeyEntry key1[] = {
		{0xFF, 0x00, 0x00, 5},
		{0x00, 0xFF, 0x00, 3},
		{0x00, 0x00, 0xFF, 4}
	};
	uint8_t result[18];
	memset(result, 0x00, sizeof(result));
	TileMap_writeRGB(tileMap, result, key1, sizeof(key1) / sizeof(key1[0]), 0x11, 0x22, 0x33);
	TestCase_assertUIntEqual(result[0],  0xFF);
	TestCase_assertUIntEqual(result[1],  0x00);
	TestCase_assertUIntEqual(result[2],  0x00);
	TestCase_assertUIntEqual(result[3],  0x00);
	TestCase_assertUIntEqual(result[4],  0xFF);
	TestCase_assertUIntEqual(result[5],  0x00);
	TestCase_assertUIntEqual(result[6],  0x11);
	TestCase_assertUIntEqual(result[7],  0x22);
	TestCase_assertUIntEqual(result[8],  0x33);
	TestCase_assertUIntEqual(result[9],  0x11);
	TestCase_assertUIntEqual(result[10], 0x22);
	TestCase_assertUIntEqual(result[11], 0x33);
	TestCase_assertUIntEqual(result[12], 0x00);
	TestCase_assertUIntEqual(result[13], 0x00);
	TestCase_assertUIntEqual(result[14], 0xFF);
	TestCase_assertUIntEqual(result[15], 0xFF);
	TestCase_assertUIntEqual(result[16], 0x00);
	TestCase_assertUIntEqual(result[17], 0x00);
	
	memset(result, 0x00, sizeof(result));
	TileMap_writeRGB(tileMap, result, key1, sizeof(key1) / sizeof(key1[0]), 0xAB, 0xCD, 0xEF);
	TestCase_assertUIntEqual(result[0],  0xFF);
	TestCase_assertUIntEqual(result[1],  0x00);
	TestCase_assertUIntEqual(result[2],  0x00);
	TestCase_assertUIntEqual(result[3],  0x00);
	TestCase_assertUIntEqual(result[4],  0xFF);
	TestCase_assertUIntEqual(result[5],  0x00);
	TestCase_assertUIntEqual(result[6],  0xAB);
	TestCase_assertUIntEqual(result[7],  0xCD);
	TestCase_assertUIntEqual(result[8],  0xEF);
	TestCase_assertUIntEqual(result[9],  0xAB);
	TestCase_assertUIntEqual(result[10], 0xCD);
	TestCase_assertUIntEqual(result[11], 0xEF);
	TestCase_assertUIntEqual(result[12], 0x00);
	TestCase_assertUIntEqual(result[13], 0x00);
	TestCase_assertUIntEqual(result[14], 0xFF);
	TestCase_assertUIntEqual(result[15], 0xFF);
	TestCase_assertUIntEqual(result[16], 0x00);
	TestCase_assertUIntEqual(result[17], 0x00);
	
	TileMapColorKeyEntry key2[] = {
		{0x01, 0x01, 0x01, 1},
		{0x02, 0x02, 0x02, 2},
		{0x03, 0x03, 0x03, 3},
		{0x04, 0x04, 0x04, 4},
		{0x05, 0x05, 0x05, 5}
	};
	memset(result, 0x00, sizeof(result));
	TileMap_writeRGB(tileMap, result, key2, sizeof(key2) / sizeof(key2[0]), 0x00, 0x00, 0x00);
	TestCase_assertUIntEqual(result[0],  0x05);
	TestCase_assertUIntEqual(result[1],  0x05);
	TestCase_assertUIntEqual(result[2],  0x05);
	TestCase_assertUIntEqual(result[3],  0x03);
	TestCase_assertUIntEqual(result[4],  0x03);
	TestCase_assertUIntEqual(result[5],  0x03);
	TestCase_assertUIntEqual(result[6],  0x01);
	TestCase_assertUIntEqual(result[7],  0x01);
	TestCase_assertUIntEqual(result[8],  0x01);
	TestCase_assertUIntEqual(result[9],  0x00);
	TestCase_assertUIntEqual(result[10], 0x00);
	TestCase_assertUIntEqual(result[11], 0x00);
	TestCase_assertUIntEqual(result[12], 0x04);
	TestCase_assertUIntEqual(result[13], 0x04);
	TestCase_assertUIntEqual(result[14], 0x04);
	TestCase_assertUIntEqual(result[15], 0x05);
	TestCase_assertUIntEqual(result[16], 0x05);
	TestCase_assertUIntEqual(result[17], 0x05);
}

static void testCalculateAdjacency4(void) {
	TileMap * tileMap = TileMap_create(2, 2);
	tileMap->tiles[0] = 1;
	TileAdjacency4 adjacency[4];
	TileAdjacencyKeyEntry key[] = {
		{1, 1, 1, false},
		{1, 2, 2, false},
		{2, 1, 3, false}
	};
	
	memset(adjacency, 0xFF, sizeof(adjacency));
	TileMap_calculateAdjacency4(tileMap, adjacency, key, sizeof(key) / sizeof(key[0]));
	TestCase_assertUIntEqual(adjacency[0].left, 0);
	TestCase_assertUIntEqual(adjacency[0].right, 0);
	TestCase_assertUIntEqual(adjacency[0].top, 0);
	TestCase_assertUIntEqual(adjacency[0].bottom, 0);
	TestCase_assertUIntEqual(adjacency[1].left, 0);
	TestCase_assertUIntEqual(adjacency[1].right, 0);
	TestCase_assertUIntEqual(adjacency[1].top, 0);
	TestCase_assertUIntEqual(adjacency[1].bottom, 0);
	TestCase_assertUIntEqual(adjacency[2].left, 0);
	TestCase_assertUIntEqual(adjacency[2].right, 0);
	TestCase_assertUIntEqual(adjacency[2].top, 0);
	TestCase_assertUIntEqual(adjacency[2].bottom, 0);
	TestCase_assertUIntEqual(adjacency[3].left, 0);
	TestCase_assertUIntEqual(adjacency[3].right, 0);
	TestCase_assertUIntEqual(adjacency[3].top, 0);
	TestCase_assertUIntEqual(adjacency[3].bottom, 0);
	
	tileMap->tiles[1] = 1;
	TileMap_calculateAdjacency4(tileMap, adjacency, key, sizeof(key) / sizeof(key[0]));
	TestCase_assertUIntEqual(adjacency[0].left, 0);
	TestCase_assertUIntEqual(adjacency[0].right, 1);
	TestCase_assertUIntEqual(adjacency[0].top, 0);
	TestCase_assertUIntEqual(adjacency[0].bottom, 0);
	TestCase_assertUIntEqual(adjacency[1].left, 1);
	TestCase_assertUIntEqual(adjacency[1].right, 0);
	TestCase_assertUIntEqual(adjacency[1].top, 0);
	TestCase_assertUIntEqual(adjacency[1].bottom, 0);
	TestCase_assertUIntEqual(adjacency[2].left, 0);
	TestCase_assertUIntEqual(adjacency[2].right, 0);
	TestCase_assertUIntEqual(adjacency[2].top, 0);
	TestCase_assertUIntEqual(adjacency[2].bottom, 0);
	TestCase_assertUIntEqual(adjacency[3].left, 0);
	TestCase_assertUIntEqual(adjacency[3].right, 0);
	TestCase_assertUIntEqual(adjacency[3].top, 0);
	TestCase_assertUIntEqual(adjacency[3].bottom, 0);
	
	tileMap->tiles[2] = 2;
	TileMap_calculateAdjacency4(tileMap, adjacency, key, sizeof(key) / sizeof(key[0]));
	TestCase_assertUIntEqual(adjacency[0].left, 0);
	TestCase_assertUIntEqual(adjacency[0].right, 1);
	TestCase_assertUIntEqual(adjacency[0].top, 0);
	TestCase_assertUIntEqual(adjacency[0].bottom, 2);
	TestCase_assertUIntEqual(adjacency[1].left, 1);
	TestCase_assertUIntEqual(adjacency[1].right, 0);
	TestCase_assertUIntEqual(adjacency[1].top, 0);
	TestCase_assertUIntEqual(adjacency[1].bottom, 0);
	TestCase_assertUIntEqual(adjacency[2].left, 0);
	TestCase_assertUIntEqual(adjacency[2].right, 0);
	TestCase_assertUIntEqual(adjacency[2].top, 3);
	TestCase_assertUIntEqual(adjacency[2].bottom, 0);
	TestCase_assertUIntEqual(adjacency[3].left, 0);
	TestCase_assertUIntEqual(adjacency[3].right, 0);
	TestCase_assertUIntEqual(adjacency[3].top, 0);
	TestCase_assertUIntEqual(adjacency[3].bottom, 0);
	
	tileMap->tiles[3] = 1;
	TileMap_calculateAdjacency4(tileMap, adjacency, key, sizeof(key) / sizeof(key[0]));
	TestCase_assertUIntEqual(adjacency[0].left, 0);
	TestCase_assertUIntEqual(adjacency[0].right, 1);
	TestCase_assertUIntEqual(adjacency[0].top, 0);
	TestCase_assertUIntEqual(adjacency[0].bottom, 2);
	TestCase_assertUIntEqual(adjacency[1].left, 1);
	TestCase_assertUIntEqual(adjacency[1].right, 0);
	TestCase_assertUIntEqual(adjacency[1].top, 0);
	TestCase_assertUIntEqual(adjacency[1].bottom, 1);
	TestCase_assertUIntEqual(adjacency[2].left, 0);
	TestCase_assertUIntEqual(adjacency[2].right, 3);
	TestCase_assertUIntEqual(adjacency[2].top, 3);
	TestCase_assertUIntEqual(adjacency[2].bottom, 0);
	TestCase_assertUIntEqual(adjacency[3].left, 2);
	TestCase_assertUIntEqual(adjacency[3].right, 0);
	TestCase_assertUIntEqual(adjacency[3].top, 1);
	TestCase_assertUIntEqual(adjacency[3].bottom, 0);
	
	TileMap_calculateAdjacency4(tileMap, adjacency, key, 1);
	TestCase_assertUIntEqual(adjacency[0].left, 0);
	TestCase_assertUIntEqual(adjacency[0].right, 1);
	TestCase_assertUIntEqual(adjacency[0].top, 0);
	TestCase_assertUIntEqual(adjacency[0].bottom, 0);
	TestCase_assertUIntEqual(adjacency[1].left, 1);
	TestCase_assertUIntEqual(adjacency[1].right, 0);
	TestCase_assertUIntEqual(adjacency[1].top, 0);
	TestCase_assertUIntEqual(adjacency[1].bottom, 1);
	TestCase_assertUIntEqual(adjacency[2].left, 0);
	TestCase_assertUIntEqual(adjacency[2].right, 0);
	TestCase_assertUIntEqual(adjacency[2].top, 0);
	TestCase_assertUIntEqual(adjacency[2].bottom, 0);
	TestCase_assertUIntEqual(adjacency[3].left, 0);
	TestCase_assertUIntEqual(adjacency[3].right, 0);
	TestCase_assertUIntEqual(adjacency[3].top, 1);
	TestCase_assertUIntEqual(adjacency[3].bottom, 0);
	
	key[0].assignAtEdges = true;
	TileMap_calculateAdjacency4(tileMap, adjacency, key, sizeof(key) / sizeof(key[0]));
	TestCase_assertUIntEqual(adjacency[0].left, 1);
	TestCase_assertUIntEqual(adjacency[0].right, 1);
	TestCase_assertUIntEqual(adjacency[0].top, 1);
	TestCase_assertUIntEqual(adjacency[0].bottom, 2);
	TestCase_assertUIntEqual(adjacency[1].left, 1);
	TestCase_assertUIntEqual(adjacency[1].right, 1);
	TestCase_assertUIntEqual(adjacency[1].top, 1);
	TestCase_assertUIntEqual(adjacency[1].bottom, 1);
	TestCase_assertUIntEqual(adjacency[2].left, 0);
	TestCase_assertUIntEqual(adjacency[2].right, 3);
	TestCase_assertUIntEqual(adjacency[2].top, 3);
	TestCase_assertUIntEqual(adjacency[2].bottom, 0);
	TestCase_assertUIntEqual(adjacency[3].left, 2);
	TestCase_assertUIntEqual(adjacency[3].right, 1);
	TestCase_assertUIntEqual(adjacency[3].top, 1);
	TestCase_assertUIntEqual(adjacency[3].bottom, 1);
}

static void testCalculateAdjacency8(void) {
	TileMap * tileMap = TileMap_create(2, 2);
	tileMap->tiles[0] = 1;
	TileAdjacency8 adjacency[4];
	TileAdjacencyKeyEntry key[] = {
		{1, 1, 1, false},
		{1, 2, 2, false},
		{2, 1, 3, false}
	};
	
	memset(adjacency, 0xFF, sizeof(adjacency));
	TileMap_calculateAdjacency8(tileMap, adjacency, key, sizeof(key) / sizeof(key[0]));
	TestCase_assertUIntEqual(adjacency[0].topLeft, 0);
	TestCase_assertUIntEqual(adjacency[0].top, 0);
	TestCase_assertUIntEqual(adjacency[0].topRight, 0);
	TestCase_assertUIntEqual(adjacency[0].left, 0);
	TestCase_assertUIntEqual(adjacency[0].right, 0);
	TestCase_assertUIntEqual(adjacency[0].bottomLeft, 0);
	TestCase_assertUIntEqual(adjacency[0].bottom, 0);
	TestCase_assertUIntEqual(adjacency[0].bottomRight, 0);
	TestCase_assertUIntEqual(adjacency[1].topLeft, 0);
	TestCase_assertUIntEqual(adjacency[1].top, 0);
	TestCase_assertUIntEqual(adjacency[1].topRight, 0);
	TestCase_assertUIntEqual(adjacency[1].left, 0);
	TestCase_assertUIntEqual(adjacency[1].right, 0);
	TestCase_assertUIntEqual(adjacency[1].bottomLeft, 0);
	TestCase_assertUIntEqual(adjacency[1].bottom, 0);
	TestCase_assertUIntEqual(adjacency[1].bottomRight, 0);
	TestCase_assertUIntEqual(adjacency[2].topLeft, 0);
	TestCase_assertUIntEqual(adjacency[2].top, 0);
	TestCase_assertUIntEqual(adjacency[2].topRight, 0);
	TestCase_assertUIntEqual(adjacency[2].left, 0);
	TestCase_assertUIntEqual(adjacency[2].right, 0);
	TestCase_assertUIntEqual(adjacency[2].bottomLeft, 0);
	TestCase_assertUIntEqual(adjacency[2].bottom, 0);
	TestCase_assertUIntEqual(adjacency[2].bottomRight, 0);
	TestCase_assertUIntEqual(adjacency[3].topLeft, 0);
	TestCase_assertUIntEqual(adjacency[3].top, 0);
	TestCase_assertUIntEqual(adjacency[3].topRight, 0);
	TestCase_assertUIntEqual(adjacency[3].left, 0);
	TestCase_assertUIntEqual(adjacency[3].right, 0);
	TestCase_assertUIntEqual(adjacency[3].bottomLeft, 0);
	TestCase_assertUIntEqual(adjacency[3].bottom, 0);
	TestCase_assertUIntEqual(adjacency[3].bottomRight, 0);
	
	tileMap->tiles[1] = 1;
	TileMap_calculateAdjacency8(tileMap, adjacency, key, sizeof(key) / sizeof(key[0]));
	TestCase_assertUIntEqual(adjacency[0].topLeft, 0);
	TestCase_assertUIntEqual(adjacency[0].top, 0);
	TestCase_assertUIntEqual(adjacency[0].topRight, 0);
	TestCase_assertUIntEqual(adjacency[0].left, 0);
	TestCase_assertUIntEqual(adjacency[0].right, 1);
	TestCase_assertUIntEqual(adjacency[0].bottomLeft, 0);
	TestCase_assertUIntEqual(adjacency[0].bottom, 0);
	TestCase_assertUIntEqual(adjacency[0].bottomRight, 0);
	TestCase_assertUIntEqual(adjacency[1].topLeft, 0);
	TestCase_assertUIntEqual(adjacency[1].top, 0);
	TestCase_assertUIntEqual(adjacency[1].topRight, 0);
	TestCase_assertUIntEqual(adjacency[1].left, 1);
	TestCase_assertUIntEqual(adjacency[1].right, 0);
	TestCase_assertUIntEqual(adjacency[1].bottomLeft, 0);
	TestCase_assertUIntEqual(adjacency[1].bottom, 0);
	TestCase_assertUIntEqual(adjacency[1].bottomRight, 0);
	TestCase_assertUIntEqual(adjacency[2].topLeft, 0);
	TestCase_assertUIntEqual(adjacency[2].top, 0);
	TestCase_assertUIntEqual(adjacency[2].topRight, 0);
	TestCase_assertUIntEqual(adjacency[2].left, 0);
	TestCase_assertUIntEqual(adjacency[2].right, 0);
	TestCase_assertUIntEqual(adjacency[2].bottomLeft, 0);
	TestCase_assertUIntEqual(adjacency[2].bottom, 0);
	TestCase_assertUIntEqual(adjacency[2].bottomRight, 0);
	TestCase_assertUIntEqual(adjacency[3].topLeft, 0);
	TestCase_assertUIntEqual(adjacency[3].top, 0);
	TestCase_assertUIntEqual(adjacency[3].topRight, 0);
	TestCase_assertUIntEqual(adjacency[3].left, 0);
	TestCase_assertUIntEqual(adjacency[3].right, 0);
	TestCase_assertUIntEqual(adjacency[3].bottomLeft, 0);
	TestCase_assertUIntEqual(adjacency[3].bottom, 0);
	TestCase_assertUIntEqual(adjacency[3].bottomRight, 0);
	
	tileMap->tiles[2] = 2;
	TileMap_calculateAdjacency8(tileMap, adjacency, key, sizeof(key) / sizeof(key[0]));
	TestCase_assertUIntEqual(adjacency[0].topLeft, 0);
	TestCase_assertUIntEqual(adjacency[0].top, 0);
	TestCase_assertUIntEqual(adjacency[0].topRight, 0);
	TestCase_assertUIntEqual(adjacency[0].left, 0);
	TestCase_assertUIntEqual(adjacency[0].right, 1);
	TestCase_assertUIntEqual(adjacency[0].bottomLeft, 0);
	TestCase_assertUIntEqual(adjacency[0].bottom, 2);
	TestCase_assertUIntEqual(adjacency[0].bottomRight, 0);
	TestCase_assertUIntEqual(adjacency[1].topLeft, 0);
	TestCase_assertUIntEqual(adjacency[1].top, 0);
	TestCase_assertUIntEqual(adjacency[1].topRight, 0);
	TestCase_assertUIntEqual(adjacency[1].left, 1);
	TestCase_assertUIntEqual(adjacency[1].right, 0);
	TestCase_assertUIntEqual(adjacency[1].bottomLeft, 2);
	TestCase_assertUIntEqual(adjacency[1].bottom, 0);
	TestCase_assertUIntEqual(adjacency[1].bottomRight, 0);
	TestCase_assertUIntEqual(adjacency[2].topLeft, 0);
	TestCase_assertUIntEqual(adjacency[2].top, 3);
	TestCase_assertUIntEqual(adjacency[2].topRight, 3);
	TestCase_assertUIntEqual(adjacency[2].left, 0);
	TestCase_assertUIntEqual(adjacency[2].right, 0);
	TestCase_assertUIntEqual(adjacency[2].bottomLeft, 0);
	TestCase_assertUIntEqual(adjacency[2].bottom, 0);
	TestCase_assertUIntEqual(adjacency[2].bottomRight, 0);
	TestCase_assertUIntEqual(adjacency[3].topLeft, 0);
	TestCase_assertUIntEqual(adjacency[3].top, 0);
	TestCase_assertUIntEqual(adjacency[3].topRight, 0);
	TestCase_assertUIntEqual(adjacency[3].left, 0);
	TestCase_assertUIntEqual(adjacency[3].right, 0);
	TestCase_assertUIntEqual(adjacency[3].bottomLeft, 0);
	TestCase_assertUIntEqual(adjacency[3].bottom, 0);
	TestCase_assertUIntEqual(adjacency[3].bottomRight, 0);
	
	tileMap->tiles[3] = 1;
	TileMap_calculateAdjacency8(tileMap, adjacency, key, sizeof(key) / sizeof(key[0]));
	TestCase_assertUIntEqual(adjacency[0].topLeft, 0);
	TestCase_assertUIntEqual(adjacency[0].top, 0);
	TestCase_assertUIntEqual(adjacency[0].topRight, 0);
	TestCase_assertUIntEqual(adjacency[0].left, 0);
	TestCase_assertUIntEqual(adjacency[0].right, 1);
	TestCase_assertUIntEqual(adjacency[0].bottomLeft, 0);
	TestCase_assertUIntEqual(adjacency[0].bottom, 2);
	TestCase_assertUIntEqual(adjacency[0].bottomRight, 1);
	TestCase_assertUIntEqual(adjacency[1].topLeft, 0);
	TestCase_assertUIntEqual(adjacency[1].top, 0);
	TestCase_assertUIntEqual(adjacency[1].topRight, 0);
	TestCase_assertUIntEqual(adjacency[1].left, 1);
	TestCase_assertUIntEqual(adjacency[1].right, 0);
	TestCase_assertUIntEqual(adjacency[1].bottomLeft, 2);
	TestCase_assertUIntEqual(adjacency[1].bottom, 1);
	TestCase_assertUIntEqual(adjacency[1].bottomRight, 0);
	TestCase_assertUIntEqual(adjacency[2].topLeft, 0);
	TestCase_assertUIntEqual(adjacency[2].top, 3);
	TestCase_assertUIntEqual(adjacency[2].topRight, 3);
	TestCase_assertUIntEqual(adjacency[2].left, 0);
	TestCase_assertUIntEqual(adjacency[2].right, 3);
	TestCase_assertUIntEqual(adjacency[2].bottomLeft, 0);
	TestCase_assertUIntEqual(adjacency[2].bottom, 0);
	TestCase_assertUIntEqual(adjacency[2].bottomRight, 0);
	TestCase_assertUIntEqual(adjacency[3].topLeft, 1);
	TestCase_assertUIntEqual(adjacency[3].top, 1);
	TestCase_assertUIntEqual(adjacency[3].topRight, 0);
	TestCase_assertUIntEqual(adjacency[3].left, 2);
	TestCase_assertUIntEqual(adjacency[3].right, 0);
	TestCase_assertUIntEqual(adjacency[3].bottomLeft, 0);
	TestCase_assertUIntEqual(adjacency[3].bottom, 0);
	TestCase_assertUIntEqual(adjacency[3].bottomRight, 0);
	
	TileMap_calculateAdjacency8(tileMap, adjacency, key, 1);
	TestCase_assertUIntEqual(adjacency[0].topLeft, 0);
	TestCase_assertUIntEqual(adjacency[0].top, 0);
	TestCase_assertUIntEqual(adjacency[0].topRight, 0);
	TestCase_assertUIntEqual(adjacency[0].left, 0);
	TestCase_assertUIntEqual(adjacency[0].right, 1);
	TestCase_assertUIntEqual(adjacency[0].bottomLeft, 0);
	TestCase_assertUIntEqual(adjacency[0].bottom, 0);
	TestCase_assertUIntEqual(adjacency[0].bottomRight, 1);
	TestCase_assertUIntEqual(adjacency[1].topLeft, 0);
	TestCase_assertUIntEqual(adjacency[1].top, 0);
	TestCase_assertUIntEqual(adjacency[1].topRight, 0);
	TestCase_assertUIntEqual(adjacency[1].left, 1);
	TestCase_assertUIntEqual(adjacency[1].right, 0);
	TestCase_assertUIntEqual(adjacency[1].bottomLeft, 0);
	TestCase_assertUIntEqual(adjacency[1].bottom, 1);
	TestCase_assertUIntEqual(adjacency[1].bottomRight, 0);
	TestCase_assertUIntEqual(adjacency[2].topLeft, 0);
	TestCase_assertUIntEqual(adjacency[2].top, 0);
	TestCase_assertUIntEqual(adjacency[2].topRight, 0);
	TestCase_assertUIntEqual(adjacency[2].left, 0);
	TestCase_assertUIntEqual(adjacency[2].right, 0);
	TestCase_assertUIntEqual(adjacency[2].bottomLeft, 0);
	TestCase_assertUIntEqual(adjacency[2].bottom, 0);
	TestCase_assertUIntEqual(adjacency[2].bottomRight, 0);
	TestCase_assertUIntEqual(adjacency[3].topLeft, 1);
	TestCase_assertUIntEqual(adjacency[3].top, 1);
	TestCase_assertUIntEqual(adjacency[3].topRight, 0);
	TestCase_assertUIntEqual(adjacency[3].left, 0);
	TestCase_assertUIntEqual(adjacency[3].right, 0);
	TestCase_assertUIntEqual(adjacency[3].bottomLeft, 0);
	TestCase_assertUIntEqual(adjacency[3].bottom, 0);
	TestCase_assertUIntEqual(adjacency[3].bottomRight, 0);
	
	key[0].assignAtEdges = true;
	TileMap_calculateAdjacency8(tileMap, adjacency, key, sizeof(key) / sizeof(key[0]));
	TestCase_assertUIntEqual(adjacency[0].topLeft, 1);
	TestCase_assertUIntEqual(adjacency[0].top, 1);
	TestCase_assertUIntEqual(adjacency[0].topRight, 1);
	TestCase_assertUIntEqual(adjacency[0].left, 1);
	TestCase_assertUIntEqual(adjacency[0].right, 1);
	TestCase_assertUIntEqual(adjacency[0].bottomLeft, 1);
	TestCase_assertUIntEqual(adjacency[0].bottom, 2);
	TestCase_assertUIntEqual(adjacency[0].bottomRight, 1);
	TestCase_assertUIntEqual(adjacency[1].topLeft, 1);
	TestCase_assertUIntEqual(adjacency[1].top, 1);
	TestCase_assertUIntEqual(adjacency[1].topRight, 1);
	TestCase_assertUIntEqual(adjacency[1].left, 1);
	TestCase_assertUIntEqual(adjacency[1].right, 1);
	TestCase_assertUIntEqual(adjacency[1].bottomLeft, 2);
	TestCase_assertUIntEqual(adjacency[1].bottom, 1);
	TestCase_assertUIntEqual(adjacency[1].bottomRight, 1);
	TestCase_assertUIntEqual(adjacency[2].topLeft, 0);
	TestCase_assertUIntEqual(adjacency[2].top, 3);
	TestCase_assertUIntEqual(adjacency[2].topRight, 3);
	TestCase_assertUIntEqual(adjacency[2].left, 0);
	TestCase_assertUIntEqual(adjacency[2].right, 3);
	TestCase_assertUIntEqual(adjacency[2].bottomLeft, 0);
	TestCase_assertUIntEqual(adjacency[2].bottom, 0);
	TestCase_assertUIntEqual(adjacency[2].bottomRight, 0);
	TestCase_assertUIntEqual(adjacency[3].topLeft, 1);
	TestCase_assertUIntEqual(adjacency[3].top, 1);
	TestCase_assertUIntEqual(adjacency[3].topRight, 1);
	TestCase_assertUIntEqual(adjacency[3].left, 2);
	TestCase_assertUIntEqual(adjacency[3].right, 1);
	TestCase_assertUIntEqual(adjacency[3].bottomLeft, 1);
	TestCase_assertUIntEqual(adjacency[3].bottom, 1);
	TestCase_assertUIntEqual(adjacency[3].bottomRight, 1);
}

static void testApplyAutoTile(void) {
	TileID tiles[] = {0, 1, 1,
		                1, 1, 2,
		                1, 1, 1};
	TileMap * tileMap = TileMap_createWithTiles(3, 3, tiles);
	AutoTileRule rules[] = {
		{1, 3, {TILE_ID_INVALID, 1, TILE_ID_INVALID, TILE_ID_INVALID, TILE_ID_INVALID, TILE_ID_INVALID, TILE_ID_INVALID, TILE_ID_INVALID}, 0}
	};
	AutoTileRuleset ruleset = {1, rules};
	TileMap * tileMap2 = TileMap_create(3, 3);
	
	TileMap_applyAutoTile(tileMap2, tileMap, &ruleset);
	TestCase_assertUIntEqual(tileMap2->tiles[0], 0);
	TestCase_assertUIntEqual(tileMap2->tiles[1], 1);
	TestCase_assertUIntEqual(tileMap2->tiles[2], 1);
	TestCase_assertUIntEqual(tileMap2->tiles[3], 1);
	TestCase_assertUIntEqual(tileMap2->tiles[4], 3);
	TestCase_assertUIntEqual(tileMap2->tiles[5], 2);
	TestCase_assertUIntEqual(tileMap2->tiles[6], 3);
	TestCase_assertUIntEqual(tileMap2->tiles[7], 3);
	TestCase_assertUIntEqual(tileMap2->tiles[8], 1);
	
	rules[0].options = AUTO_TILE_OPTION_EDGE_IS_MATCH;
	TileMap_applyAutoTile(tileMap2, tileMap, &ruleset);
	TestCase_assertUIntEqual(tileMap2->tiles[0], 0);
	TestCase_assertUIntEqual(tileMap2->tiles[1], 3);
	TestCase_assertUIntEqual(tileMap2->tiles[2], 3);
	TestCase_assertUIntEqual(tileMap2->tiles[3], 1);
	TestCase_assertUIntEqual(tileMap2->tiles[4], 3);
	TestCase_assertUIntEqual(tileMap2->tiles[5], 2);
	TestCase_assertUIntEqual(tileMap2->tiles[6], 3);
	TestCase_assertUIntEqual(tileMap2->tiles[7], 3);
	TestCase_assertUIntEqual(tileMap2->tiles[8], 1);
	
	rules[0].options = AUTO_TILE_OPTION_ZERO_IS_MATCH;
	TileMap_applyAutoTile(tileMap2, tileMap, &ruleset);
	TestCase_assertUIntEqual(tileMap2->tiles[0], 0);
	TestCase_assertUIntEqual(tileMap2->tiles[1], 1);
	TestCase_assertUIntEqual(tileMap2->tiles[2], 1);
	TestCase_assertUIntEqual(tileMap2->tiles[3], 3);
	TestCase_assertUIntEqual(tileMap2->tiles[4], 3);
	TestCase_assertUIntEqual(tileMap2->tiles[5], 2);
	TestCase_assertUIntEqual(tileMap2->tiles[6], 3);
	TestCase_assertUIntEqual(tileMap2->tiles[7], 3);
	TestCase_assertUIntEqual(tileMap2->tiles[8], 1);
	
	rules[0].options = AUTO_TILE_OPTION_NEGATIVE;
	TileMap_applyAutoTile(tileMap2, tileMap, &ruleset);
	TestCase_assertUIntEqual(tileMap2->tiles[0], 0);
	TestCase_assertUIntEqual(tileMap2->tiles[1], 3);
	TestCase_assertUIntEqual(tileMap2->tiles[2], 3);
	TestCase_assertUIntEqual(tileMap2->tiles[3], 3);
	TestCase_assertUIntEqual(tileMap2->tiles[4], 1);
	TestCase_assertUIntEqual(tileMap2->tiles[5], 2);
	TestCase_assertUIntEqual(tileMap2->tiles[6], 1);
	TestCase_assertUIntEqual(tileMap2->tiles[7], 1);
	TestCase_assertUIntEqual(tileMap2->tiles[8], 3);
	
	rules[0].options = AUTO_TILE_OPTION_EDGE_IS_MATCH | AUTO_TILE_OPTION_ZERO_IS_MATCH;
	TileMap_applyAutoTile(tileMap2, tileMap, &ruleset);
	TestCase_assertUIntEqual(tileMap2->tiles[0], 0);
	TestCase_assertUIntEqual(tileMap2->tiles[1], 3);
	TestCase_assertUIntEqual(tileMap2->tiles[2], 3);
	TestCase_assertUIntEqual(tileMap2->tiles[3], 3);
	TestCase_assertUIntEqual(tileMap2->tiles[4], 3);
	TestCase_assertUIntEqual(tileMap2->tiles[5], 2);
	TestCase_assertUIntEqual(tileMap2->tiles[6], 3);
	TestCase_assertUIntEqual(tileMap2->tiles[7], 3);
	TestCase_assertUIntEqual(tileMap2->tiles[8], 1);
	
	rules[0].options = AUTO_TILE_OPTION_EDGE_IS_MATCH | AUTO_TILE_OPTION_NEGATIVE;
	TileMap_applyAutoTile(tileMap2, tileMap, &ruleset);
	TestCase_assertUIntEqual(tileMap2->tiles[0], 0);
	TestCase_assertUIntEqual(tileMap2->tiles[1], 1);
	TestCase_assertUIntEqual(tileMap2->tiles[2], 1);
	TestCase_assertUIntEqual(tileMap2->tiles[3], 3);
	TestCase_assertUIntEqual(tileMap2->tiles[4], 1);
	TestCase_assertUIntEqual(tileMap2->tiles[5], 2);
	TestCase_assertUIntEqual(tileMap2->tiles[6], 1);
	TestCase_assertUIntEqual(tileMap2->tiles[7], 1);
	TestCase_assertUIntEqual(tileMap2->tiles[8], 3);
	
	rules[0].options = AUTO_TILE_OPTION_ZERO_IS_MATCH | AUTO_TILE_OPTION_NEGATIVE;
	TileMap_applyAutoTile(tileMap2, tileMap, &ruleset);
	TestCase_assertUIntEqual(tileMap2->tiles[0], 0);
	TestCase_assertUIntEqual(tileMap2->tiles[1], 3);
	TestCase_assertUIntEqual(tileMap2->tiles[2], 3);
	TestCase_assertUIntEqual(tileMap2->tiles[3], 1);
	TestCase_assertUIntEqual(tileMap2->tiles[4], 1);
	TestCase_assertUIntEqual(tileMap2->tiles[5], 2);
	TestCase_assertUIntEqual(tileMap2->tiles[6], 1);
	TestCase_assertUIntEqual(tileMap2->tiles[7], 1);
	TestCase_assertUIntEqual(tileMap2->tiles[8], 3);
	
	rules[0].options = AUTO_TILE_OPTION_EDGE_IS_MATCH | AUTO_TILE_OPTION_ZERO_IS_MATCH | AUTO_TILE_OPTION_NEGATIVE;
	TileMap_applyAutoTile(tileMap2, tileMap, &ruleset);
	TestCase_assertUIntEqual(tileMap2->tiles[0], 0);
	TestCase_assertUIntEqual(tileMap2->tiles[1], 1);
	TestCase_assertUIntEqual(tileMap2->tiles[2], 1);
	TestCase_assertUIntEqual(tileMap2->tiles[3], 1);
	TestCase_assertUIntEqual(tileMap2->tiles[4], 1);
	TestCase_assertUIntEqual(tileMap2->tiles[5], 2);
	TestCase_assertUIntEqual(tileMap2->tiles[6], 1);
	TestCase_assertUIntEqual(tileMap2->tiles[7], 1);
	TestCase_assertUIntEqual(tileMap2->tiles[8], 3);
	
	// TODO: Test in-place transformation, other directions than north, multiple rules (priority), corners and edges
}

static void testClear(void) {
	TileMap * tileMap = TileMap_create(2, 2);
	TileMap_clear(tileMap, 1);
	assertTilesClear(tileMap, 1, __LINE__);
	TileMap_clear(tileMap, 2);
	assertTilesClear(tileMap, 2, __LINE__);
	TileMap_dispose(tileMap);
}

static void testCopyTiles(void) {
	TileID sourceTiles[] = {
		1, 2, 3,
		4, 5, 6,
		7, 8, 9
	};
	TileID expectedTiles1[] = {
		0, 0, 0,
		0, 0, 0,
		0, 1, 2
	};
	TileID expectedTiles2[] = {
		5, 6, 0,
		8, 9, 0,
		0, 1, 2
	};
	TileID expectedTiles3[] = {
		1, 2, 0,
		4, 5, 0,
		0, 0, 0
	};
	TileID expectedTiles4[] = {
		0, 0, 0,
		2, 3, 0,
		5, 6, 0
	};
	TileID expectedTiles5[] = {
		0, 0, 0,
		0, 1, 0,
		0, 0, 0
	};
	
	TileMap * source = TileMap_createWithTiles(3, 3, sourceTiles);
	TileMap * target = TileMap_create(3, 3);
	
	TileMap_copyTiles(target, source, 0, 0, 0, 0, 3, 3);
	assertTilesEqual(target, sourceTiles, __LINE__);
	
	TileMap_clear(target, 0);
	TileMap_copyTiles(target, source, 0, 0, 1, 2, 3, 3);
	assertTilesEqual(target, expectedTiles1, __LINE__);
	
	TileMap_copyTiles(target, source, 1, 1, 0, 0, 3, 3);
	assertTilesEqual(target, expectedTiles2, __LINE__);
	
	TileMap_clear(target, 0);
	TileMap_copyTiles(target, source, 0, 0, 0, 0, 2, 2);
	assertTilesEqual(target, expectedTiles3, __LINE__);
	
	TileMap_clear(target, 0);
	TileMap_copyTiles(target, source, 0, 0, -1, 1, 3, 3);
	assertTilesEqual(target, expectedTiles4, __LINE__);
	
	TileMap_clear(target, 0);
	TileMap_copyTiles(target, source, -1, -1, 0, 0, 2, 2);
	assertTilesEqual(target, expectedTiles5, __LINE__);
	
	TileMap_dispose(target);
	TileMap_dispose(source);
}

TEST_SUITE(TileMapTest,
           testCreate,
           testCopy,
           testLoadString,
           testLoadRGB,
           testWriteString,
           testWriteRGB,
           testCalculateAdjacency4,
           testCalculateAdjacency8,
           testApplyAutoTile,
           testClear,
           testCopyTiles)