diff --git a/tests/ir-tests.cpp b/tests/ir-tests.cpp
index 5041a23..fa1f9f3 100644
--- a/tests/ir-tests.cpp
+++ b/tests/ir-tests.cpp
@@ -8,24 +8,144 @@
 #include "gtest/gtest.h"
 #include "test-utils.hpp"
 #include <json.h>
+#include <nlohmann/json.hpp>
+#include <filesystem>
+#include <fstream>
 #include <libcper/cper-parse.h>
 #include <libcper/json-schema.h>
 #include <libcper/generator/cper-generate.h>
 #include <libcper/sections/cper-section.h>
 #include <libcper/generator/sections/gen-section.h>
 
+namespace fs = std::filesystem;
+
 /*
 * Test templates.
 */
+static const GEN_VALID_BITS_TEST_TYPE allValidbitsSet = ALL_VALID;
+static const GEN_VALID_BITS_TEST_TYPE fixedValidbitsSet = SOME_VALID;
+static const int GEN_EXAMPLES = 0;
+
+void cper_create_examples(const char *section_name)
+{
+	//Generate full CPER record for the given type.
+	fs::path file_path = LIBCPER_EXAMPLES;
+	file_path /= section_name;
+	fs::path cper_out = file_path.replace_extension("cper");
+	fs::path json_out = file_path.replace_extension("json");
+
+	char *buf;
+	size_t size;
+	FILE *record = generate_record_memstream(&section_name, 1, &buf, &size,
+						 0, fixedValidbitsSet);
+
+	// Write example CPER to disk
+	std::ofstream outFile(cper_out, std::ios::binary);
+	if (!outFile.is_open()) {
+		std::cerr << "Failed to create/open CPER output file: "
+			  << cper_out << std::endl;
+		return;
+	}
+
+	char buffer[1024];
+	size_t bytesRead;
+	while ((bytesRead = fread(buffer, 1, sizeof(buffer), record)) > 0) {
+		outFile.write(buffer, bytesRead);
+		if (!outFile) {
+			std::cerr << "Failed to write to output file."
+				  << std::endl;
+			outFile.close();
+			return;
+		}
+	}
+	outFile.close();
+
+	//Convert to IR, free resources.
+	rewind(record);
+	json_object *ir = cper_to_ir(record);
+	if (ir == NULL) {
+		std::cerr << "Empty JSON from CPER bin" << std::endl;
+		FAIL();
+		return;
+	}
+	char *str = strdup(json_object_to_json_string(ir));
+	nlohmann::json jsonData = nlohmann::json::parse(str, nullptr, false);
+	if (jsonData.is_discarded()) {
+		std::cerr << "cper_create_examples: JSON parse error:"
+			  << std::endl;
+	}
+	free(str);
+	fclose(record);
+	free(buf);
+
+	//Write json output to disk
+	std::ofstream jsonOutFile(json_out);
+	jsonOutFile << std::setw(4) << jsonData << std::endl;
+	jsonOutFile.close();
+}
+
+//Tests fixed CPER sections for IR validity with an example set.
+void cper_example_section_ir_test(const char *section_name)
+{
+	//Open CPER record for the given type.
+	fs::path fpath = LIBCPER_EXAMPLES;
+	fpath /= section_name;
+	fs::path cper = fpath.replace_extension("cper");
+	fs::path json = fpath.replace_extension("json");
+
+	// Do a C style read to obtain FILE*
+	FILE *record = fopen(cper.string().c_str(), "rb");
+	if (record == NULL) {
+		std::cerr
+			<< "cper_example_section_ir_test: File cannot be opened/does not exist "
+			<< cper << std::endl;
+		FAIL() << "cper_example_section_ir_test: File cannot be opened/does not exist";
+		return;
+	}
+
+	//Convert to IR, free resources.
+	json_object *ir = cper_to_ir(record);
+	if (ir == NULL) {
+		fclose(record);
+		std::cerr << "Empty JSON from CPER bin" << std::endl;
+		FAIL();
+		return;
+	}
+	const char *str = json_object_to_json_string(ir);
+	nlohmann::json jsonData = nlohmann::json::parse(str, nullptr, false);
+	if (jsonData.is_discarded()) {
+		std::cerr << "cper_example_section_ir_test: JSON parse error:"
+			  << std::endl;
+		FAIL() << "cper_example_section_ir_test: JSON parse error:";
+		fclose(record);
+		json_object_put(ir);
+
+		return;
+	}
+	fclose(record);
+
+	//Open json example file
+	nlohmann::json jGolden = loadJson(json.string().c_str());
+	if (jGolden.is_discarded()) {
+		std::cerr << "Could not open JSON example file: " << json
+			  << std::endl;
+		FAIL() << "Could not open JSON example file";
+	}
+
+	json_object_put(ir);
+
+	EXPECT_EQ(jGolden, jsonData);
+}
 
 //Tests a single randomly generated CPER section of the given type to ensure CPER-JSON IR validity.
-void cper_log_section_ir_test(const char *section_name, int single_section)
+void cper_log_section_ir_test(const char *section_name, int single_section,
+			      GEN_VALID_BITS_TEST_TYPE validBitsType)
 {
 	//Generate full CPER record for the given type.
 	char *buf;
 	size_t size;
 	FILE *record = generate_record_memstream(&section_name, 1, &buf, &size,
-						 single_section);
+						 single_section, validBitsType);
 
 	//Convert to IR, free resources.
 	json_object *ir;
@@ -34,13 +154,21 @@
 	} else {
 		ir = cper_to_ir(record);
 	}
+
+	char *str = strdup(json_object_to_json_string(ir));
+	nlohmann::json jsonData = nlohmann::json::parse(str, nullptr, false);
+	if (jsonData.is_discarded()) {
+		std::cerr << "Could not parse json output" << std::endl;
+	}
+	free(str);
 	fclose(record);
 	free(buf);
 
 	//Validate against schema.
-	char error_message[JSON_ERROR_MSG_MAX_LEN] = { 0 };
-	int valid =
-		validate_schema_from_file(LIBCPER_JSON_SPEC, ir, error_message);
+	std::string error_message;
+
+	int valid = schema_validate_from_file(LIBCPER_JSON_SPEC, jsonData,
+					      error_message);
 	json_object_put(ir);
 	ASSERT_TRUE(valid)
 		<< "IR validation test failed (single section mode = "
@@ -48,13 +176,19 @@
 }
 
 //Checks for binary round-trip equality for a given randomly generated CPER record.
-void cper_log_section_binary_test(const char *section_name, int single_section)
+void cper_log_section_binary_test(const char *section_name, int single_section,
+				  GEN_VALID_BITS_TEST_TYPE validBitsType)
 {
 	//Generate CPER record for the given type.
 	char *buf;
 	size_t size;
 	FILE *record = generate_record_memstream(&section_name, 1, &buf, &size,
-						 single_section);
+						 single_section, validBitsType);
+	if (record == NULL) {
+		std::cerr << "Could not generate memstream for binary test"
+			  << std::endl;
+		return;
+	}
 
 	//Convert to IR.
 	json_object *ir;
@@ -73,12 +207,12 @@
 	} else {
 		ir_to_cper(ir, stream);
 	}
-	size_t cper_len = ftell(stream);
 	fclose(stream);
 
-	//Validate the two are identical.
-	ASSERT_GE(size, cper_len);
-	ASSERT_EQ(memcmp(buf, cper_buf, cper_len), 0)
+	std::cout << "size: " << size << ", cper_buf_size: " << cper_buf_size
+		  << std::endl;
+	EXPECT_EQ(std::string_view(buf, size),
+		  std::string_view(cper_buf, std::min(size, cper_buf_size)))
 		<< "Binary output was not identical to input (single section mode = "
 		<< single_section << ").";
 
@@ -92,15 +226,17 @@
 //Tests randomly generated CPER sections for IR validity of a given type, in both single section mode and full CPER log mode.
 void cper_log_section_dual_ir_test(const char *section_name)
 {
-	cper_log_section_ir_test(section_name, 0);
-	cper_log_section_ir_test(section_name, 1);
+	cper_log_section_ir_test(section_name, 0, allValidbitsSet);
+	cper_log_section_ir_test(section_name, 1, allValidbitsSet);
+	//Validate against examples
+	cper_example_section_ir_test(section_name);
 }
 
 //Tests randomly generated CPER sections for binary compatibility of a given type, in both single section mode and full CPER log mode.
 void cper_log_section_dual_binary_test(const char *section_name)
 {
-	cper_log_section_binary_test(section_name, 0);
-	cper_log_section_binary_test(section_name, 1);
+	cper_log_section_binary_test(section_name, 0, allValidbitsSet);
+	cper_log_section_binary_test(section_name, 1, allValidbitsSet);
 }
 
 /*
@@ -316,6 +452,24 @@
 //Entrypoint for the testing program.
 int main()
 {
+	if (GEN_EXAMPLES) {
+		cper_create_examples("arm");
+		cper_create_examples("ia32x64");
+		cper_create_examples("memory");
+		cper_create_examples("memory2");
+		cper_create_examples("pcie");
+		cper_create_examples("firmware");
+		cper_create_examples("pcibus");
+		cper_create_examples("pcidev");
+		cper_create_examples("dmargeneric");
+		cper_create_examples("dmarvtd");
+		cper_create_examples("dmariommu");
+		cper_create_examples("ccixper");
+		cper_create_examples("cxlprotocol");
+		cper_create_examples("cxlcomponent-media");
+		cper_create_examples("nvidia");
+		cper_create_examples("unknown");
+	}
 	testing::InitGoogleTest();
 	return RUN_ALL_TESTS();
 }
diff --git a/tests/meson.build b/tests/meson.build
index 68eb1f3..d9e9d96 100644
--- a/tests/meson.build
+++ b/tests/meson.build
@@ -1,3 +1,5 @@
+cmake = import('cmake')
+
 gtest = dependency('gtest', main: true, disabler: true, required: false)
 gmock = dependency('gmock', disabler: true, required: false)
 if not gtest.found() or not gmock.found()
@@ -19,6 +21,23 @@
     endif
 endif
 
+nlohmann_json_dep = dependency(
+    'nlohmann_json',
+    required: false,
+    version: '>=3.11.2',
+    include_type: 'system',
+)
+if not nlohmann_json_dep.found()
+    nlohmann_proj = subproject('nlohmann_json', required: true)
+    nlohmann_json_dep = nlohmann_proj.get_variable('nlohmann_json_dep')
+endif
+
+valijson_dep = dependency('valijson', required: false)
+if not valijson_dep.found()
+    valijson_proj = cmake.subproject('valijson')
+    valijson_dep = valijson_proj.get_variable('valijson_dep')
+endif
+
 sources = ['ir-tests.cpp', 'test-utils.cpp', 'base64_test.cpp']
 
 test_include_dirs = ['.', '../include']
@@ -35,6 +54,8 @@
         json_c_dep,
         gtest,
         gmock,
+        nlohmann_json_dep,
+        valijson_dep
     ],
 )
 test('test-cper-tests', cper_tests)
diff --git a/tests/test-utils.cpp b/tests/test-utils.cpp
index e16413c..5b5925a 100644
--- a/tests/test-utils.cpp
+++ b/tests/test-utils.cpp
@@ -6,15 +6,45 @@
 
 #include <cstdio>
 #include <cstdlib>
+#include <fstream>
+#include <filesystem>
 #include "test-utils.hpp"
 
 #include <libcper/BaseTypes.h>
 #include <libcper/generator/cper-generate.h>
 
+namespace fs = std::filesystem;
+
+// Truly optional properties that shouldn't be added to "required" field for
+// validating the entire schema with validationbits=1
+const static std::map<std::string, std::vector<std::string> >
+	optional_properties_map = {
+		{ "./sections/cper-arm-processor.json",
+		  { "vendorSpecificInfo" } },
+		{ "./cper-json-section-log.json", { "header" } },
+		{ "./sections/cper-cxl-protocol.json",
+		  { "capabilityStructure", "deviceSerial" } },
+		{ "./sections/cper-generic-dmar.json",
+		  { "faultReason", "description" } },
+		{ "./sections/cper-cxl-component.json",
+		  { "cxlComponentEventLog" } },
+	};
+
+nlohmann::json loadJson(const char *filePath)
+{
+	std::ifstream file(filePath);
+	if (!file.is_open()) {
+		std::cerr << "Failed to open file: " << filePath << std::endl;
+	}
+	nlohmann::json out = nlohmann::json::parse(file, nullptr, false);
+	return out;
+}
+
 //Returns a ready-for-use memory stream containing a CPER record with the given sections inside.
 FILE *generate_record_memstream(const char **types, UINT16 num_types,
 				char **buf, size_t *buf_size,
-				int single_section)
+				int single_section,
+				GEN_VALID_BITS_TEST_TYPE validBitsType)
 {
 	//Open a memory stream.
 	FILE *stream = open_memstream(buf, buf_size);
@@ -22,13 +52,162 @@
 	//Generate a section to the stream, close & return.
 	if (!single_section) {
 		generate_cper_record(const_cast<char **>(types), num_types,
-				     stream);
+				     stream, validBitsType);
 	} else {
 		generate_single_section_record(const_cast<char *>(types[0]),
-					       stream);
+					       stream, validBitsType);
 	}
 	fclose(stream);
 
 	//Return fmemopen() buffer for reading.
 	return fmemopen(*buf, *buf_size, "r");
 }
+
+void iterate_make_required_props(nlohmann::json &jsonSchema,
+				 std::vector<std::string> &optional_props)
+{
+	//id
+	const auto it_id = jsonSchema.find("$id");
+	if (it_id != jsonSchema.end()) {
+		auto id_strptr = it_id->get_ptr<const std::string *>();
+		std::string id_str = *id_strptr;
+		if (id_str.find("header") != std::string::npos ||
+		    id_str.find("section-descriptor") != std::string::npos) {
+			return;
+		}
+	}
+	//oneOf
+	const auto it_oneof = jsonSchema.find("oneOf");
+	if (it_oneof != jsonSchema.end()) {
+		//Iterate over oneOf properties
+		for (auto &oneOfProp : *it_oneof) {
+			iterate_make_required_props(oneOfProp, optional_props);
+		}
+	}
+
+	//items
+	const auto it_items = jsonSchema.find("items");
+	if (it_items != jsonSchema.end()) {
+		iterate_make_required_props(*it_items, optional_props);
+	}
+	//required
+	const auto it_req = jsonSchema.find("required");
+	if (it_req == jsonSchema.end()) {
+		return;
+	}
+
+	//properties
+	const auto it_prop = jsonSchema.find("properties");
+	if (it_prop == jsonSchema.end()) {
+		return;
+	}
+	nlohmann::json &propertyFields = *it_prop;
+	nlohmann::json::array_t property_list;
+	if (propertyFields.is_object()) {
+		for (auto &[key, value] : propertyFields.items()) {
+			const auto it_find_opt_prop =
+				std::find(optional_props.begin(),
+					  optional_props.end(), key);
+			if (it_find_opt_prop == optional_props.end()) {
+				//Add to list if property is not optional
+				property_list.push_back(key);
+			}
+
+			iterate_make_required_props(value, optional_props);
+		}
+	}
+
+	*it_req = property_list;
+}
+
+// Document loader callback function
+const nlohmann::json *documentLoader(const std::string &uri)
+{
+	// Load the schema from a file
+	nlohmann::json *ref_schema = new nlohmann::json;
+	*ref_schema = loadJson(uri.c_str());
+	if (ref_schema->is_discarded()) {
+		std::cerr << "Could not open schema file: " << uri << std::endl;
+	}
+	std::vector<std::string> opt = {};
+	const auto it_optional_file = optional_properties_map.find(uri);
+	if (it_optional_file != optional_properties_map.end()) {
+		opt = it_optional_file->second;
+	}
+	iterate_make_required_props(*ref_schema, opt);
+
+	return ref_schema;
+}
+
+// Document release callback function
+void documentRelease(const nlohmann::json *adapter)
+{
+	delete adapter; // Free the adapter memory
+}
+
+int schema_validate_from_file(const char *schema_file_path,
+			      nlohmann::json &jsonData,
+			      std::string &error_message)
+{
+	// Load the schema
+	nlohmann::json schema_root = loadJson(schema_file_path);
+	if (schema_root.is_discarded()) {
+		std::cerr << "Could not open schema file: " << schema_file_path
+			  << std::endl;
+		return 0;
+	}
+
+	fs::path pathObj(schema_file_path);
+	fs::path base_path = pathObj.parent_path();
+	try {
+		fs::current_path(base_path);
+		// std::cout << "Changed directory to: " << fs::current_path()
+		// 	  << std::endl;
+	} catch (const fs::filesystem_error &e) {
+		std::cerr << "Filesystem error: " << e.what() << std::endl;
+	}
+
+	// Parse the json schema into an internal schema format
+	valijson::Schema schema;
+	valijson::SchemaParser parser;
+	valijson::adapters::NlohmannJsonAdapter schemaDocumentAdapter(
+		schema_root);
+
+	// Set up callbacks for resolving external references
+	try {
+		parser.populateSchema(schemaDocumentAdapter, schema,
+				      documentLoader, documentRelease);
+	} catch (std::exception &e) {
+		std::cerr << "Failed to parse schema: " << e.what()
+			  << std::endl;
+		return 0;
+	}
+
+	// Perform validation
+	valijson::Validator validator(valijson::Validator::kStrongTypes);
+	valijson::ValidationResults results;
+	valijson::adapters::NlohmannJsonAdapter targetDocumentAdapter(jsonData);
+	if (!validator.validate(schema, targetDocumentAdapter, &results)) {
+		std::cerr << "Validation failed." << std::endl;
+		valijson::ValidationResults::Error error;
+		unsigned int errorNum = 1;
+		while (results.popError(error)) {
+			std::string context;
+			std::vector<std::string>::iterator itr =
+				error.context.begin();
+			for (; itr != error.context.end(); itr++) {
+				context += *itr;
+			}
+
+			std::cout << "Error #" << errorNum << std::endl
+				  << "  context: " << context << std::endl
+				  << "  desc:    " << error.description
+				  << std::endl;
+			++errorNum;
+		}
+		return 0;
+	}
+
+	error_message = "Schema validation successful";
+	return 1;
+}
diff --git a/tests/test-utils.hpp b/tests/test-utils.hpp
index dd8ec6a..42e41bc 100644
--- a/tests/test-utils.hpp
+++ b/tests/test-utils.hpp
@@ -1,13 +1,24 @@
 #ifndef CPER_IR_TEST_UTILS_H
 #define CPER_IR_TEST_UTILS_H
 
+#include <valijson/adapters/nlohmann_json_adapter.hpp>
+#include <valijson/schema.hpp>
+#include <valijson/schema_parser.hpp>
+#include <valijson/validator.hpp>
+#include <nlohmann/json.hpp>
+
 extern "C" {
 #include <stdio.h>
 #include <libcper/BaseTypes.h>
+#include <libcper/generator/sections/gen-section.h>
 }
 
 FILE *generate_record_memstream(const char **types, UINT16 num_types,
 				char **buf, size_t *buf_size,
-				int single_section);
+				int single_section,
+				GEN_VALID_BITS_TEST_TYPE validBitsType);
+int schema_validate_from_file(const char *file_path, nlohmann::json &jsonData,
+			      std::string &error_message);
+nlohmann::json loadJson(const char *filePath);
 
 #endif