/* SPDX-License-Identifier: GPL-2.0-or-later */ /* * Copyright (C) 2022, Google Inc. * * yaml-parser.cpp - YAML parser operations tests */ #include <array> #include <iostream> #include <map> #include <string> #include <unistd.h> #include <libcamera/base/file.h> #include <libcamera/base/utils.h> #include "libcamera/internal/yaml_parser.h" #include "test.h" using namespace libcamera; using namespace std; static const string testYaml = "string: libcamera\n" "double: 3.14159\n" "int8_t: -100\n" "uint8_t: 100\n" "int16_t: -1000\n" "uint16_t: 1000\n" "int32_t: -100000\n" "uint32_t: 100000\n" "size: [1920, 1080]\n" "list:\n" " - James\n" " - Mary\n" "dictionary:\n" " a: 1\n" " c: 3\n" " b: 2\n" "level1:\n" " level2:\n" " - [1, 2]\n" " - {one: 1, two: 2}\n"; static const string invalidYaml = "Invalid : - YAML : - Content"; class YamlParserTest : public Test { protected: bool createFile(const string &content, string &filename) { filename = "/tmp/libcamera.test.XXXXXX"; int fd = mkstemp(&filename.front()); if (fd == -1) return false; int ret = write(fd, content.c_str(), content.size()); close(fd); if (ret != static_cast<int>(content.size())) return false; return true; } int init() { if (!createFile(testYaml, testYamlFile_)) return TestFail; if (!createFile(invalidYaml, invalidYamlFile_)) return TestFail; return TestPass; } enum class Type { String, Int8, UInt8, Int16, UInt16, Int32, UInt32, Double, Size, List, Dictionary, }; int testObjectType(const YamlObject &obj, const char *name, Type type) { bool isList = type == Type::List || type == Type::Size; bool isScalar = !isList && type != Type::Dictionary; bool isInteger8 = type == Type::Int8 || type == Type::UInt8; bool isInteger16 = type == Type::Int16 || type == Type::UInt16; bool isInteger32 = type == Type::Int32 || type == Type::UInt32; bool isIntegerUpTo16 = isInteger8 || isInteger16; bool isIntegerUpTo32 = isIntegerUpTo16 || isInteger32; bool isSigned = type == Type::Int8 || type == Type::Int16 || type == Type::Int32; if ((isScalar && !obj.isValue()) || (!isScalar && obj.isValue())) { std::cerr << "Object " << name << " type mismatch when compared to " << "value" << std::endl; return TestFail; } if ((isList && !obj.isList()) || (!isList && obj.isList())) { std::cerr << "Object " << name << " type mismatch when compared to " << "list" << std::endl; return TestFail; } if ((type == Type::Dictionary && !obj.isDictionary()) || (type != Type::Dictionary && obj.isDictionary())) { std::cerr << "Object " << name << " type mismatch when compared to " << "dictionary" << std::endl; return TestFail; } if (!isScalar && obj.get<std::string>()) { std::cerr << "Object " << name << " didn't fail to parse as " << "string" << std::endl; return TestFail; } if (!isInteger8 && obj.get<int8_t>()) { std::cerr << "Object " << name << " didn't fail to parse as " << "int8_t" << std::endl; return TestFail; } if ((!isInteger8 || isSigned) && obj.get<uint8_t>()) { std::cerr << "Object " << name << " didn't fail to parse as " << "uint8_t" << std::endl; return TestFail; } if (!isIntegerUpTo16 && obj.get<int16_t>()) { std::cerr << "Object " << name << " didn't fail to parse as " << "int16_t" << std::endl; return TestFail; } if ((!isIntegerUpTo16 || isSigned) && obj.get<uint16_t>()) { std::cerr << "Object " << name << " didn't fail to parse as " << "uint16_t" << std::endl; return TestFail; } if (!isIntegerUpTo32 && obj.get<int32_t>()) { std::cerr << "Object " << name << " didn't fail to parse as " << "int32_t" << std::endl; return TestFail; } if ((!isIntegerUpTo32 || isSigned) && obj.get<uint32_t>()) { std::cerr << "Object " << name << " didn't fail to parse as " << "uint32_t" << std::endl; return TestFail; } if (!isIntegerUpTo32 && type != Type::Double && obj.get<double>()) { std::cerr << "Object " << name << " didn't fail to parse as " << "double" << std::endl; return TestFail; } if (type != Type::Size && obj.get<Size>()) { std::cerr << "Object " << name << " didn't fail to parse as " << "Size" << std::endl; return TestFail; } return TestPass; } int testIntegerObject(const YamlObject &obj, const char *name, Type type, int64_t value) { uint64_t unsignedValue = static_cast<uint64_t>(value); std::string strValue = std::to_string(value); bool isInteger8 = type == Type::Int8 || type == Type::UInt8; bool isInteger16 = type == Type::Int16 || type == Type::UInt16; bool isSigned = type == Type::Int8 || type == Type::Int16 || type == Type::Int32; /* All integers can be parsed as strings or double. */ if (obj.get<string>().value_or("") != strValue || obj.get<string>("") != strValue) { std::cerr << "Object " << name << " failed to parse as " << "string" << std::endl; return TestFail; } if (obj.get<double>().value_or(0.0) != value || obj.get<double>(0.0) != value) { std::cerr << "Object " << name << " failed to parse as " << "double" << std::endl; return TestFail; } if (isInteger8) { if (obj.get<int8_t>().value_or(0) != value || obj.get<int8_t>(0) != value) { std::cerr << "Object " << name << " failed to parse as " << "int8_t" << std::endl; return TestFail; } } if (isInteger8 && !isSigned) { if (obj.get<uint8_t>().value_or(0) != unsignedValue || obj.get<uint8_t>(0) != unsignedValue) { std::cerr << "Object " << name << " failed to parse as " << "uint8_t" << std::endl; return TestFail; } } if (isInteger8 || isInteger16) { if (obj.get<int16_t>().value_or(0) != value || obj.get<int16_t>(0) != value) { std::cerr << "Object " << name << " failed to parse as " << "int16_t" << std::endl; return TestFail; } } if ((isInteger8 || isInteger16) && !isSigned) { if (obj.get<uint16_t>().value_or(0) != unsignedValue || obj.get<uint16_t>(0) != unsignedValue) { std::cerr << "Object " << name << " failed to parse as " << "uint16_t" << std::endl; return TestFail; } } if (obj.get<int32_t>().value_or(0) != value || obj.get<int32_t>(0) != value) { std::cerr << "Object " << name << " failed to parse as " << "int32_t" << std::endl; return TestFail; } if (!isSigned) { if (obj.get<uint32_t>().value_or(0) != unsignedValue || obj.get<uint32_t>(0) != unsignedValue) { std::cerr << "Object " << name << " failed to parse as " << "uint32_t" << std::endl; return TestFail; } } return TestPass; } int run() { /* Test invalid YAML file */ File file{ invalidYamlFile_ }; if (!file.open(File::OpenModeFlag::ReadOnly)) { cerr << "Fail to open invalid YAML file" << std::endl; return TestFail; } std::unique_ptr<YamlObject> root = YamlParser::parse(file); if (root) { cerr << "Invalid YAML file parse successfully" << std::endl; return TestFail; } /* Test YAML file */ file.close(); file.setFileName(testYamlFile_); if (!file.open(File::OpenModeFlag::ReadOnly)) { cerr << "Fail to open test YAML file" << std::endl; return TestFail; } root = YamlParser::parse(file); if (!root) { cerr << "Fail to parse test YAML file: " << std::endl; return TestFail; } if (!root->isDictionary()) { cerr << "YAML root is not dictionary" << std::endl; return TestFail; } std::vector<const char *> rootElemNames = { "string", "double", "int8_t", "uint8_t", "int16_t", "uint16_t", "int32_t", "uint32_t", "size", "list", "dictionary", "level1", }; for (const char *name : rootElemNames) { if (!root->contains(name)) { cerr << "Missing " << name << " object in YAML root" << std::endl; return TestFail; } } /* Test string object */ auto &strObj = (*root)["string"]; if (testObjectType(strObj, "string", Type::String) != TestPass) return TestFail; if (strObj.get<string>().value_or("") != "libcamera" || strObj.get<string>("") != "libcamera") { cerr << "String object parse as wrong content" << std::endl; return TestFail; } /* Test int8_t object */ auto &int8Obj = (*root)["int8_t"]; if (testObjectType(int8Obj, "int8_t", Type::Int8) != TestPass) return TestFail; if (testIntegerObject(int8Obj, "int8_t", Type::Int8, -100) != TestPass) return TestFail; /* Test uint8_t object */ auto &uint8Obj = (*root)["uint8_t"]; if (testObjectType(uint8Obj, "uint8_t", Type::UInt8) != TestPass) return TestFail; if (testIntegerObject(uint8Obj, "uint8_t", Type::UInt8, 100) != TestPass) return TestFail; /* Test int16_t object */ auto &int16Obj = (*root)["int16_t"]; if (testObjectType(int16Obj, "int16_t", Type::Int16) != TestPass) return TestFail; if (testIntegerObject(int16Obj, "int16_t", Type::Int16, -1000) != TestPass) return TestFail; /* Test uint16_t object */ auto &uint16Obj = (*root)["uint16_t"]; if (testObjectType(uint16Obj, "uint16_t", Type::UInt16) != TestPass) return TestFail; if (testIntegerObject(uint16Obj, "uint16_t", Type::UInt16, 1000) != TestPass) return TestFail; /* Test int32_t object */ auto &int32Obj = (*root)["int32_t"]; if (testObjectType(int32Obj, "int32_t", Type::Int32) != TestPass) return TestFail; if (testIntegerObject(int32Obj, "int32_t", Type::Int32, -100000) != TestPass) return TestFail; /* Test uint32_t object */ auto &uint32Obj = (*root)["uint32_t"]; if (testObjectType(uint32Obj, "uint32_t", Type::UInt32) != TestPass) return TestFail; if (testIntegerObject(uint32Obj, "uint32_t", Type::UInt32, 100000) != TestPass) return TestFail; /* Test double value */ auto &doubleObj = (*root)["double"]; if (testObjectType(doubleObj, "double", Type::Double) != TestPass) return TestFail; if (doubleObj.get<string>().value_or("") != "3.14159" || doubleObj.get<string>("") != "3.14159") { cerr << "Double object fail to parse as string" << std::endl; return TestFail; } if (doubleObj.get<double>().value_or(0.0) != 3.14159 || doubleObj.get<double>(0.0) != 3.14159) { cerr << "Double object parse as wrong value" << std::endl; return TestFail; } /* Test Size value */ auto &sizeObj = (*root)["size"]; if (testObjectType(sizeObj, "size", Type::Size) != TestPass) return TestFail; if (sizeObj.get<Size>().value_or(Size(0, 0)) != Size(1920, 1080) || sizeObj.get<Size>(Size(0, 0)) != Size(1920, 1080)) { cerr << "Size object parse as wrong value" << std::endl; return TestFail; } /* Test list object */ auto &listObj = (*root)["list"]; if (testObjectType(listObj, "list", Type::List) != TestPass) return TestFail; static constexpr std::array<const char *, 2> listValues{ "James", "Mary", }; if (listObj.size() != listValues.size()) { cerr << "List object parse with wrong size" << std::endl; return TestFail; } unsigned int i = 0; for (auto &elem : listObj.asList()) { if (i >= listValues.size()) { std::cerr << "Too many elements in list during iteration" << std::endl; return TestFail; } std::string value = listValues[i]; if (&elem != &listObj[i]) { std::cerr << "List element " << i << " has wrong address" << std::endl; return TestFail; } if (elem.get<std::string>("") != value) { std::cerr << "List element " << i << " has wrong value" << std::endl; return TestFail; } i++; } /* Test dictionary object */ auto &dictObj = (*root)["dictionary"]; if (testObjectType(dictObj, "dictionary", Type::Dictionary) != TestPass) return TestFail; static constexpr std::array<std::pair<const char *, int>, 3> dictValues{ { { "a", 1 }, { "c", 3 }, { "b", 2 }, } }; size_t dictSize = dictValues.size(); if (dictObj.size() != dictSize) { cerr << "Dictionary object has wrong size" << std::endl; return TestFail; } i = 0; for (const auto &[key, elem] : dictObj.asDict()) { if (i >= dictSize) { std::cerr << "Too many elements in dictionary during iteration" << std::endl; return TestFail; } const auto &item = dictValues[i]; if (item.first != key) { std::cerr << "Dictionary key " << i << " has wrong value" << std::endl; return TestFail; } if (&elem != &dictObj[key]) { std::cerr << "Dictionary element " << i << " has wrong address" << std::endl; return TestFail; } if (elem.get<int32_t>(0) != item.second) { std::cerr << "Dictionary element " << i << " has wrong value" << std::endl; return TestFail; } i++; } /* Make sure utils::map_keys() works on the adapter. */ (void)utils::map_keys(dictObj.asDict()); /* Test leveled objects */ auto &level1Obj = (*root)["level1"]; if (!level1Obj.isDictionary()) { cerr << "level1 object fail to parse as Dictionary" << std::endl; return TestFail; } auto &level2Obj = level1Obj["level2"]; if (!level2Obj.isList() || level2Obj.size() != 2) { cerr << "level2 object should be 2 element list" << std::endl; return TestFail; } auto &firstElement = level2Obj[0]; if (!firstElement.isList() || firstElement.size() != 2 || firstElement[0].get<int32_t>(0) != 1 || firstElement[1].get<int32_t>(0) != 2) { cerr << "The first element of level2 object fail to parse as integer list" << std::endl; return TestFail; } const auto &values = firstElement.getList<uint16_t>(); if (!values || values->size() != 2 || (*values)[0] != 1 || (*values)[1] != 2) { cerr << "getList() failed to return correct vector" << std::endl; return TestFail; } auto &secondElement = level2Obj[1]; if (!secondElement.isDictionary() || !secondElement.contains("one") || !secondElement.contains("two") || secondElement["one"].get<int32_t>(0) != 1 || secondElement["two"].get<int32_t>(0) != 2) { cerr << "The second element of level2 object fail to parse as dictionary" << std::endl; return TestFail; } return TestPass; } void cleanup() { unlink(testYamlFile_.c_str()); unlink(invalidYamlFile_.c_str()); } private: std::string testYamlFile_; std::string invalidYamlFile_; }; TEST_REGISTER(YamlParserTest)