diff --git a/test/bej_decoder_test.cpp b/test/bej_decoder_test.cpp
index b390017..16cd19a 100644
--- a/test/bej_decoder_test.cpp
+++ b/test/bej_decoder_test.cpp
@@ -1,11 +1,7 @@
+#include "bej_common_test.hpp"
 #include "bej_decoder_json.hpp"
-#include "nlohmann/json.hpp"
 
-#include <fstream>
-#include <iostream>
 #include <memory>
-#include <optional>
-#include <span>
 #include <string_view>
 
 #include <gmock/gmock-matchers.h>
@@ -15,24 +11,6 @@
 namespace libbej
 {
 
-struct BejTestInputFiles
-{
-    const char* jsonFile;
-    const char* schemaDictionaryFile;
-    const char* annotationDictionaryFile;
-    const char* errorDictionaryFile;
-    const char* encodedStreamFile;
-};
-
-struct BejTestInputs
-{
-    const nlohmann::json expectedJson;
-    const uint8_t* schemaDictionary;
-    const uint8_t* annotationDictionary;
-    const uint8_t* errorDictionary;
-    std::span<const uint8_t> encodedStream;
-};
-
 struct BejDecoderTestParams
 {
     const std::string testName;
@@ -73,82 +51,6 @@
     .encodedStreamFile = "../test/encoded/dummy_simple_enc.bin",
 };
 
-// Buffer size for storing a single binary file data.
-constexpr uint32_t maxBufferSize = 16 * 1024;
-
-std::streamsize readBinaryFile(const char* fileName, std::span<uint8_t> buffer)
-{
-    std::ifstream inputStream(fileName, std::ios::binary);
-    if (!inputStream.is_open())
-    {
-        std::cerr << "Cannot open file: " << fileName << "\n";
-        return 0;
-    }
-    auto readLength = inputStream.readsome(
-        reinterpret_cast<char*>(buffer.data()), buffer.size_bytes());
-    if (inputStream.peek() != EOF)
-    {
-        std::cerr << "Failed to read the complete file: " << fileName
-                  << "  read length: " << readLength << "\n";
-        return 0;
-    }
-    return readLength;
-}
-
-std::optional<BejTestInputs> loadInputs(const BejTestInputFiles& files,
-                                        bool readErrorDictionary = false)
-{
-    std::ifstream jsonInput(files.jsonFile);
-    if (!jsonInput.is_open())
-    {
-        std::cerr << "Cannot open file: " << files.jsonFile << "\n";
-        return std::nullopt;
-    }
-    nlohmann::json expJson;
-    jsonInput >> expJson;
-
-    static uint8_t schemaDictBuffer[maxBufferSize];
-    if (readBinaryFile(files.schemaDictionaryFile,
-                       std::span(schemaDictBuffer, maxBufferSize)) == 0)
-    {
-        return std::nullopt;
-    }
-
-    static uint8_t annoDictBuffer[maxBufferSize];
-    if (readBinaryFile(files.annotationDictionaryFile,
-                       std::span(annoDictBuffer, maxBufferSize)) == 0)
-    {
-        return std::nullopt;
-    }
-
-    static uint8_t encBuffer[maxBufferSize];
-    auto encLen = readBinaryFile(files.encodedStreamFile,
-                                 std::span(encBuffer, maxBufferSize));
-    if (encLen == 0)
-    {
-        return std::nullopt;
-    }
-
-    static uint8_t errorDict[maxBufferSize];
-    if (readErrorDictionary)
-    {
-        if (readBinaryFile(files.errorDictionaryFile,
-                           std::span(errorDict, maxBufferSize)) == 0)
-        {
-            return std::nullopt;
-        }
-    }
-
-    BejTestInputs inputs = {
-        .expectedJson = expJson,
-        .schemaDictionary = schemaDictBuffer,
-        .annotationDictionary = annoDictBuffer,
-        .errorDictionary = errorDict,
-        .encodedStream = std::span(encBuffer, encLen),
-    };
-    return inputs;
-}
-
 TEST_P(BejDecoderTest, Decode)
 {
     const BejDecoderTestParams& test_case = GetParam();
diff --git a/test/bej_encoder_test.cpp b/test/bej_encoder_test.cpp
new file mode 100644
index 0000000..d258b4b
--- /dev/null
+++ b/test/bej_encoder_test.cpp
@@ -0,0 +1,442 @@
+#include "bej_dictionary.h"
+#include "bej_encoder_core.h"
+#include "bej_tree.h"
+
+#include "bej_common_test.hpp"
+#include "bej_decoder_json.hpp"
+#include "bej_encoder_json.hpp"
+
+#include <vector>
+
+#include <gmock/gmock-matchers.h>
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+namespace libbej
+{
+
+struct BejEncoderTestParams
+{
+    const std::string testName;
+    const BejTestInputFiles inputFiles;
+    std::string expectedJson;
+    struct RedfishPropertyParent* (*createResource)();
+};
+
+using BejEncoderTest = testing::TestWithParam<BejEncoderTestParams>;
+
+const BejTestInputFiles dummySimpleTestFiles = {
+    .jsonFile = "../test/json/dummysimple.json",
+    .schemaDictionaryFile = "../test/dictionaries/dummy_simple_dict.bin",
+    .annotationDictionaryFile = "../test/dictionaries/annotation_dict.bin",
+    .errorDictionaryFile = "",
+    .encodedStreamFile = "../test/encoded/dummy_simple_enc.bin",
+};
+
+const BejTestInputFiles driveOemTestFiles = {
+    .jsonFile = "../test/json/drive_oem.json",
+    .schemaDictionaryFile = "../test/dictionaries/drive_oem_dict.bin",
+    .annotationDictionaryFile = "../test/dictionaries/annotation_dict.bin",
+    .errorDictionaryFile = "",
+    .encodedStreamFile = "../test/encoded/drive_oem_enc.bin",
+};
+
+const BejTestInputFiles chassisTestFiles = {
+    .jsonFile = "../test/json/chassis.json",
+    .schemaDictionaryFile = "../test/dictionaries/chassis_dict.bin",
+    .annotationDictionaryFile = "../test/dictionaries/annotation_dict.bin",
+    .errorDictionaryFile = "",
+    .encodedStreamFile = "../test/encoded/chassis_enc.bin",
+};
+
+struct RedfishPropertyParent* createDummyResource()
+{
+    static struct RedfishPropertyParent root;
+    bejTreeInitSet(&root, "DummySimple");
+
+    static struct RedfishPropertyLeafString id;
+    bejTreeAddString(&root, &id, "Id", "Dummy ID");
+
+    static struct RedfishPropertyLeafInt intProp;
+    bejTreeAddInteger(&root, &intProp, "SampleIntegerProperty", -5);
+
+    static struct RedfishPropertyLeafReal real;
+    bejTreeAddReal(&root, &real, "SampleRealProperty", -5576.90001);
+
+    static struct RedfishPropertyLeafNull enProp;
+    bejTreeAddNull(&root, &enProp, "SampleEnabledProperty");
+
+    static struct RedfishPropertyParent chArraySet1;
+    bejTreeInitSet(&chArraySet1, nullptr);
+
+    static struct RedfishPropertyLeafBool chArraySet1bool;
+    bejTreeAddBool(&chArraySet1, &chArraySet1bool, "AnotherBoolean", true);
+
+    static struct RedfishPropertyLeafEnum chArraySet1Ls;
+    bejTreeAddEnum(&chArraySet1, &chArraySet1Ls, "LinkStatus", "NoLink");
+
+    static struct RedfishPropertyParent chArraySet2;
+    bejTreeInitSet(&chArraySet2, nullptr);
+
+    static struct RedfishPropertyLeafEnum chArraySet2Ls;
+    bejTreeAddEnum(&chArraySet2, &chArraySet2Ls, "LinkStatus", "LinkDown");
+
+    static struct RedfishPropertyParent chArray;
+    bejTreeInitArray(&chArray, "ChildArrayProperty");
+
+    bejTreeLinkChildToParent(&chArray, &chArraySet1);
+    bejTreeLinkChildToParent(&chArray, &chArraySet2);
+
+    bejTreeLinkChildToParent(&root, &chArray);
+    return &root;
+}
+
+const std::string driveOemJson = R"(
+      {
+        "@odata.id": "/redfish/v1/drives/1",
+        "@odata.type": "#Drive.v1_5_0.Drive",
+        "Id": "Drive1",
+        "Actions": {
+            "#Drive.Reset": {
+                "target": "/redfish/v1/drives/1/Actions/Drive.Reset",
+                "title": "Reset a Drive",
+                "ResetType@Redfish.AllowableValues": [
+                        "On",
+                        "ForceOff",
+                        "ForceRestart",
+                        "Nmi",
+                        "ForceOn",
+                        "PushPowerButton"
+                    ]
+            }
+        },
+        "Status@Message.ExtendedInfo": [
+            {
+                "MessageId": "PredictiveFailure",
+                "RelatedProperties": ["FailurePredicted", "MediaType"]
+            }
+        ],
+        "Identifiers": [],
+        "Links": {}
+    }
+)";
+
+struct RedfishPropertyParent* createDriveOem()
+{
+    static struct RedfishPropertyParent root;
+    bejTreeInitSet(&root, "Drive");
+
+    static struct RedfishPropertyLeafString odataId;
+    bejTreeAddString(&root, &odataId, "@odata.id", "/redfish/v1/drives/1");
+
+    static struct RedfishPropertyLeafString odataType;
+    bejTreeAddString(&root, &odataType, "@odata.type", "#Drive.v1_5_0.Drive");
+
+    static struct RedfishPropertyLeafString id;
+    bejTreeAddString(&root, &id, "Id", "Drive1");
+
+    static struct RedfishPropertyParent actions;
+    bejTreeInitSet(&actions, "Actions");
+
+    static struct RedfishPropertyParent drRst;
+    bejTreeInitSet(&drRst, "#Drive.Reset");
+
+    static struct RedfishPropertyLeafString drRstTarget;
+    bejTreeAddString(&drRst, &drRstTarget, "target",
+                     "/redfish/v1/drives/1/Actions/Drive.Reset");
+
+    static struct RedfishPropertyLeafString drRstTitle;
+    bejTreeAddString(&drRst, &drRstTitle, "title", "Reset a Drive");
+
+    static struct RedfishPropertyParent drRstType;
+    bejTreeInitPropertyAnnotated(&drRstType, "ResetType");
+
+    static struct RedfishPropertyParent drRstTypeAllowable;
+    bejTreeInitArray(&drRstTypeAllowable, "@Redfish.AllowableValues");
+
+    static struct RedfishPropertyLeafString drRstTypeAllowableS1;
+    bejTreeAddString(&drRstTypeAllowable, &drRstTypeAllowableS1, "", "On");
+
+    static struct RedfishPropertyLeafString drRstTypeAllowableS2;
+    bejTreeAddString(&drRstTypeAllowable, &drRstTypeAllowableS2, "",
+                     "ForceOff");
+
+    static struct RedfishPropertyLeafString drRstTypeAllowableS3;
+    bejTreeAddString(&drRstTypeAllowable, &drRstTypeAllowableS3, "",
+                     "ForceRestart");
+
+    static struct RedfishPropertyLeafString drRstTypeAllowableS4;
+    bejTreeAddString(&drRstTypeAllowable, &drRstTypeAllowableS4, "", "Nmi");
+
+    static struct RedfishPropertyLeafString drRstTypeAllowableS5;
+    bejTreeAddString(&drRstTypeAllowable, &drRstTypeAllowableS5, "", "ForceOn");
+
+    static struct RedfishPropertyLeafString drRstTypeAllowableS6;
+    bejTreeAddString(&drRstTypeAllowable, &drRstTypeAllowableS6, "",
+                     "PushPowerButton");
+
+    bejTreeLinkChildToParent(&drRstType, &drRstTypeAllowable);
+    bejTreeLinkChildToParent(&drRst, &drRstType);
+    bejTreeLinkChildToParent(&actions, &drRst);
+    bejTreeLinkChildToParent(&root, &actions);
+
+    static struct RedfishPropertyParent statusAnt;
+    bejTreeInitPropertyAnnotated(&statusAnt, "Status");
+
+    static struct RedfishPropertyParent statusAntMsgExtInfo;
+    bejTreeInitArray(&statusAntMsgExtInfo, "@Message.ExtendedInfo");
+
+    static struct RedfishPropertyParent statusAntMsgExtInfoSet1;
+    bejTreeInitSet(&statusAntMsgExtInfoSet1, nullptr);
+
+    static struct RedfishPropertyLeafString statusAntMsgExtInfoSet1P1;
+    bejTreeAddString(&statusAntMsgExtInfoSet1, &statusAntMsgExtInfoSet1P1,
+                     "MessageId", "PredictiveFailure");
+
+    static struct RedfishPropertyParent statusAntMsgExtInfoSet1P2;
+    bejTreeInitArray(&statusAntMsgExtInfoSet1P2, "RelatedProperties");
+    bejTreeLinkChildToParent(&statusAntMsgExtInfoSet1,
+                             &statusAntMsgExtInfoSet1P2);
+
+    static struct RedfishPropertyLeafString statusAntMsgExtInfoSet1P2Ele1;
+    bejTreeAddString(&statusAntMsgExtInfoSet1P2, &statusAntMsgExtInfoSet1P2Ele1,
+                     "", "FailurePredicted");
+
+    static struct RedfishPropertyLeafString statusAntMsgExtInfoSet1P2Ele2;
+    bejTreeAddString(&statusAntMsgExtInfoSet1P2, &statusAntMsgExtInfoSet1P2Ele2,
+                     "", "MediaType");
+
+    bejTreeLinkChildToParent(&statusAntMsgExtInfo, &statusAntMsgExtInfoSet1);
+    bejTreeLinkChildToParent(&statusAnt, &statusAntMsgExtInfo);
+    bejTreeLinkChildToParent(&root, &statusAnt);
+
+    static struct RedfishPropertyParent identifiers;
+    bejTreeInitArray(&identifiers, "Identifiers");
+    bejTreeLinkChildToParent(&root, &identifiers);
+
+    static struct RedfishPropertyParent links;
+    bejTreeInitSet(&links, "Links");
+    bejTreeLinkChildToParent(&root, &links);
+
+    return &root;
+}
+
+/**
+ * @brief Storage for an array of links with an annotated odata.count.
+ *
+ * This doesn't contain storage for the link itself.
+ *
+ * Eg:
+ * "Contains": [],
+ * "Contains@odata.count": 0,
+ */
+struct RedfishArrayOfLinksJson
+{
+    struct RedfishPropertyParent array;
+    struct RedfishPropertyParent annotatedProperty;
+    struct RedfishPropertyLeafInt count;
+};
+
+/**
+ * @brief Storage for a single odata.id link inside a JSON "Set" object.
+ *
+ * Eg: FieldName: {
+ *   "@odata.id": "/redfish/v1/Chassis/Something"
+ * }
+ */
+struct RedfishLinkJson
+{
+    struct RedfishPropertyParent set;
+    struct RedfishPropertyLeafString odataId;
+};
+
+void addLinkToTree(struct RedfishPropertyParent* parent,
+                   struct RedfishPropertyParent* linkSet,
+                   const char* linkSetLabel,
+                   struct RedfishPropertyLeafString* odataId,
+                   const char* linkValue)
+{
+    bejTreeInitSet(linkSet, linkSetLabel);
+    bejTreeAddString(linkSet, odataId, "@odata.id", linkValue);
+    bejTreeLinkChildToParent(parent, linkSet);
+}
+
+void redfishCreateArrayOfLinksJson(struct RedfishPropertyParent* parent,
+                                   const char* arrayName, int linkCount,
+                                   const char* const links[],
+                                   struct RedfishArrayOfLinksJson* linksInfo,
+                                   struct RedfishLinkJson* linkJsonArray)
+{
+    bejTreeInitArray(&linksInfo->array, arrayName);
+    bejTreeLinkChildToParent(parent, &linksInfo->array);
+
+    bejTreeInitPropertyAnnotated(&linksInfo->annotatedProperty, arrayName);
+    bejTreeAddInteger(&linksInfo->annotatedProperty, &linksInfo->count,
+                      "@odata.count", linkCount);
+    bejTreeLinkChildToParent(parent, &linksInfo->annotatedProperty);
+
+    for (int i = 0; i < linkCount; ++i)
+    {
+        addLinkToTree(&linksInfo->array, &linkJsonArray[i].set, NULL,
+                      &linkJsonArray[i].odataId, links[i]);
+    }
+}
+
+struct RedfishPropertyParent* createChassisResource()
+{
+    constexpr int containsLinkCount = 2;
+    const char* contains[containsLinkCount] = {"/redfish/v1/Chassis/Disk_0",
+                                               "/redfish/v1/Chassis/Disk_1"};
+    const char* storage[1] = {"/redfish/v1/Systems/system/Storage/SATA"};
+    const char* drives[1] = {"/redfish/v1/Chassis/SomeChassis/Drives/SATA_0"};
+    static struct RedfishPropertyParent root;
+    static struct RedfishPropertyLeafString odataId;
+    static struct RedfishPropertyParent links;
+    static struct RedfishPropertyParent computerSystemsArray;
+    static struct RedfishPropertyParent computerSystemsLinkSet;
+    static struct RedfishPropertyLeafString computerSystemsLinkOdataId;
+    static struct RedfishPropertyParent containedBySet;
+    static struct RedfishPropertyLeafString containedByOdataId;
+    static struct RedfishArrayOfLinksJson containsArray;
+    static struct RedfishLinkJson containsLinks[containsLinkCount];
+    static struct RedfishArrayOfLinksJson storageArray;
+    static struct RedfishLinkJson storageLink;
+    static struct RedfishArrayOfLinksJson drives_array;
+    static struct RedfishLinkJson drive_link;
+
+    bejTreeInitSet(&root, "Chassis");
+    bejTreeAddString(&root, &odataId, "@odata.id",
+                     "/redfish/v1/Chassis/SomeChassis");
+
+    bejTreeInitSet(&links, "Links");
+    bejTreeLinkChildToParent(&root, &links);
+
+    bejTreeInitArray(&computerSystemsArray, "ComputerSystems");
+    bejTreeLinkChildToParent(&links, &computerSystemsArray);
+
+    addLinkToTree(&computerSystemsArray, &computerSystemsLinkSet, "",
+                  &computerSystemsLinkOdataId, "/redfish/v1/Systems/system");
+
+    addLinkToTree(&links, &containedBySet, "ContainedBy", &containedByOdataId,
+                  "/redfish/v1/Chassis/SomeOtherChassis");
+
+    redfishCreateArrayOfLinksJson(&links, "Contains", containsLinkCount,
+                                  contains, &containsArray, containsLinks);
+
+    redfishCreateArrayOfLinksJson(&links, "Storage", /*linkCount=*/1, storage,
+                                  &storageArray, &storageLink);
+
+    redfishCreateArrayOfLinksJson(&links, "Drives", /*linkCount=*/1, drives,
+                                  &drives_array, &drive_link);
+
+    return &root;
+}
+
+TEST_P(BejEncoderTest, Encode)
+{
+    const BejEncoderTestParams& test_case = GetParam();
+    auto inputsOrErr = loadInputs(test_case.inputFiles);
+    EXPECT_TRUE(inputsOrErr);
+
+    BejDictionaries dictionaries = {
+        .schemaDictionary = inputsOrErr->schemaDictionary,
+        .annotationDictionary = inputsOrErr->annotationDictionary,
+        .errorDictionary = inputsOrErr->errorDictionary,
+    };
+
+    std::vector<uint8_t> outputBuffer;
+    struct BejEncoderOutputHandler output = {
+        .handlerContext = &outputBuffer,
+        .recvOutput = &getBejEncodedBuffer,
+    };
+
+    std::vector<void*> pointerStack;
+    struct BejPointerStackCallback stackCallbacks = {
+        .stackContext = &pointerStack,
+        .stackEmpty = stackEmpty,
+        .stackPeek = stackPeek,
+        .stackPop = stackPop,
+        .stackPush = stackPush,
+        .deleteStack = NULL,
+    };
+
+    bejEncode(&dictionaries, BEJ_DICTIONARY_START_AT_HEAD, bejMajorSchemaClass,
+              test_case.createResource(), &output, &stackCallbacks);
+
+    BejDecoderJson decoder;
+    EXPECT_THAT(decoder.decode(dictionaries, std::span(outputBuffer)), 0);
+    std::string decoded = decoder.getOutput();
+    nlohmann::json jsonDecoded = nlohmann::json::parse(decoded);
+
+    if (!test_case.expectedJson.empty())
+    {
+        inputsOrErr->expectedJson =
+            nlohmann::json::parse(test_case.expectedJson);
+    }
+    EXPECT_TRUE(jsonDecoded.dump() == inputsOrErr->expectedJson.dump());
+}
+
+TEST_P(BejEncoderTest, EncodeWrapper)
+{
+    const BejEncoderTestParams& test_case = GetParam();
+    auto inputsOrErr = loadInputs(test_case.inputFiles);
+    EXPECT_TRUE(inputsOrErr);
+
+    BejDictionaries dictionaries = {
+        .schemaDictionary = inputsOrErr->schemaDictionary,
+        .annotationDictionary = inputsOrErr->annotationDictionary,
+        .errorDictionary = inputsOrErr->errorDictionary,
+    };
+
+    libbej::BejEncoderJson encoder;
+    encoder.encode(&dictionaries, bejMajorSchemaClass,
+                   test_case.createResource());
+
+    std::vector<uint8_t> outputBuffer = encoder.getOutput();
+    BejDecoderJson decoder;
+    EXPECT_THAT(decoder.decode(dictionaries, std::span(outputBuffer)), 0);
+    std::string decoded = decoder.getOutput();
+    nlohmann::json jsonDecoded = nlohmann::json::parse(decoded);
+
+    if (!test_case.expectedJson.empty())
+    {
+        inputsOrErr->expectedJson =
+            nlohmann::json::parse(test_case.expectedJson);
+    }
+    EXPECT_TRUE(jsonDecoded.dump() == inputsOrErr->expectedJson.dump());
+
+    // Try using the same encoder object again to ensure that the same object
+    // does the encoding correctly
+    encoder.encode(&dictionaries, bejMajorSchemaClass,
+                   test_case.createResource());
+
+    outputBuffer = encoder.getOutput();
+
+    EXPECT_THAT(decoder.decode(dictionaries, std::span(outputBuffer)), 0);
+    decoded = decoder.getOutput();
+    jsonDecoded = nlohmann::json::parse(decoded);
+
+    if (!test_case.expectedJson.empty())
+    {
+        inputsOrErr->expectedJson =
+            nlohmann::json::parse(test_case.expectedJson);
+    }
+    EXPECT_TRUE(jsonDecoded.dump() == inputsOrErr->expectedJson.dump());
+}
+
+/**
+ * TODO: Add more test cases.
+ */
+
+INSTANTIATE_TEST_SUITE_P(
+    , BejEncoderTest,
+    testing::ValuesIn<BejEncoderTestParams>({
+        {"DriveOEM", driveOemTestFiles, driveOemJson, &createDriveOem},
+        {"DummySimple", dummySimpleTestFiles, "", &createDummyResource},
+        {"Chassis", chassisTestFiles, "", &createChassisResource},
+    }),
+    [](const testing::TestParamInfo<BejEncoderTest::ParamType>& info) {
+    return info.param.testName;
+});
+
+} // namespace libbej
diff --git a/test/dictionaries/chassis_dict.bin b/test/dictionaries/chassis_dict.bin
new file mode 100644
index 0000000..88b3b4d
--- /dev/null
+++ b/test/dictionaries/chassis_dict.bin
Binary files differ
diff --git a/test/encoded/chassis_enc.bin b/test/encoded/chassis_enc.bin
new file mode 100644
index 0000000..a4d4172
--- /dev/null
+++ b/test/encoded/chassis_enc.bin
Binary files differ
diff --git a/test/include/bej_common_test.hpp b/test/include/bej_common_test.hpp
new file mode 100644
index 0000000..74d8c83
--- /dev/null
+++ b/test/include/bej_common_test.hpp
@@ -0,0 +1,109 @@
+#include "bej_dictionary.h"
+#include "bej_encoder_core.h"
+#include "bej_tree.h"
+
+#include "nlohmann/json.hpp"
+
+#include <fstream>
+#include <iostream>
+#include <optional>
+#include <span>
+
+namespace libbej
+{
+
+// Buffer size for storing a single binary file data.
+constexpr uint32_t maxBufferSize = 16 * 1024;
+
+struct BejTestInputFiles
+{
+    const char* jsonFile;
+    const char* schemaDictionaryFile;
+    const char* annotationDictionaryFile;
+    const char* errorDictionaryFile;
+    const char* encodedStreamFile;
+};
+
+struct BejTestInputs
+{
+    nlohmann::json expectedJson;
+    const uint8_t* schemaDictionary;
+    const uint8_t* annotationDictionary;
+    const uint8_t* errorDictionary;
+    std::span<const uint8_t> encodedStream;
+};
+
+std::streamsize readBinaryFile(const char* fileName, std::span<uint8_t> buffer)
+{
+    std::ifstream inputStream(fileName, std::ios::binary);
+    if (!inputStream.is_open())
+    {
+        std::cerr << "Cannot open file: " << fileName << "\n";
+        return 0;
+    }
+    auto readLength = inputStream.readsome(
+        reinterpret_cast<char*>(buffer.data()), buffer.size_bytes());
+    if (inputStream.peek() != EOF)
+    {
+        std::cerr << "Failed to read the complete file: " << fileName
+                  << "  read length: " << readLength << "\n";
+        return 0;
+    }
+    return readLength;
+}
+
+std::optional<BejTestInputs> loadInputs(const BejTestInputFiles& files,
+                                        bool readErrorDictionary = false)
+{
+    std::ifstream jsonInput(files.jsonFile);
+    if (!jsonInput.is_open())
+    {
+        std::cerr << "Cannot open file: " << files.jsonFile << "\n";
+        return std::nullopt;
+    }
+    nlohmann::json expJson;
+    jsonInput >> expJson;
+
+    static uint8_t schemaDictBuffer[maxBufferSize];
+    if (readBinaryFile(files.schemaDictionaryFile,
+                       std::span(schemaDictBuffer, maxBufferSize)) == 0)
+    {
+        return std::nullopt;
+    }
+
+    static uint8_t annoDictBuffer[maxBufferSize];
+    if (readBinaryFile(files.annotationDictionaryFile,
+                       std::span(annoDictBuffer, maxBufferSize)) == 0)
+    {
+        return std::nullopt;
+    }
+
+    static uint8_t encBuffer[maxBufferSize];
+    auto encLen = readBinaryFile(files.encodedStreamFile,
+                                 std::span(encBuffer, maxBufferSize));
+    if (encLen == 0)
+    {
+        return std::nullopt;
+    }
+
+    static uint8_t errorDict[maxBufferSize];
+    if (readErrorDictionary)
+    {
+        if (readBinaryFile(files.errorDictionaryFile,
+                           std::span(errorDict, maxBufferSize)) == 0)
+        {
+            return std::nullopt;
+        }
+    }
+
+    BejTestInputs inputs = {
+        .expectedJson = expJson,
+        .schemaDictionary = schemaDictBuffer,
+        .annotationDictionary = annoDictBuffer,
+        .errorDictionary = errorDict,
+        .encodedStream = std::span(encBuffer, encLen),
+    };
+    return inputs;
+}
+
+} // namespace libbej
diff --git a/test/json/chassis.json b/test/json/chassis.json
new file mode 100644
index 0000000..40cc88d
--- /dev/null
+++ b/test/json/chassis.json
@@ -0,0 +1,34 @@
+{
+    "@odata.id": "/redfish/v1/Chassis/SomeChassis",
+    "Links": {
+        "ComputerSystems": [
+            {
+                "@odata.id": "/redfish/v1/Systems/system"
+            }
+        ],
+        "ContainedBy": {
+            "@odata.id": "/redfish/v1/Chassis/SomeOtherChassis"
+        },
+        "Contains": [
+            {
+                "@odata.id": "/redfish/v1/Chassis/Disk_0"
+            },
+            {
+                "@odata.id": "/redfish/v1/Chassis/Disk_1"
+            }
+        ],
+        "Contains@odata.count": 2,
+        "Storage": [
+            {
+                "@odata.id": "/redfish/v1/Systems/system/Storage/SATA"
+            }
+        ],
+        "Storage@odata.count": 1,
+        "Drives": [
+            {
+                "@odata.id": "/redfish/v1/Chassis/SomeChassis/Drives/SATA_0"
+            }
+        ],
+        "Drives@odata.count": 1
+    }
+}
diff --git a/test/meson.build b/test/meson.build
index a4ddfe1..c61ab8c 100644
--- a/test/meson.build
+++ b/test/meson.build
@@ -20,10 +20,14 @@
   'bej_common',
   'bej_dictionary',
   'bej_tree',
+  'bej_encoder'
 ]
+
+libbej_test_incs = include_directories('include')
 foreach t : gtests
   test(t, executable(t.underscorify(), t + '_test.cpp',
                      build_by_default: false,
                      implicit_include_directories: false,
+                     include_directories: libbej_test_incs,
                      dependencies: [libbej, gtest, gmock]))
 endforeach