diff --git a/src/JTABLES.cpp b/src/JTABLES.cpp
new file mode 100644
index 0000000..0033c2b
--- /dev/null
+++ b/src/JTABLES.cpp
@@ -0,0 +1,286 @@
+#include <aspeed/JTABLES.H>
+
+static unsigned char zigzag[64] = {
+    0,  1,  5,  6,  14, 15, 27, 28, 2,  4,  7,  13, 16, 26, 29, 42,
+    3,  8,  12, 17, 25, 30, 41, 43, 9,  11, 18, 24, 31, 40, 44, 53,
+    10, 19, 23, 32, 39, 45, 52, 54, 20, 22, 33, 38, 46, 51, 55, 60,
+    21, 34, 37, 47, 50, 56, 59, 61, 35, 36, 48, 49, 57, 58, 62, 63};
+
+static unsigned char dezigzag[64 + 15] = {
+    0, 1, 8, 16, 9, 2, 3, 10, 17, 24, 32, 25, 18, 11, 4, 5, 12, 19, 26, 33, 40,
+    48, 41, 34, 27, 20, 13, 6, 7, 14, 21, 28, 35, 42, 49, 56, 57, 50, 43, 36,
+    29, 22, 15, 23, 30, 37, 44, 51, 58, 59, 52, 45, 38, 31, 39, 46, 53, 60, 61,
+    54, 47, 55, 62, 63,
+    // let corrupt input sample past end
+    63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63, 63};
+
+static unsigned char *std_luminance_qt;
+static unsigned char *std_chrominance_qt;
+
+// Standard Huffman tables (cf. JPEG standard section K.3) */
+
+static unsigned char std_dc_luminance_nrcodes[17] = {0, 0, 1, 5, 1, 1, 1, 1, 1,
+                                                     1, 0, 0, 0, 0, 0, 0, 0};
+static unsigned char std_dc_luminance_values[12] = {0, 1, 2, 3, 4,  5,
+                                                    6, 7, 8, 9, 10, 11};
+
+static unsigned char std_dc_chrominance_nrcodes[17] = {
+    0, 0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0};
+static unsigned char std_dc_chrominance_values[12] = {0, 1, 2, 3, 4,  5,
+                                                      6, 7, 8, 9, 10, 11};
+
+static unsigned char std_ac_luminance_nrcodes[17] = {
+    0, 0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d};
+static unsigned char std_ac_luminance_values[162] = {
+    0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12, 0x21, 0x31, 0x41, 0x06,
+    0x13, 0x51, 0x61, 0x07, 0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
+    0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0, 0x24, 0x33, 0x62, 0x72,
+    0x82, 0x09, 0x0a, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
+    0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x43, 0x44, 0x45,
+    0x46, 0x47, 0x48, 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
+    0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x73, 0x74, 0x75,
+    0x76, 0x77, 0x78, 0x79, 0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
+    0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3,
+    0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
+    0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9,
+    0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
+    0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf1, 0xf2, 0xf3, 0xf4,
+    0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa};
+
+static unsigned char std_ac_chrominance_nrcodes[17] = {
+    0, 0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77};
+static unsigned char std_ac_chrominance_values[162] = {
+    0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21, 0x31, 0x06, 0x12, 0x41,
+    0x51, 0x07, 0x61, 0x71, 0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
+    0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0, 0x15, 0x62, 0x72, 0xd1,
+    0x0a, 0x16, 0x24, 0x34, 0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
+    0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x43, 0x44,
+    0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
+    0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x73, 0x74,
+    0x75, 0x76, 0x77, 0x78, 0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
+    0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a,
+    0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
+    0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7,
+    0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
+    0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xf2, 0xf3, 0xf4,
+    0xf5, 0xf6, 0xf7, 0xf8, 0xf9, 0xfa};
+
+unsigned short int DC_LUMINANCE_HUFFMANCODE[13 * 2] = {
+    /* 0 */ 0x0000,  0,
+    /* 1 */ 0x4000,  2,
+    /* 2 */ 0x6000,  3,
+    /* 3 */ 0x8000,  3,
+    /* 4 */ 0xA000,  3,
+    /* 5 */ 0xC000,  3,
+    /* 6 */ 0xE000,  3,
+    /* 7 */ 0xF000,  4,
+    /* 8 */ 0xF800,  5,
+    /* 9 */ 0xFC00,  6,
+    /* 10 */ 0xFE00, 7,
+    /* 11 */ 0xFF00, 8,
+    /* 12 */ 0xFFFF, 9,
+};
+
+unsigned short int DC_CHROMINANCE_HUFFMANCODE[13 * 2] = {
+    /* 0 */ 0x0000,  0,
+    /* 1 */ 0x4000,  2,
+    /* 2 */ 0x8000,  2,
+    /* 3 */ 0xC000,  2,
+    /* 4 */ 0xE000,  3,
+    /* 5 */ 0xF000,  4,
+    /* 6 */ 0xF800,  5,
+    /* 7 */ 0xFC00,  6,
+    /* 8 */ 0xFE00,  7,
+    /* 9 */ 0xFF00,  8,
+    /* 10 */ 0xFF80, 9,
+    /* 11 */ 0xFFC0, 10,
+    /* 12 */ 0xFFFF, 11,
+};
+
+unsigned short int AC_LUMINANCE_HUFFMANCODE[39 * 2] = {
+    /* 0 */ 0x0000,  0,
+    /* 1 */ 0x4000,  2,
+    /* 2 */ 0x8000,  2,
+    /* 3 */ 0xA000,  3,
+    /* 4 */ 0xB000,  4,
+    /* 5 */ 0xC000,  4,
+    /* 6 */ 0xD000,  4,
+    /* 7 */ 0xD800,  5,
+    /* 8 */ 0xE000,  5,
+    /* 9 */ 0xE800,  5,
+    /* 10 */ 0xEC00, 6,
+    /* 11 */ 0xF000, 6,
+    /* 12 */ 0xF200, 7,
+    /* 13 */ 0xF400, 7,
+    /* 14 */ 0xF600, 7,
+    /* 15 */ 0xF800, 7,
+    /* 16 */ 0xF900, 8,
+    /* 17 */ 0xFA00, 8,
+    /* 18 */ 0xFB00, 8,
+    /* 19 */ 0xFB80, 9,
+    /* 20 */ 0xFC00, 9,
+    /* 21 */ 0xFC80, 9,
+    /* 22 */ 0xFD00, 9,
+    /* 23 */ 0xFD80, 9,
+    /* 24 */ 0xFDC0, 10,
+    /* 25 */ 0xFE00, 10,
+    /* 26 */ 0xFE40, 10,
+    /* 27 */ 0xFE80, 10,
+    /* 28 */ 0xFEC0, 10,
+    /* 29 */ 0xFEE0, 11,
+    /* 30 */ 0xFF00, 11,
+    /* 31 */ 0xFF20, 11,
+    /* 32 */ 0xFF40, 11,
+    /* 33 */ 0xFF50, 12,
+    /* 34 */ 0xFF60, 12,
+    /* 35 */ 0xFF70, 12,
+    /* 36 */ 0xFF80, 12,
+    /* 37 */ 0xFF82, 15,
+    /* 38 */ 0xFFFF, 16,
+};
+
+unsigned short int AC_CHROMINANCE_HUFFMANCODE[45 * 2] = {
+    /* 0 */ 0x0000,  0,
+    /* 1 */ 0x4000,  2,
+    /* 2 */ 0x8000,  2,
+    /* 3 */ 0xA000,  3,
+    /* 4 */ 0xB000,  4,
+    /* 5 */ 0xC000,  4,
+    /* 6 */ 0xC800,  5,
+    /* 7 */ 0xD000,  5,
+    /* 8 */ 0xD800,  5,
+    /* 9 */ 0xE000,  5,
+    /* 10 */ 0xE400, 6,
+    /* 11 */ 0xE800, 6,
+    /* 12 */ 0xEC00, 6,
+    /* 13 */ 0xF000, 6,
+    /* 14 */ 0xF200, 7,
+    /* 15 */ 0xF400, 7,
+    /* 16 */ 0xF600, 7,
+    /* 17 */ 0xF700, 8,
+    /* 18 */ 0xF800, 8,
+    /* 19 */ 0xF900, 8,
+    /* 20 */ 0xFA00, 8,
+    /* 21 */ 0xFA80, 9,
+    /* 22 */ 0xFB00, 9,
+    /* 23 */ 0xFB80, 9,
+    /* 24 */ 0xFC00, 9,
+    /* 25 */ 0xFC80, 9,
+    /* 26 */ 0xFD00, 9,
+    /* 27 */ 0xFD80, 9,
+    /* 28 */ 0xFDC0, 10,
+    /* 29 */ 0xFE00, 10,
+    /* 30 */ 0xFE40, 10,
+    /* 31 */ 0xFE80, 10,
+    /* 32 */ 0xFEC0, 10,
+    /* 33 */ 0xFEE0, 11,
+    /* 34 */ 0xFF00, 11,
+    /* 35 */ 0xFF20, 11,
+    /* 36 */ 0xFF40, 11,
+    /* 37 */ 0xFF50, 12,
+    /* 38 */ 0xFF60, 12,
+    /* 39 */ 0xFF70, 12,
+    /* 40 */ 0xFF80, 12,
+    /* 41 */ 0xFF84, 14,
+    /* 42 */ 0xFF86, 15,
+    /* 43 */ 0xFF88, 15,
+    /* 44 */ 0xFFFF, 16,
+};
+
+//[100]=========================
+static unsigned char Tbl_100Y[64] = {
+    2, 1, 1, 2,  3,  5,  6,  7,  1, 1,  1,  2,  3,  7,  7,  6,
+    1, 1, 2, 3,  5,  7,  8,  7,  1, 2,  2,  3,  6,  10, 10, 7,
+    2, 2, 4, 7,  8,  13, 12, 9,  3, 4,  6,  8,  10, 13, 14, 11,
+    6, 8, 9, 10, 12, 15, 15, 12, 9, 11, 11, 12, 14, 12, 12, 12};
+static unsigned char Tbl_100UV[64] = {
+    3,  3,  4,  8,  18, 18, 18, 18, 3,  3,  4,  12, 18, 18, 18, 18,
+    4,  4,  10, 18, 18, 18, 18, 18, 8,  12, 18, 18, 18, 18, 18, 18,
+    18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,
+    18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18};
+
+//[086]=========================
+static unsigned char Tbl_086Y[64] = {
+    3, 2,  1,  3,  4,  7,  9,  11, 2,  2,  2,  3,  4,  10, 11, 10,
+    2, 2,  3,  4,  7,  10, 12, 10, 2,  3,  4,  5,  9,  16, 15, 11,
+    3, 4,  6,  10, 12, 20, 19, 14, 4,  6,  10, 12, 15, 19, 21, 17,
+    9, 12, 14, 16, 19, 22, 22, 18, 13, 17, 17, 18, 21, 18, 19, 18};
+static unsigned char Tbl_086UV[64] = {
+    4,  5,  6,  13, 27, 27, 27, 27, 5,  5,  7,  18, 27, 27, 27, 27,
+    6,  7,  15, 27, 27, 27, 27, 27, 13, 18, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+    27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27};
+
+//[071]=========================
+static unsigned char Tbl_071Y[64] = {
+    6,  4,  3,  6,  9,  15, 19, 22, 4,  4,  5,  7,  9,  21, 22, 20,
+    5,  4,  6,  9,  15, 21, 25, 21, 5,  6,  8,  10, 19, 32, 30, 23,
+    6,  8,  13, 21, 25, 40, 38, 28, 9,  13, 20, 24, 30, 39, 42, 34,
+    18, 24, 29, 32, 38, 45, 45, 37, 27, 34, 35, 36, 42, 37, 38, 37};
+static unsigned char Tbl_071UV[64] = {
+    9,  10, 13, 26, 55, 55, 55, 55, 10, 11, 14, 37, 55, 55, 55, 55,
+    13, 14, 31, 55, 55, 55, 55, 55, 26, 37, 55, 55, 55, 55, 55, 55,
+    55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55,
+    55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55, 55};
+//[057]=========================
+static unsigned char Tbl_057Y[64] = {
+    9,  6,  5,  9,  13, 22, 28, 34, 6,  6,  7,  10, 14, 32, 33, 30,
+    7,  7,  9,  13, 22, 32, 38, 31, 7,  9,  12, 16, 28, 48, 45, 34,
+    10, 12, 20, 31, 38, 61, 57, 43, 13, 19, 30, 36, 45, 58, 63, 51,
+    27, 36, 43, 48, 57, 68, 67, 56, 40, 51, 53, 55, 63, 56, 57, 55};
+static unsigned char Tbl_057UV[64] = {
+    13, 14, 19, 38, 80, 80, 80, 80, 14, 17, 21, 53, 80, 80, 80, 80,
+    19, 21, 45, 80, 80, 80, 80, 80, 38, 53, 80, 80, 80, 80, 80, 80,
+    80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80,
+    80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80, 80};
+
+//[043]=========================
+static unsigned char Tbl_043Y[64] = {
+    11, 7,  7,  11, 17, 28, 36, 43, 8,  8,  10, 13, 18, 41, 43, 39,
+    10, 9,  11, 17, 28, 40, 49, 40, 10, 12, 15, 20, 36, 62, 57, 44,
+    12, 15, 26, 40, 48, 78, 74, 55, 17, 25, 39, 46, 58, 74, 81, 66,
+    35, 46, 56, 62, 74, 86, 86, 72, 51, 66, 68, 70, 80, 71, 74, 71};
+static unsigned char Tbl_043UV[64] = {
+    18,  19,  26,  51,  108, 108, 108, 108, 19,  22,  28,  72,  108,
+    108, 108, 108, 26,  28,  61,  108, 108, 108, 108, 108, 51,  72,
+    108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108,
+    108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108,
+    108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108, 108};
+
+//[029]=========================
+static unsigned char Tbl_029Y[64] = {
+    14, 9,  9,  14, 21, 36,  46,  55, 10, 10, 12, 17, 23,  52, 54,  49,
+    12, 11, 14, 21, 36, 51,  62,  50, 12, 15, 19, 26, 46,  78, 72,  56,
+    16, 19, 33, 50, 61, 98,  93,  69, 21, 31, 49, 58, 73,  94, 102, 83,
+    44, 58, 70, 78, 93, 109, 108, 91, 65, 83, 86, 88, 101, 90, 93,  89};
+static unsigned char Tbl_029UV[64] = {
+    22,  24,  32,  63,  133, 133, 133, 133, 24,  28,  34,  88,  133,
+    133, 133, 133, 32,  34,  75,  133, 133, 133, 133, 133, 63,  88,
+    133, 133, 133, 133, 133, 133, 133, 133, 133, 133, 133, 133, 133,
+    133, 133, 133, 133, 133, 133, 133, 133, 133, 133, 133, 133, 133,
+    133, 133, 133, 133, 133, 133, 133, 133, 133, 133, 133, 133};
+
+//[014]=========================
+static unsigned char Tbl_014Y[64] = {
+    17, 12, 10, 17, 26,  43,  55,  66,  13, 13,  15,  20,  28,  63,  65,  60,
+    15, 14, 17, 26, 43,  62,  75,  61,  15, 18,  24,  31,  55,  95,  87,  67,
+    19, 24, 40, 61, 74,  119, 112, 84,  26, 38,  60,  70,  88,  113, 123, 100,
+    53, 70, 85, 95, 112, 132, 131, 110, 78, 100, 103, 107, 122, 109, 112, 108};
+static unsigned char Tbl_014UV[64] = {
+    27,  29,  39,  76,  160, 160, 160, 160, 29,  34,  42,  107, 160,
+    160, 160, 160, 39,  42,  91,  160, 160, 160, 160, 160, 76,  107,
+    160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
+    160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160,
+    160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160, 160};
+//[000]=========================
+static unsigned char Tbl_000Y[64] = {
+    20, 13, 12, 20,  30,  50,  63,  76,  15, 15,  17,  23,  32,  72,  75,  68,
+    17, 16, 20, 30,  50,  71,  86,  70,  17, 21,  27,  36,  63,  108, 100, 77,
+    22, 27, 46, 70,  85,  136, 128, 96,  30, 43,  68,  80,  101, 130, 141, 115,
+    61, 80, 97, 108, 128, 151, 150, 126, 90, 115, 118, 122, 140, 125, 128, 123};
+static unsigned char Tbl_000UV[64] = {
+    31,  33,  45,  88,  185, 185, 185, 185, 33,  39,  48,  123, 185,
+    185, 185, 185, 45,  48,  105, 185, 185, 185, 185, 185, 88,  123,
+    185, 185, 185, 185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
+    185, 185, 185, 185, 185, 185, 185, 185, 185, 185, 185, 185, 185,
+    185, 185, 185, 185, 185, 185, 185, 185, 185, 185, 185, 185};
\ No newline at end of file
diff --git a/src/ast_jpeg_decoder_test.cpp b/src/ast_jpeg_decoder_test.cpp
index 5b9e769..22c9ecf 100644
--- a/src/ast_jpeg_decoder_test.cpp
+++ b/src/ast_jpeg_decoder_test.cpp
@@ -1,6 +1,6 @@
 #include "ast_jpeg_decoder.hpp"
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
 
 #ifdef BUILD_CIMG
 #define cimg_display 0
@@ -85,7 +85,7 @@
     }
   }
 }
-/*
+
 TEST(AstJpegDecoder, TestColors) {
   AstVideo::RawVideoBuffer out;
 
@@ -110,7 +110,7 @@
            out.uv_selector);
 
   int tolerance = 16;
-
+  /*
   for (int i = 0; i < out.width * out.height; i++) {
     AstVideo::RGB &pixel = d.OutBuffer[i];
     EXPECT_GT(pixel.R, 0x8E - tolerance);
@@ -120,8 +120,9 @@
     EXPECT_GT(pixel.B, 0xF1 - tolerance);
     EXPECT_LT(pixel.B, 0xF1 + tolerance);
   }
+  */
 }
-*/
+
 // Tests the buffers around the screen aren't written to
 TEST(AstJpegDecoder, BufferLimits) {
   AstVideo::RawVideoBuffer out;
diff --git a/src/ci_map_tests.cpp b/src/ci_map_tests.cpp
new file mode 100644
index 0000000..acaaa6e
--- /dev/null
+++ b/src/ci_map_tests.cpp
@@ -0,0 +1,78 @@
+#include "crow/ci_map.h"
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+using namespace testing;
+
+TEST(CiMap, MapEmpty) {
+  crow::ci_map map;
+  EXPECT_TRUE(map.empty());
+  EXPECT_EQ(map.size(), 0);
+
+  map.emplace("foo", "bar");
+
+  map.clear();
+  EXPECT_TRUE(map.empty());
+}
+
+TEST(CiMap, MapBasicInsert) {
+  crow::ci_map map;
+  map.emplace("foo", "bar");
+  auto x = map.find("foo");
+  ASSERT_NE(x, map.end());
+
+  EXPECT_EQ(map.find("foo")->first, "foo");
+  EXPECT_EQ(map.find("foo")->second, "bar");
+  EXPECT_EQ(map.find("FOO")->first, "foo");
+  EXPECT_EQ(map.find("FOO")->second, "bar");
+}
+
+TEST(CiMap, MapManyInsert) {
+  crow::ci_map map;
+  map.emplace("foo", "car");
+  map.emplace("foo", "boo");
+  map.emplace("bar", "cat");
+  map.emplace("baz", "bat");
+
+  EXPECT_EQ(map.size(), 3);
+  ASSERT_NE(map.find("foo"), map.end());
+  EXPECT_EQ(map.find("foo")->first, "foo");
+  EXPECT_EQ(map.find("foo")->second, "car");
+
+  ASSERT_NE(map.find("FOO"), map.end());
+  EXPECT_EQ(map.find("FOO")->first, "foo");
+  EXPECT_EQ(map.find("FOO")->second, "car");
+  
+  ASSERT_NE(map.find("bar"), map.end());
+  EXPECT_EQ(map.find("bar")->first, "bar");
+  EXPECT_EQ(map.find("bar")->second, "cat");
+
+  ASSERT_NE(map.find("BAR"), map.end());
+  EXPECT_EQ(map.find("BAR")->first, "bar");
+  EXPECT_EQ(map.find("BAR")->second, "cat");
+
+  ASSERT_NE(map.find("baz"), map.end());
+  EXPECT_EQ(map.find("baz")->first, "baz");
+  EXPECT_EQ(map.find("baz")->second, "bat");
+
+  ASSERT_NE(map.find("BAZ"), map.end());
+  EXPECT_EQ(map.find("BAZ")->first, "baz");
+  EXPECT_EQ(map.find("BAZ")->second, "bat");
+
+  EXPECT_EQ(map.count("foo"), 1);
+  EXPECT_EQ(map.count("bar"), 1);
+  EXPECT_EQ(map.count("baz"), 1);
+  EXPECT_EQ(map.count("FOO"), 1);
+  EXPECT_EQ(map.count("BAR"), 1);
+  EXPECT_EQ(map.count("BAZ"), 1);
+}
+
+TEST(CiMap, MapMultiInsert) {
+  crow::ci_map map;
+  map.emplace("foo", "bar1");
+  map.emplace("foo", "bar2");
+  EXPECT_EQ(map.count("foo"), 1);
+  EXPECT_EQ(map.count("FOO"), 1);
+  EXPECT_EQ(map.count("fOo"), 1);
+  EXPECT_EQ(map.count("FOo"), 1);
+}
\ No newline at end of file
diff --git a/src/crowtest/crow_unittest.cpp b/src/crow_test.cpp
similarity index 100%
rename from src/crowtest/crow_unittest.cpp
rename to src/crow_test.cpp
diff --git a/src/crowtest/about.txt b/src/crowtest/about.txt
deleted file mode 100644
index bd55fd1..0000000
--- a/src/crowtest/about.txt
+++ /dev/null
@@ -1 +0,0 @@
-This folder contains a port of the CROW unit tests, ported to google test to maek them easier to run
\ No newline at end of file
diff --git a/src/getvideo_main.cpp b/src/getvideo_main.cpp
index cd7f09c..8c92bd3 100644
--- a/src/getvideo_main.cpp
+++ b/src/getvideo_main.cpp
@@ -1,4 +1,3 @@
-
 #include <fcntl.h>
 #include <unistd.h>
 #include <chrono>
diff --git a/src/kvm_websocket_test.cpp b/src/kvm_websocket_test.cpp
new file mode 100644
index 0000000..d690305
--- /dev/null
+++ b/src/kvm_websocket_test.cpp
@@ -0,0 +1,102 @@
+#include <iostream>
+#include <sstream>
+#include <vector>
+#include "test_utils.hpp"
+#include "web_kvm.hpp"
+#include "crow.h"
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+using namespace crow;
+using namespace testing;
+
+// Tests static files are loaded correctly
+TEST(Kvm, BasicRfb) {
+  SimpleApp app;
+
+  crow::kvm::request_routes(app);
+  app.bindaddr("127.0.0.1").port(45451);
+  CROW_ROUTE(app, "/")([]() { return 200; });
+  auto _ = async(std::launch::async, [&] { app.run(); });
+  auto routes = app.get_routes();
+  asio::io_service is;
+
+  {
+    // Retry a couple of times waiting for the server to come up
+    // TODO(ed)  This is really unfortunate, and should use some form of mock
+    asio::ip::tcp::socket c(is);
+    for (int i = 0; i < 200; i++) {
+      try {
+        c.connect(asio::ip::tcp::endpoint(
+            asio::ip::address::from_string("127.0.0.1"), 45451));
+        c.close();
+        break;
+      } catch (std::exception e) {
+        // do nothing.  We expect this to fail while the server is starting up
+      }
+    }
+  }
+
+  // Get the websocket
+  std::string sendmsg =
+      ("GET /kvmws HTTP/1.1\r\n"
+       "Host: localhost:45451\r\n"
+       "Connection: Upgrade\r\n"
+       "Upgrade: websocket\r\n"
+       "Sec-WebSocket-Version: 13\r\n"
+       "Sec-WebSocket-Key: aLeGkmLPZmdv5tTyEpJ3jQ==\r\n"
+       "Sec-WebSocket-Extensions: permessage-deflate; "
+       "client_max_window_bits\r\n"
+       "Sec-WebSocket-Protocol: binary\r\n"
+       "\r\n");
+
+  asio::ip::tcp::socket socket(is);
+  socket.connect(asio::ip::tcp::endpoint(
+      asio::ip::address::from_string("127.0.0.1"), 45451));
+  socket.send(asio::buffer(sendmsg));
+
+  // Read the response status line. The response streambuf will automatically
+  // grow to accommodate the entire line. The growth may be limited by passing
+  // a maximum size to the streambuf constructor.
+  boost::asio::streambuf response;
+  boost::asio::read_until(socket, response, "\r\n");
+
+  // Check that response is OK.
+  std::istream response_stream(&response);
+  std::string http_response;
+  std::getline(response_stream, http_response);
+
+  EXPECT_EQ(http_response, "HTTP/1.1 101 Switching Protocols\r");
+
+  // Read the response headers, which are terminated by a blank line.
+  boost::asio::read_until(socket, response, "\r\n\r\n");
+
+  // Process the response headers.
+  std::string header;
+  std::vector<std::string> headers;
+  while (std::getline(response_stream, header) && header != "\r") {
+    headers.push_back(header);
+  }
+
+  EXPECT_THAT(headers, Contains("Upgrade: websocket\r"));
+  EXPECT_THAT(headers, Contains("Connection: Upgrade\r"));
+  EXPECT_THAT(headers, Contains("Sec-WebSocket-Protocol: binary\r"));
+  // TODO(ed) This is the result that it gives today.  Need to check websocket
+  // docs and make
+  // sure that this calclution is actually being done to spec
+  EXPECT_THAT(headers,
+              Contains("Sec-WebSocket-Accept: /CnDM3l79rIxniLNyxMryXbtLEU=\r"));
+  std::array<char, 13> rfb_open_string;
+
+  //
+  // socket.receive(rfb_open_string.data(), rfb_open_string.size());
+  boost::asio::read(socket, boost::asio::buffer(rfb_open_string));
+  auto open_string =
+      std::string(std::begin(rfb_open_string), std::end(rfb_open_string));
+  // Todo(ed) find out what the two characters at the end of the websocket
+  // stream are
+  open_string = open_string.substr(2);
+  EXPECT_EQ(open_string, "RFB 003.008");
+
+  app.stop();
+}
\ No newline at end of file
diff --git a/src/msan_test.cpp b/src/msan_test.cpp
index 047d3cf..9fcb9d5 100644
--- a/src/msan_test.cpp
+++ b/src/msan_test.cpp
@@ -1,5 +1,5 @@
-#include "gtest/gtest.h"
 #include <string>
+#include "gtest/gtest.h"
 
 TEST(MemorySanitizer, TestIsWorking) {
   std::string foo("foo");
diff --git a/src/security_headers_middleware.cpp b/src/security_headers_middleware.cpp
index bcaa87d..265cda7 100644
--- a/src/security_headers_middleware.cpp
+++ b/src/security_headers_middleware.cpp
@@ -2,19 +2,38 @@
 
 namespace crow {
 
+static const std::string strict_transport_security_key =
+    "Strict-Transport-Security";
+static const std::string strict_transport_security_value =
+    "max-age=31536000; includeSubdomains; preload";
+
+static const std::string ua_compatability_key = "X-UA-Compatible";
+static const std::string ua_compatability_value = "IE=11";
+
+static const std::string xframe_key = "X-Frame-Options";
+static const std::string xframe_value = "DENY";
+
+static const std::string xss_key = "X-XSS-Protection";
+static const std::string xss_value = "1; mode=block";
+
+static const std::string content_security_key = "X-Content-Security-Policy";
+static const std::string content_security_value = "default-src 'self'";
+
 void SecurityHeadersMiddleware::before_handle(crow::request& req, response& res,
                                               context& ctx) {}
 
 void SecurityHeadersMiddleware::after_handle(request& /*req*/, response& res,
                                              context& ctx) {
-  // TODO(ed) these should really check content types.  for example, X-UA-Compatible
-  // header doesn't make sense when retrieving a JSON or javascript file.  It doesn't
-  // hurt anything, it's just ugly.
-  res.set_header("Strict-Transport-Security",
-                 "max-age=31536000; includeSubdomains; preload");
-  res.set_header("X-UA-Compatible", "IE=11");
-  res.set_header("X-Frame-Options", "DENY");
-  res.set_header("X-XSS-Protection", "1; mode=block");
-  res.set_header("X-Content-Security-Policy", "default-src 'self'");
+  /*
+   TODO(ed) these should really check content types.  for example,
+   X-UA-Compatible header doesn't make sense when retrieving a JSON or
+   javascript file.  It doesn't hurt anything, it's just ugly.
+   */
+  res.add_header(strict_transport_security_key,
+                 strict_transport_security_value);
+  res.add_header(ua_compatability_key, ua_compatability_value);
+  res.add_header(xframe_key, xframe_value);
+  res.add_header(xss_key, xss_value);
+  res.add_header(content_security_key, content_security_value);
 }
 }
diff --git a/src/security_headers_middleware_test.cpp b/src/security_headers_middleware_test.cpp
index fc183e9..5045215 100644
--- a/src/security_headers_middleware_test.cpp
+++ b/src/security_headers_middleware_test.cpp
@@ -1,7 +1,7 @@
-#include <crow/app.h>
-#include <gmock/gmock.h>
 #include <security_headers_middleware.hpp>
-#include "gtest/gtest.h"
+#include <crow/app.h>
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
 
 using namespace crow;
 using namespace std;
diff --git a/src/test_utils.cpp b/src/test_utils.cpp
new file mode 100644
index 0000000..65ef721
--- /dev/null
+++ b/src/test_utils.cpp
@@ -0,0 +1,67 @@
+#include <zlib.h>
+#include <test_utils.hpp>
+#include <cstring>
+
+bool gzipInflate(const std::string& compressedBytes,
+                 std::string& uncompressedBytes) {
+  if (compressedBytes.size() == 0) {
+    uncompressedBytes = compressedBytes;
+    return true;
+  }
+
+  uncompressedBytes.clear();
+
+  unsigned full_length = compressedBytes.size();
+  unsigned half_length = compressedBytes.size() / 2;
+
+  unsigned uncompLength = full_length;
+  char* uncomp = (char*)calloc(sizeof(char), uncompLength);
+
+  z_stream strm;
+  strm.next_in = (Bytef*)compressedBytes.c_str();
+  strm.avail_in = compressedBytes.size();
+  strm.total_out = 0;
+  strm.zalloc = Z_NULL;
+  strm.zfree = Z_NULL;
+
+  bool done = false;
+
+  if (inflateInit2(&strm, (16 + MAX_WBITS)) != Z_OK) {
+    free(uncomp);
+    return false;
+  }
+
+  while (!done) {
+    // If our output buffer is too small
+    if (strm.total_out >= uncompLength) {
+      // Increase size of output buffer
+      char* uncomp2 = (char*)calloc(sizeof(char), uncompLength + half_length);
+      std::memcpy(uncomp2, uncomp, uncompLength);
+      uncompLength += half_length;
+      free(uncomp);
+      uncomp = uncomp2;
+    }
+
+    strm.next_out = (Bytef*)(uncomp + strm.total_out);
+    strm.avail_out = uncompLength - strm.total_out;
+
+    // Inflate another chunk.
+    int err = inflate(&strm, Z_SYNC_FLUSH);
+    if (err == Z_STREAM_END)
+      done = true;
+    else if (err != Z_OK) {
+      break;
+    }
+  }
+
+  if (inflateEnd(&strm) != Z_OK) {
+    free(uncomp);
+    return false;
+  }
+
+  for (size_t i = 0; i < strm.total_out; ++i) {
+    uncompressedBytes += uncomp[i];
+  }
+  free(uncomp);
+  return true;
+}
\ No newline at end of file
diff --git a/src/token_authorization_middleware.cpp b/src/token_authorization_middleware.cpp
index 4c7a2d4..8b109e0 100644
--- a/src/token_authorization_middleware.cpp
+++ b/src/token_authorization_middleware.cpp
@@ -1,10 +1,10 @@
-#include <boost/algorithm/string/predicate.hpp>
 #include <random>
 #include <unordered_map>
+#include <boost/algorithm/string/predicate.hpp>
 
-#include <crow/logging.h>
 #include <base64.hpp>
 #include <token_authorization_middleware.hpp>
+#include <crow/logging.h>
 
 namespace crow {
 
@@ -29,7 +29,7 @@
     res.end();
   };
 
-  LOG(DEBUG) << "Token Auth Got route " << req.url;
+  CROW_LOG_DEBUG << "Token Auth Got route " << req.url;
 
   if (req.url == "/" || boost::starts_with(req.url, "/static/")) {
     // TODO this is total hackery to allow the login page to work before the
diff --git a/src/token_authorization_middleware_test.cpp b/src/token_authorization_middleware_test.cpp
index c01e7f9..e8277653 100644
--- a/src/token_authorization_middleware_test.cpp
+++ b/src/token_authorization_middleware_test.cpp
@@ -1,7 +1,7 @@
+#include "token_authorization_middleware.hpp"
 #include <crow/app.h>
 #include "gmock/gmock.h"
 #include "gtest/gtest.h"
-#include "token_authorization_middleware.hpp"
 
 using namespace crow;
 using namespace std;
diff --git a/src/udpclient.cpp b/src/udpclient.cpp
index cf9f3d1..9bebd6e 100644
--- a/src/udpclient.cpp
+++ b/src/udpclient.cpp
@@ -8,9 +8,8 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //
 #include <array>
-#include <boost/array.hpp>
-#include <boost/asio.hpp>
 #include <iostream>
+#include <boost/asio.hpp>
 
 using boost::asio::ip::udp;
 
@@ -44,7 +43,7 @@
         0x0E + 0x80;  // E is defined in spec as this channel
                       // 0x80 is requesting IPMI 2.0
     uint8_t byte1 = static_cast<uint8_t>(channel_number | 0x80);
-    boost::array<uint8_t, 2> payload{byte1, privilege_level};
+    std::array<uint8_t, 2> payload{byte1, privilege_level};
 
     int payload_sum = 0;
     for (auto element : payload) {
diff --git a/src/webassets_test.cpp b/src/webassets_test.cpp
index 8d0cfef..1d02171 100644
--- a/src/webassets_test.cpp
+++ b/src/webassets_test.cpp
@@ -1,85 +1,20 @@
 #include <crow/app.h>
 #include <gmock/gmock.h>
-#include <zlib.h>
+
+#include <test_utils.hpp>
+#include <webassets.hpp>
+#include <sstream>
 #include <boost/algorithm/string/predicate.hpp>
 #include <boost/iostreams/copy.hpp>
 #include <boost/iostreams/filter/gzip.hpp>
 #include <boost/iostreams/filtering_streambuf.hpp>
 #include <boost/lexical_cast.hpp>
-#include <sstream>
-#include <webassets.hpp>
 #include "gtest/gtest.h"
+
 using namespace crow;
 using namespace std;
 using namespace testing;
 
-bool gzipInflate(const std::string& compressedBytes,
-                 std::string& uncompressedBytes) {
-  if (compressedBytes.size() == 0) {
-    uncompressedBytes = compressedBytes;
-    return true;
-  }
-
-  uncompressedBytes.clear();
-
-  unsigned full_length = compressedBytes.size();
-  unsigned half_length = compressedBytes.size() / 2;
-
-  unsigned uncompLength = full_length;
-  char* uncomp = (char*)calloc(sizeof(char), uncompLength);
-
-  z_stream strm;
-  strm.next_in = (Bytef*)compressedBytes.c_str();
-  strm.avail_in = compressedBytes.size();
-  strm.total_out = 0;
-  strm.zalloc = Z_NULL;
-  strm.zfree = Z_NULL;
-
-  bool done = false;
-
-  if (inflateInit2(&strm, (16 + MAX_WBITS)) != Z_OK) {
-    free(uncomp);
-    return false;
-  }
-
-  while (!done) {
-    // If our output buffer is too small
-    if (strm.total_out >= uncompLength) {
-      // Increase size of output buffer
-      char* uncomp2 = (char*)calloc(sizeof(char), uncompLength + half_length);
-      memcpy(uncomp2, uncomp, uncompLength);
-      uncompLength += half_length;
-      free(uncomp);
-      uncomp = uncomp2;
-    }
-
-    strm.next_out = (Bytef*)(uncomp + strm.total_out);
-    strm.avail_out = uncompLength - strm.total_out;
-
-    // Inflate another chunk.
-    int err = inflate(&strm, Z_SYNC_FLUSH);
-    if (err == Z_STREAM_END)
-      done = true;
-    else if (err != Z_OK) {
-      break;
-    }
-  }
-
-  if (inflateEnd(&strm) != Z_OK) {
-    free(uncomp);
-    return false;
-  }
-
-  for (size_t i = 0; i < strm.total_out; ++i) {
-    uncompressedBytes += uncomp[i];
-  }
-  free(uncomp);
-  return true;
-}
-
-
-
-
 // Tests static files are loaded correctly
 TEST(Webassets, StaticFilesFixedRoutes) {
   std::array<char, 2048> buf;
@@ -151,8 +86,6 @@
   server.stop();
 }
 
-
-
 // Tests static files are loaded correctly
 TEST(Webassets, EtagIsSane) {
   std::array<char, 2048> buf;
diff --git a/src/webserver_main.cpp b/src/webserver_main.cpp
index d77d822..2ec7e37 100644
--- a/src/webserver_main.cpp
+++ b/src/webserver_main.cpp
@@ -21,10 +21,12 @@
 #include "crow/websocket.h"
 
 #include "color_cout_g3_sink.hpp"
-#include "webassets.hpp"
-
 #include "security_headers_middleware.hpp"
+#include "ssl_key_handler.hpp"
 #include "token_authorization_middleware.hpp"
+#include "web_kvm.hpp"
+#include "webassets.hpp"
+#include "webassets.hpp"
 
 #include <boost/asio.hpp>
 #include <boost/endian/arithmetic.hpp>
@@ -34,10 +36,6 @@
 #include <string>
 #include <unordered_set>
 
-#include <web_kvm.hpp>
-#include <webassets.hpp>
-#include "ssl_key_handler.hpp"
-
 int main(int argc, char** argv) {
   auto worker(g3::LogWorker::createLogWorker());
   std::string logger_name("bmcweb");
@@ -117,6 +115,8 @@
 
       });
   auto ssl_context = ensuressl::get_ssl_context(ssl_pem_file);
-  app.port(18080).ssl(std::move(ssl_context)).run();
+  app.port(18080)
+      //.ssl(std::move(ssl_context))
+      //.concurrency(4)
+      .run();
 }
-