diff --git a/inc/qcbor/qcbor_common.h b/inc/qcbor/qcbor_common.h
index 0500795..9f0a16f 100644
--- a/inc/qcbor/qcbor_common.h
+++ b/inc/qcbor/qcbor_common.h
@@ -325,6 +325,9 @@
         floating-point date was encountered by the decoder. */
     QCBOR_ERR_FLOAT_DATE_UNSUPPORTED = 25,
 
+    /** Support for half-precision float decoding is disabled. */
+    QCBOR_ERR_HALF_PRECISION_UNSUPPORTED = 26,
+
     /* This is stored in uint8_t in places; never add values > 255 */
 } QCBORError;
 
diff --git a/src/qcbor_decode.c b/src/qcbor_decode.c
index 6accc83..02fecd2 100644
--- a/src/qcbor_decode.c
+++ b/src/qcbor_decode.c
@@ -576,7 +576,7 @@
          pDecodedItem->val.dfnum = IEEE754_HalfToDouble((uint16_t)uNumber);
          pDecodedItem->uDataType = QCBOR_TYPE_DOUBLE;
 #else
-         nReturn = QCBOR_ERR_UNSUPPORTED;
+         nReturn = QCBOR_ERR_HALF_PRECISION_UNSUPPORTED;
 #endif
          break;
       case SINGLE_PREC_FLOAT:
diff --git a/test/float_tests.c b/test/float_tests.c
index 4ad4a9a..735a55d 100644
--- a/test/float_tests.c
+++ b/test/float_tests.c
@@ -13,11 +13,11 @@
 
 #include "float_tests.h"
 #include "qcbor/qcbor_encode.h"
+#include "qcbor/qcbor_decode.h"
 #include <math.h> // For INFINITY and NAN and isnan()
 
 #ifndef QCBOR_DISABLE_PREFERRED_FLOAT
 
-#include "qcbor/qcbor_decode.h"
 #include "half_to_double_from_rfc7049.h"
 
 
@@ -458,7 +458,6 @@
  {100: 0.0, 101: 3.1415926, "euler": 2.718281828459045, 105: 0.0,
   102: 0.0, 103: 3.141592502593994, "euler2": 2.7182817459106445, 106: 0.0}]
  */
-#ifndef QCBOR_DISABLE_PREFERRED_FLOAT
 static const uint8_t spExpectedFloats[] = {
    0x8B,
       0xF9, 0x00, 0x00,
@@ -488,8 +487,8 @@
           0xFA, 0x40, 0x2D, 0xF8, 0x54,
          0x18, 0x6A,
           0xFA, 0x00, 0x00, 0x00, 0x00};
-#else
-static const uint8_t spExpectedFloats[] = {
+
+static const uint8_t spExpectedFloatsNoHalf[] = {
    0x8B,
       0xFB, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
       0xFB, 0x40, 0x09, 0x1E, 0xB8, 0x51, 0xEB, 0x85, 0x1F,
@@ -518,11 +517,18 @@
           0xFA, 0x40, 0x2D, 0xF8, 0x54,
          0x18, 0x6A,
           0xFA, 0x00, 0x00, 0x00, 0x00};
-#endif /* QCBOR_DISABLE_PREFERRED_FLOAT */
 
 int32_t GeneralFloatEncodeTests()
 {
+#ifndef QCBOR_DISABLE_PREFERRED_FLOAT
    UsefulBuf_MAKE_STACK_UB(OutBuffer, sizeof(spExpectedFloats));
+   UsefulBufC ExpectedFloats = UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spExpectedFloats);
+   (void)spExpectedFloatsNoHalf; // Avoid unused variable error
+#else
+   UsefulBuf_MAKE_STACK_UB(OutBuffer, sizeof(spExpectedFloatsNoHalf));
+   UsefulBufC ExpectedFloats = UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spExpectedFloatsNoHalf);
+   (void)spExpectedFloats; // Avoid unused variable error
+#endif /* QCBOR_DISABLE_PREFERRED_FLOAT */
 
    QCBOREncodeContext EC;
    QCBOREncode_Init(&EC, OutBuffer);
@@ -561,7 +567,7 @@
       return -1;
    }
 
-   if(UsefulBuf_Compare(Encoded, UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spExpectedFloats))) {
+   if(UsefulBuf_Compare(Encoded, ExpectedFloats)) {
       return -3;
    }
 
@@ -569,6 +575,156 @@
 }
 
 
+#ifndef QCBOR_DISABLE_PREFERRED_FLOAT
+/* returns 0 if equivalent, non-zero if not equivalent */
+static int CHECK_EXPECTED_DOUBLE(double val, double expected)
+{
+   double diff = val - expected;
+
+   diff = fabs(diff);
+
+   if(diff > 0.000001) {
+      return 1;
+   } else {
+      return 0;
+   }
+}
+#endif
+
+
+int32_t GeneralFloatDecodeTests()
+{
+   UsefulBufC TestData = UsefulBuf_FROM_BYTE_ARRAY_LITERAL(spExpectedFloats);
+
+   QCBORDecodeContext DC;
+   QCBORDecode_Init(&DC, TestData, 0);
+
+   QCBORItem Item;
+   QCBORError uErr;
+
+   QCBORDecode_GetNext(&DC, &Item);
+   if(Item.uDataType != QCBOR_TYPE_ARRAY) {
+      return -1;
+   }
+
+#ifndef QCBOR_DISABLE_PREFERRED_FLOAT
+   uErr = QCBORDecode_GetNext(&DC, &Item);
+   if(uErr != QCBOR_SUCCESS ||
+      Item.uDataType != QCBOR_TYPE_DOUBLE ||
+      Item.val.dfnum != 0.0) {
+      return -2;
+   }
+#else
+   uErr = QCBORDecode_GetNext(&DC, &Item);
+   if(uErr != QCBOR_ERR_HALF_PRECISION_UNSUPPORTED) {
+      return -3;
+   }
+#endif
+
+   uErr = QCBORDecode_GetNext(&DC, &Item);
+   if(uErr != QCBOR_SUCCESS ||
+      Item.uDataType != QCBOR_TYPE_DOUBLE ||
+      Item.val.dfnum != 3.14) {
+      return -4;
+   }
+
+   uErr = QCBORDecode_GetNext(&DC, &Item);
+   if(uErr != QCBOR_SUCCESS ||
+      Item.uDataType != QCBOR_TYPE_DOUBLE ||
+      Item.val.dfnum != 0.0) {
+      return -5;
+   }
+
+   uErr = QCBORDecode_GetNext(&DC, &Item);
+   if(uErr != QCBOR_SUCCESS ||
+      Item.uDataType != QCBOR_TYPE_DOUBLE ||
+      !isnan(Item.val.dfnum)) {
+      return -6;
+   }
+
+   uErr = QCBORDecode_GetNext(&DC, &Item);
+   if(uErr != QCBOR_SUCCESS ||
+      Item.uDataType != QCBOR_TYPE_DOUBLE ||
+      Item.val.dfnum != INFINITY) {
+      return -7;
+   }
+
+#ifndef QCBOR_DISABLE_PREFERRED_FLOAT
+   uErr = QCBORDecode_GetNext(&DC, &Item);
+   if(uErr != QCBOR_SUCCESS ||
+      Item.uDataType != QCBOR_TYPE_DOUBLE ||
+      Item.val.dfnum != 0.0) {
+      return -8;
+   }
+
+   uErr = QCBORDecode_GetNext(&DC, &Item);
+   if(uErr != QCBOR_SUCCESS ||
+      Item.uDataType != QCBOR_TYPE_DOUBLE ||
+      CHECK_EXPECTED_DOUBLE(3.14, Item.val.dfnum)) {
+      return -9;
+   }
+
+   uErr = QCBORDecode_GetNext(&DC, &Item);
+   if(uErr != QCBOR_SUCCESS ||
+      Item.uDataType != QCBOR_TYPE_DOUBLE ||
+      Item.val.dfnum != 0.0) {
+      return -10;
+   }
+
+   uErr = QCBORDecode_GetNext(&DC, &Item);
+   if(uErr != QCBOR_SUCCESS ||
+      Item.uDataType != QCBOR_TYPE_DOUBLE ||
+      !isnan(Item.val.dfnum)) {
+      return -11;
+   }
+
+   uErr = QCBORDecode_GetNext(&DC, &Item);
+   if(uErr != QCBOR_SUCCESS ||
+      Item.uDataType != QCBOR_TYPE_DOUBLE ||
+      Item.val.dfnum != INFINITY) {
+      return -12;
+   }
+
+#else
+   uErr = QCBORDecode_GetNext(&DC, &Item);
+   if(uErr != QCBOR_ERR_HALF_PRECISION_UNSUPPORTED) {
+      return -13;
+   }
+
+   uErr = QCBORDecode_GetNext(&DC, &Item);
+   if(uErr != QCBOR_SUCCESS ||
+      Item.uDataType != QCBOR_TYPE_FLOAT ||
+      Item.val.fnum != 3.14f) {
+      return -14;
+   }
+
+   uErr = QCBORDecode_GetNext(&DC, &Item);
+   if(uErr != QCBOR_SUCCESS ||
+      Item.uDataType != QCBOR_TYPE_FLOAT ||
+      Item.val.fnum != 0.0f) {
+      return -15;
+   }
+
+   uErr = QCBORDecode_GetNext(&DC, &Item);
+   if(uErr != QCBOR_SUCCESS ||
+      Item.uDataType != QCBOR_TYPE_FLOAT ||
+      !isnan(Item.val.fnum)) {
+      return -16;
+   }
+
+   uErr = QCBORDecode_GetNext(&DC, &Item);
+   if(uErr != QCBOR_SUCCESS ||
+      Item.uDataType != QCBOR_TYPE_FLOAT ||
+      Item.val.fnum != INFINITY) {
+      return -17;
+   }
+#endif
+   /* Sufficent test coverage. Don't need to decode the rest */
+
+   return 0;
+}
+
+
 
 #ifdef NAN_EXPERIMENT
 /*
diff --git a/test/float_tests.h b/test/float_tests.h
index 5f9ebcd..54daa3f 100644
--- a/test/float_tests.h
+++ b/test/float_tests.h
@@ -31,4 +31,10 @@
  */
 int32_t GeneralFloatEncodeTests(void);
 
+/*
+ Tests basic float decoding.
+ */
+int32_t GeneralFloatDecodeTests(void);
+
+
 #endif /* float_tests_h */
diff --git a/test/qcbor_decode_tests.c b/test/qcbor_decode_tests.c
index 0a3fa2a..a14e9d2 100644
--- a/test/qcbor_decode_tests.c
+++ b/test/qcbor_decode_tests.c
@@ -2075,7 +2075,7 @@
 
 
 // have to check float expected only to within an epsilon
-int CHECK_EXPECTED_DOUBLE(double val, double expected) {
+static int CHECK_EXPECTED_DOUBLE(double val, double expected) {
 
    double diff = val - expected;
 
diff --git a/test/run_tests.c b/test/run_tests.c
index 14ccd6d..e4b2713 100644
--- a/test/run_tests.c
+++ b/test/run_tests.c
@@ -97,6 +97,7 @@
     TEST_ENTRY(HalfPrecisionAgainstRFCCodeTest),
 #endif /* QCBOR_DISABLE_PREFERRED_FLOAT */
     TEST_ENTRY(GeneralFloatEncodeTests),
+    TEST_ENTRY(GeneralFloatDecodeTests),
     TEST_ENTRY(BstrWrapTest),
     TEST_ENTRY(BstrWrapErrorTest),
     TEST_ENTRY(BstrWrapNestTest),