Remove validation bits
Discard invalid properties from json decode. JSON output should only
contain valid properties. This saves time in preventing post
processing of output for valid fields.
Ensure round trip validity with validation bits removed and required
properties populated.
Fix bugs in json decode.
Overhaul unit tests to use valijson. Add tests with static examples
to validate against schema. Use and nlohmann for better schema
validation over intrinsic libcper validation.
Example json output before:
{
"ValidationBits": {
"LevelValid": false,
"CorrectedValid": true
},
"Level": 1,
"Corrected": true
}
After:
{
"Corrected": true
}
Change-Id: I188bdc2827a57d938c22a431238fadfcdc939ab8
Signed-off-by: Aushim Nagarkatti <anagarkatti@nvidia.com>
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(§ion_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(§ion_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(§ion_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