diff --git a/test/float_tests.c b/test/float_tests.c
index c23a3b8..5aefaea 100644
--- a/test/float_tests.c
+++ b/test/float_tests.c
@@ -303,22 +303,20 @@
  "single with precision loss": 16777217.0,
  1: "fin"}
  */
-// TODO: check these values in hex against expected encoded by hand
 static const uint8_t spExpectedSmallest[] = {
    0xB8, 0x1A,
       0x64, 0x7A, 0x65, 0x72, 0x6F,
       0xF9, 0x00, 0x00,
 
-      0x6D, 0x6E, 0x65, 0x67, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20,
-         0x7A, 0x65, 0x72, 0x6F,
+      0x6D, 0x6E, 0x65, 0x67, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x7A,
+         0x65, 0x72, 0x6F,
       0xF9, 0x80, 0x00,
 
       0x6A, 0x69, 0x6E, 0x66, 0x69, 0x6E, 0x69, 0x74, 0x69, 0x74, 0x79,
       0xF9, 0x7C, 0x00,
 
-      0x73, 0x6E, 0x65, 0x67, 0x61, 0x74, 0x69, 0x76, 0x65,
-         0x20, 0x69, 0x6E, 0x66, 0x69, 0x6E, 0x69, 0x74, 0x69, 0x74,
-         0x79,
+      0x73, 0x6E, 0x65, 0x67, 0x61, 0x74, 0x69, 0x76, 0x65, 0x20, 0x69,
+         0x6E, 0x66, 0x69, 0x6E, 0x69, 0x74, 0x69, 0x74, 0x79,
       0xF9, 0xFC, 0x00,
 
       0x63, 0x4E, 0x61, 0x4E,
@@ -327,24 +325,23 @@
       0x63, 0x6F, 0x6E, 0x65,
       0xF9, 0x3C, 0x00,
 
-      0x69, 0x6F,
-         0x6E, 0x65, 0x20, 0x74, 0x68, 0x69, 0x72, 0x64,
+      0x69, 0x6F, 0x6E, 0x65, 0x20, 0x74, 0x68, 0x69, 0x72, 0x64,
       0xF9, 0x35, 0x55,
 
-      0x76, 0x6C, 0x61, 0x72, 0x67, 0x65, 0x73, 0x74, 0x20,
-         0x68, 0x61, 0x6C, 0x66, 0x2D, 0x70, 0x72, 0x65, 0x63, 0x69,
-         0x73, 0x69, 0x6F, 0x6E,
+      0x76, 0x6C, 0x61, 0x72, 0x67, 0x65, 0x73, 0x74, 0x20, 0x68, 0x61,
+         0x6C, 0x66, 0x2D, 0x70, 0x72, 0x65, 0x63, 0x69, 0x73, 0x69,
+         0x6F, 0x6E,
       0xF9, 0x7B, 0xFF,
 
-      0x78, 0x20, 0x6C, 0x61, 0x72, 0x67, 0x65, 0x73, 0x74, 0x20, 0x68, 0x61, 0x6C,
-         0x66, 0x2D, 0x70, 0x72, 0x65, 0x63, 0x69, 0x73, 0x69, 0x6F,
-         0x6E, 0x20, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x20, 0x6F, 0x6E,
-         0x65,
+      0x78, 0x20, 0x6C, 0x61, 0x72, 0x67, 0x65, 0x73, 0x74, 0x20, 0x68,
+         0x61, 0x6C, 0x66, 0x2D, 0x70, 0x72, 0x65, 0x63, 0x69, 0x73,
+         0x69, 0x6F, 0x6E, 0x20, 0x70, 0x6F, 0x69, 0x6E, 0x74, 0x20,
+         0x6F, 0x6E, 0x65,
       0xFB, 0x40, 0xEF, 0xFC, 0x03, 0x33, 0x33, 0x33, 0x33,
 
-      0x78, 0x18, 0x74, 0x6F, 0x6F, 0x2D, 0x6C, 0x61, 0x72, 0x67,
-         0x65, 0x20, 0x68, 0x61, 0x6C, 0x66, 0x2D, 0x70, 0x72, 0x65,
-         0x63, 0x69, 0x73, 0x69, 0x6F, 0x6E,
+      0x78, 0x18, 0x74, 0x6F, 0x6F, 0x2D, 0x6C, 0x61, 0x72, 0x67, 0x65,
+         0x20, 0x68, 0x61, 0x6C, 0x66, 0x2D, 0x70, 0x72, 0x65, 0x63,
+         0x69, 0x73, 0x69, 0x6F, 0x6E,
       0xFA, 0x47, 0x80, 0x00, 0x00,
 
       0x77, 0x73, 0x6D, 0x61, 0x6C, 0x6C, 0x65, 0x73, 0x74,
@@ -352,74 +349,65 @@
          0x6F, 0x72, 0x6D, 0x61, 0x6C,
       0xFA, 0x33, 0x80, 0x00, 0x00,
 
-      0x74, 0x73, 0x6D, 0x61, 0x6C, 0x6C, 0x65, 0x73, 0x74, 0x20,
-         0x68, 0x61, 0x6C, 0x66, 0x20, 0x6E, 0x6F, 0x72, 0x6D, 0x61,
-      0x6C,
+      0x74, 0x73, 0x6D, 0x61, 0x6C, 0x6C, 0x65, 0x73, 0x74, 0x20, 0x68,
+         0x61, 0x6C, 0x66, 0x20, 0x6E, 0x6F, 0x72, 0x6D, 0x61, 0x6C,
       0xF9, 0x04, 0x00,
 
-      0x78, 0x19, 0x73, 0x6D, 0x61, 0x6C,
-         0x6C, 0x65, 0x73, 0x74, 0x20, 0x68, 0x61, 0x6C, 0x66, 0x20,
-         0x6E, 0x6F, 0x72, 0x6D, 0x61, 0x6C, 0x20, 0x70, 0x6C, 0x75,
-         0x73,
+      0x78, 0x19, 0x73, 0x6D, 0x61, 0x6C, 0x6C, 0x65, 0x73, 0x74, 0x20,
+         0x68, 0x61, 0x6C, 0x66, 0x20, 0x6E, 0x6F, 0x72, 0x6D, 0x61,
+         0x6C, 0x20, 0x70, 0x6C, 0x75, 0x73,
       0xFB, 0x3F, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
 
-      0x75, 0x73, 0x6D, 0x61, 0x6C, 0x6C, 0x65, 0x73, 0x74, 0x20,
-         0x6E, 0x6F, 0x72, 0x6D, 0x61, 0x6C, 0x20, 0x6D, 0x69, 0x6E,
+      0x75, 0x73, 0x6D, 0x61, 0x6C, 0x6C, 0x65, 0x73, 0x74, 0x20, 0x6E,
+         0x6F, 0x72, 0x6D, 0x61, 0x6C, 0x20, 0x6D, 0x69, 0x6E,
          0x75, 0x73,
       0xFB, 0x3F, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
 
-      0x75, 0x73, 0x6D, 0x61, 0x6C, 0x6C, 0x65, 0x73, 0x74,
-         0x20, 0x6E, 0x6F, 0x72, 0x6D, 0x61, 0x6C, 0x20, 0x6D, 0x69,
-         0x6E, 0x75, 0x73,
+      0x75, 0x73, 0x6D, 0x61, 0x6C, 0x6C, 0x65, 0x73, 0x74, 0x20, 0x6E,
+         0x6F, 0x72, 0x6D, 0x61, 0x6C, 0x20, 0x6D, 0x69, 0x6E, 0x75,
+         0x73,
       0xFA, 0x38, 0x00, 0x00, 0x00,
 
-      0x6E, 0x6C,
-         0x61, 0x72, 0x67, 0x65, 0x73, 0x74, 0x20, 0x73, 0x69, 0x6E,
-         0x67, 0x6C, 0x65,
+      0x6E, 0x6C, 0x61, 0x72, 0x67, 0x65, 0x73, 0x74, 0x20, 0x73, 0x69,
+         0x6E, 0x67, 0x6C, 0x65,
       0xFA, 0x7F, 0x7F, 0xFF, 0xFF,
 
-      0x73, 0x6C,
-         0x61, 0x72, 0x67, 0x65, 0x73, 0x74, 0x20, 0x73, 0x69, 0x6E,
-         0x67, 0x6C, 0x65, 0x20, 0x70, 0x6C, 0x75, 0x73,
+      0x73, 0x6C, 0x61, 0x72, 0x67, 0x65, 0x73, 0x74, 0x20, 0x73, 0x69,
+         0x6E,0x67, 0x6C, 0x65, 0x20, 0x70, 0x6C, 0x75, 0x73,
       0xFB, 0x47, 0xEF, 0xFF, 0xFF, 0xE0, 0x00, 0x00, 0x01,
 
-      0x73, 0x6C, 0x61,
-         0x72, 0x67, 0x65, 0x73, 0x74, 0x20, 0x73, 0x69, 0x6E, 0x67,
-         0x6C, 0x65, 0x20, 0x70, 0x6C, 0x75, 0x73,
+      0x73, 0x6C, 0x61, 0x72, 0x67, 0x65, 0x73, 0x74, 0x20, 0x73, 0x69,
+         0x6E, 0x67, 0x6C, 0x65, 0x20, 0x70, 0x6C, 0x75, 0x73,
       0xFB, 0x47, 0xFF, 0xFF, 0xFF, 0xE0, 0x00, 0x00, 0x00,
 
-      0x6F, 0x73, 0x6D, 0x61,
-         0x6C, 0x6C, 0x65, 0x73, 0x74, 0x20, 0x73, 0x69, 0x6E, 0x67,
-         0x6C, 0x65,
+      0x6F, 0x73, 0x6D, 0x61, 0x6C, 0x6C, 0x65, 0x73, 0x74, 0x20, 0x73,
+         0x69, 0x6E, 0x67, 0x6C, 0x65,
       0xFA, 0x00, 0x80, 0x00, 0x00,
 
-      0x74, 0x73, 0x6D,
-         0x61, 0x6C, 0x6C, 0x65, 0x73, 0x74, 0x20, 0x73, 0x69, 0x6E,
-         0x67, 0x6C, 0x65, 0x20, 0x70, 0x6C, 0x75, 0x73,
+      0x74, 0x73, 0x6D, 0x61, 0x6C, 0x6C, 0x65, 0x73, 0x74, 0x20, 0x73,
+         0x69, 0x6E, 0x67, 0x6C, 0x65, 0x20, 0x70, 0x6C, 0x75, 0x73,
       0xFB, 0x38, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
 
-      0x75, 0x73, 0x6D,
-         0x61, 0x6C, 0x6C, 0x65, 0x73, 0x74, 0x20, 0x73, 0x69, 0x6E,
-         0x67, 0x6C, 0x65, 0x20, 0x6D, 0x69, 0x6E, 0x75, 0x73,
+      0x75, 0x73, 0x6D, 0x61, 0x6C, 0x6C, 0x65, 0x73, 0x74, 0x20, 0x73,
+         0x69, 0x6E, 0x67, 0x6C, 0x65, 0x20, 0x6D, 0x69, 0x6E, 0x75,
+         0x73,
       0xFB, 0x38, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
 
-      0x78, 0x1A,
-         0x73, 0x6D, 0x61, 0x6C, 0x6C, 0x65, 0x73, 0x74, 0x20, 0x73,
-         0x69, 0x6E, 0x67, 0x6C, 0x65, 0x20, 0x6D, 0x69, 0x6E, 0x75,
-         0x73, 0x20, 0x6D, 0x6F, 0x72, 0x65,
+      0x78, 0x1A, 0x73, 0x6D, 0x61, 0x6C, 0x6C, 0x65, 0x73, 0x74, 0x20,
+         0x73, 0x69, 0x6E, 0x67, 0x6C, 0x65, 0x20, 0x6D, 0x69, 0x6E,
+         0x75, 0x73, 0x20, 0x6D, 0x6F, 0x72, 0x65,
       0xFB, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 
       0x03,
       0xF9, 0xC0, 0x00,
 
-      0x70,
-         0x73, 0x69, 0x6E, 0x67, 0x6C, 0x65, 0x20, 0x70, 0x72, 0x65,
+      0x70, 0x73, 0x69, 0x6E, 0x67, 0x6C, 0x65, 0x20, 0x70, 0x72, 0x65,
          0x63, 0x69, 0x73, 0x69, 0x6F, 0x6E,
       0xFA, 0x4B, 0x80, 0x00, 0x00,
 
-      0x78, 0x1A, 0x73, 0x69, 0x6E, 0x67, 0x6C, 0x65, 0x20,
-         0x77, 0x69, 0x74, 0x68, 0x20, 0x70, 0x72, 0x65, 0x63, 0x69,
-         0x73, 0x69, 0x6F, 0x6E, 0x20, 0x6C, 0x6F, 0x73, 0x73,
+      0x78, 0x1A, 0x73, 0x69, 0x6E, 0x67, 0x6C, 0x65, 0x20, 0x77, 0x69,
+         0x74, 0x68, 0x20, 0x70, 0x72, 0x65, 0x63, 0x69, 0x73, 0x69,
+         0x6F, 0x6E, 0x20, 0x6C, 0x6F, 0x73, 0x73,
       0xFB, 0x41, 0x70, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
 
       0x01,
@@ -447,40 +435,26 @@
    // and
    // https://en.wikipedia.org/wiki/Single-precision_floating-point_format
 
-   // 64                                   # text(4)
-   //    7A65726F                          # "zero"
    // F9 0000                              # primitive(0)
    QCBOREncode_AddDoubleToMap(&EC, "zero", 0.00);
 
-   // 64                                   # text(4)
-   //    7A65726F                          # "negative zero"
    // F9 8000                              # primitive(0)
    QCBOREncode_AddDoubleToMap(&EC, "negative zero", -0.00);
 
-   // 6A                                   # text(10)
-   //    696E66696E6974697479              # "infinitity"
    // F9 7C00                              # primitive(31744)
    QCBOREncode_AddDoubleToMap(&EC, "infinitity", INFINITY);
 
-   // 73                                   # text(19)
-   //    6E6567617469766520696E66696E6974697479 # "negative infinitity"
    // F9 FC00                              # primitive(64512)
    QCBOREncode_AddDoubleToMap(&EC, "negative infinitity", -INFINITY);
 
-   // 63                                   # text(3)
-   //    4E614E                            # "NaN"
    // F9 7E00                              # primitive(32256)
    QCBOREncode_AddDoubleToMap(&EC, "NaN", NAN);
 
    // TODO: test a few NaN variants
 
-   // 63                                   # text(3)
-   //    6F6E65                            # "one"
    // F9 3C00                              # primitive(15360)
    QCBOREncode_AddDoubleToMap(&EC, "one", 1.0);
 
-   // 69                                   # text(9)
-   //    6F6E65207468697264                # "one third"
    // F9 3555                              # primitive(13653)
    QCBOREncode_AddDoubleToMap(&EC, "one third", 0.333251953125);
 
@@ -501,9 +475,9 @@
    QCBOREncode_AddDoubleToMap(&EC, "too-large half-precision", 65536.0);
 
    // 5.9604644775390625E-8, the smallest possible half-precision
-   // subnormal, but digitis are lost converting to half, so this is
-   // output as a double.
-   // 0xFA, 0x33, 0x80, 0x00, 0x00, TODO: is this right?
+   // subnormal, digitis are lost converting to half, but not
+   // when converting to a single
+   // 0xFA, 0x33, 0x80, 0x00, 0x00,
    QCBOREncode_AddDoubleToMap(&EC,
                               "smallest half subnormal",
                               MAKE_DOUBLE(0x3e70000000000000));
@@ -511,7 +485,7 @@
    // 0.00006103515625, the double value that converts to the smallest
    // possible half-precision normal.  which is what should appear in
    // the output.
-   //       0xF9, 0x04, 0x00,
+   // 0xF9, 0x04, 0x00,
    QCBOREncode_AddDoubleToMap(&EC,
                               "smallest half normal",
                               MAKE_DOUBLE(0x3f10000000000000));
@@ -519,7 +493,7 @@
    // 0.000061035156250000014 ,the double value that is a tiny bit
    // greater than smallest possible half-precision normal. It will be
    // output as a double because converting it will reduce precision.
-   //  0xFB, 0x3F, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+   // 0xFB, 0x3F, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
    QCBOREncode_AddDoubleToMap(&EC,
                               "smallest half normal plus",
                               MAKE_DOUBLE(0x3f10000000000001));
@@ -545,7 +519,7 @@
 
    // 3.4028234664e38, the value that converts to the largest possible
    // single-precision.
-   //       0xFA, 0x7F, 0x7F, 0xFF, 0xFF,
+   // 0xFA, 0x7F, 0x7F, 0xFF, 0xFF,
    QCBOREncode_AddDoubleToMap(&EC,
                               "largest single",
                               MAKE_DOUBLE(0x47efffffe0000000));
@@ -561,14 +535,14 @@
    // 6.8056469327705772E38, slightly more larger than the largers
    // possible single precision.  Conversion fails because exponent is
    // too large.
-   //       0xFB, 0x47, 0xFF, 0xFF, 0xFF, 0xE0, 0x00, 0x00, 0x00,
+   // 0xFB, 0x47, 0xFF, 0xFF, 0xFF, 0xE0, 0x00, 0x00, 0x00,
    QCBOREncode_AddDoubleToMap(&EC,
                               "largest single plus",
                               MAKE_DOUBLE(0x47ffffffe0000000));
 
    // 1.1754943508222875E-38, The double value that converts to the
    // smallest possible single-precision normal
-   //       0xFA, 0x00, 0x80, 0x00, 0x00,
+   // 0xFA, 0x00, 0x80, 0x00, 0x00,
    QCBOREncode_AddDoubleToMap(&EC,
                               "smallest single",
                               MAKE_DOUBLE(0x3810000000000000));
@@ -576,14 +550,14 @@
    // 1.1754943508222878E-38, double value that is slightly larger
    // than the smallest single-precision normal. Conversion fails
    // because of precision
-   //       0xFB, 0x38, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+   // 0xFB, 0x38, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
    QCBOREncode_AddDoubleToMap(&EC,
                               "smallest single plus",
                               MAKE_DOUBLE(0x3810000000000001));
 
    // 1.1754943508222874E-38, slightly smaller than the smallest
    // single-precision normal.  Conversion fails because of precision
-   //       0xFB, 0x38, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+   // 0xFB, 0x38, 0x0F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
    QCBOREncode_AddDoubleToMap(&EC,
                               "smallest single minus",
                               MAKE_DOUBLE(0x380fffffffffffff));
@@ -945,6 +919,3 @@
     return 0;
 }
 #endif
-
-
-