add yaml support for tests and glTF tests

.gitignore

@@ -66,6 +66,9 @@ exts/cesium.omniverse/certs/cacert.pem
 # Test output
 _testoutput
 
+# Test utils header has components generated by CMake
+tests/testUtils.h
+
 # Packman user files
 *.user
 

CMakeLists.txt

@@ -425,6 +425,7 @@ find_package(cpr)
 find_package(doctest)
 find_package(stb)
 find_package(ZLIB)
+find_package(yaml-cpp)
 
 # So that the installed libraries can find shared libraries in the same directory
 set(CMAKE_INSTALL_RPATH $ORIGIN)

ThirdParty.extra.json

@@ -6,5 +6,14 @@
         ],
         "version": "0.15.0",
         "url": "https://github.com/CesiumGS/cesium-native"
+    },
+    {
+        "name": "glTF-Asset-Generator",
+        "license": [
+            "MIT"
+        ],
+        "version": "0.6.1",
+        "url": "https://github.com/KhronosGroup/glTF-Asset-Generator",
+        "notes": "A selection of test models from this generator are used for testing."
     }
 ]

ThirdParty.json

@@ -15,6 +15,15 @@
         "version": "1.9.0",
         "url": "https://docs.libcpr.org/"
     },
+    {
+        "name": "glTF-Asset-Generator",
+        "license": [
+            "MIT"
+        ],
+        "version": "0.6.1",
+        "url": "https://github.com/KhronosGroup/glTF-Asset-Generator",
+        "notes": "A selection of test models from this generator are used for testing."
+    },
     {
         "name": "libcurl",
         "license": [
@@ -56,6 +65,14 @@
         "version": "cci.20220909",
         "url": "https://github.com/nothings/stb"
     },
+    {
+        "name": "yaml-cpp",
+        "license": [
+            "MIT"
+        ],
+        "version": "0.7.0",
+        "url": "https://github.com/jbeder/yaml-cpp"
+    },
     {
         "name": "zlib",
         "license": [

cmake/AddConanDependencies.cmake

@@ -10,6 +10,7 @@ set(REQUIRES
     "pybind11/2.10.1@#561736204506dad955276aaab438aab4"
     "stb/cci.20220909@#1c47474f095ef8cd9e4959558525b827"
     "zlib/1.2.13@#13c96f538b52e1600c40b88994de240f"
+    "yaml-cpp/0.7.0@#85b409c274a53d226b71f1bdb9cb4f8b"
     "libcurl/7.86.0@#88506b3234d553b90af1ceefc3dd1652"
     "nasm/2.15.05@#799d63b1672a337584b09635b0f22fc1")
 

src/core/CMakeLists.txt

@@ -37,11 +37,11 @@ setup_lib(
         CesiumUsdSchemas
         CesiumIonClient
         Cesium3DTilesSelection
-        CesiumAsync
         CesiumGeospatial
         CesiumGeometry
         CesiumGltf
         CesiumGltfReader
+        CesiumAsync
         CesiumJsonReader
         CesiumUtility
         async++

tests/CMakeLists.txt

@@ -2,6 +2,10 @@ include(Macros)
 
 glob_files(SOURCES "${CMAKE_CURRENT_LIST_DIR}/*.cpp")
 
+# replace a string in the utils header with the intended working dir for the test executable
+set(TEST_WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}")
+configure_file("${CMAKE_CURRENT_LIST_DIR}/testUtils.h.in" "${CMAKE_CURRENT_LIST_DIR}/testUtils.h")
+
 # cmake-format: off
 setup_app(
     TARGET_NAME
@@ -11,6 +15,7 @@ setup_app(
     LIBRARIES
         CesiumOmniverseCore
         doctest::doctest
+        yaml-cpp::yaml-cpp
     CXX_FLAGS
         ${CESIUM_OMNI_CXX_FLAGS}
     CXX_FLAGS_DEBUG

tests/ExampleTests.cpp

@@ -2,17 +2,27 @@
 * A collection of simple tests to demonstrate Doctest
 */
 
-#include "doctestUtils.h"
+#include "testUtils.h"
 
 #include <doctest/doctest.h>
 
+#include <array>
 #include <cstdint>
+#include <iostream>
 #include <list>
 #include <stdexcept>
+#include <vector>
+
+#include <yaml-cpp/yaml.h>
+
+const std::string CONFIG_PATH = "tests/configs/exampleConfig.yaml";
 
 // Test Suites are not required, but this sort of grouping makes it possible
 // to select which tests do/don't run via command line options
 TEST_SUITE("Example Tests") {
+    // ----------------------------------------------
+    //                   Basic Tests
+    // ----------------------------------------------
 
     TEST_CASE("The most basic test") {
         CHECK(1 + 1 == 2);
@@ -65,6 +75,52 @@ TEST_SUITE("Example Tests") {
         CHECK(item > 0);
     }
 
+    // ----------------------------------------------
+    //             YAML Config Examples
+    // ----------------------------------------------
+
+    std::string transmogrifier(const std::string& s) {
+        // an example function with differing output for some scenarios
+        if (s == "scenario2") {
+            return "bar";
+        }
+        return "foo";
+    }
+
+    void checkAgainstExpectedResults(const std::string& scenarioName, const YAML::Node& expectedResults) {
+
+        // we have to specify the type of the desired data from the config via as()
+        CHECK(3.14159 == expectedResults["pi"].as<double>());
+        CHECK(2 == expectedResults["onlyEvenPrime"].as<int>());
+
+        // as() does work for some non-scalar types, such as vectors, lists, and maps
+        // for adding custom types to the config, see:
+        // https://github.com/jbeder/yaml-cpp/wiki/Tutorial#converting-tofrom-native-data-types
+        const auto fib = expectedResults["fibonacciSeq"].as<std::vector<int>>();
+        CHECK(fib[2] + fib[3] == fib[4]);
+
+        // More complicated checks can be done with helper functions that take the scenario as input
+        CHECK(transmogrifier(scenarioName) == expectedResults["transmogrifierOutput"].as<std::string>());
+    }
+
+    TEST_CASE("Use a config file to detail multiple scenarios") {
+
+        YAML::Node configRoot = YAML::LoadFile(CONFIG_PATH);
+
+        // The config file has default parameters and
+        // an override for one or more scenarios
+        std::vector<std::string> scenarios = {"scenario1", "scenario2", "scenario3"};
+
+        for (const auto& s : scenarios) {
+            ConfigMap conf = getScenarioConfig(s, configRoot);
+            checkAgainstExpectedResults(s, conf);
+        }
+    }
+
+    // ----------------------------------------------
+    //                   Misc.
+    // ----------------------------------------------
+
     TEST_CASE("A few other useful macros") {
         // The most common test macro is CHECK, but others are available
         // Here are just a few

tests/GltfTests.cpp

@@ -0,0 +1,149 @@
+#include "testUtils.h"
+
+#include "cesium/omniverse/GltfAccessors.h"
+#include "cesium/omniverse/GltfUtil.h"
+
+#include <CesiumGltf/Material.h>
+#include <CesiumGltf/MeshPrimitive.h>
+#include <CesiumGltf/Model.h>
+#include <CesiumGltfReader/GltfReader.h>
+#include <doctest/doctest.h>
+
+#include <cstddef>
+#include <cstdio>
+#include <filesystem>
+#include <fstream>
+#include <iostream>
+#include <optional>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include <gsl/span>
+#include <yaml-cpp/yaml.h>
+
+using namespace cesium::omniverse;
+
+const std::string ASSET_DIR = "tests/testAssets/gltfs";
+const std::string CONFIG_PATH = "tests/configs/gltfConfig.yaml";
+
+// simplifies casting when comparing some material queries to expected output from config
+bool operator==(const pxr::GfVec3f& v3, const std::vector<float>& v) {
+    return v.size() == 3 && v3[0] == v[0] && v3[1] == v[1] && v3[2] == v[2];
+}
+
+TEST_SUITE("Test GltfUtil") {
+    void checkGltfExpectedResults(const std::filesystem::path& gltfFileName, const YAML::Node& expectedResults) {
+
+        // --- Load Gltf ---
+        std::ifstream gltfStream(gltfFileName, std::ifstream::binary);
+        gltfStream.seekg(0, std::ios::end);
+        auto gltfFileLength = gltfStream.tellg();
+        gltfStream.seekg(0, std::ios::beg);
+
+        std::vector<std::byte> gltfBuf(gltfFileLength);
+        gltfStream.read((char*)&gltfBuf[0], gltfFileLength);
+
+        CesiumGltfReader::GltfReader reader;
+        auto gltf = reader.readGltf(gsl::span(reinterpret_cast<const std::byte*>(gltfBuf.data()), gltfFileLength));
+
+        if (!gltf.errors.empty()) {
+            for (const auto& err : gltf.errors) {
+                std::cerr << err;
+            }
+            throw std::runtime_error("failed to parse model");
+        }
+
+        // gltf.model is a std::optional<CesiumGltf::Model>, make sure it exists
+        if (!(gltf.model && gltf.model->meshes.size() > 0)) {
+            throw std::runtime_error("test model is empty");
+        }
+
+        // --- Begin checks ---
+        const auto& prim = gltf.model->meshes[0].primitives[0];
+        const auto& model = *gltf.model;
+
+        CHECK(GltfUtil::hasNormals(model, prim, false) == expectedResults["hasNormals"].as<bool>());
+        CHECK(GltfUtil::hasTexcoords(model, prim, 0) == expectedResults["hasTexcoords"].as<bool>());
+        CHECK(GltfUtil::hasImageryTexcoords(model, prim, 0) == expectedResults["hasImageryTexcoords"].as<bool>());
+        CHECK(GltfUtil::hasVertexColors(model, prim, 0) == expectedResults["hasVertexColors"].as<bool>());
+        CHECK(GltfUtil::hasMaterial(prim) == expectedResults["hasMaterial"].as<bool>());
+        CHECK(GltfUtil::getDoubleSided(model, prim) == expectedResults["doubleSided"].as<bool>());
+
+        // material tests
+        if (GltfUtil::hasMaterial(prim)) {
+            const auto& mat = gltf.model->materials[0];
+            CHECK(GltfUtil::getAlphaMode(mat) == expectedResults["alphaMode"].as<int>());
+            CHECK(GltfUtil::getAlphaCutoff(mat) == expectedResults["alphaCutoff"].as<float>());
+            CHECK(GltfUtil::getBaseAlpha(mat) == expectedResults["baseAlpha"].as<float>());
+            CHECK(GltfUtil::getMetallicFactor(mat) == expectedResults["metallicFactor"].as<float>());
+            CHECK(GltfUtil::getRoughnessFactor(mat) == expectedResults["roughnessFactor"].as<float>());
+            CHECK(GltfUtil::getBaseColorTextureWrapS(model, mat) == expectedResults["baseColorTextureWrapS"].as<int>());
+            CHECK(GltfUtil::getBaseColorTextureWrapT(model, mat) == expectedResults["baseColorTextureWrapT"].as<int>());
+
+            CHECK(GltfUtil::getBaseColorFactor(mat) == expectedResults["baseColorFactor"].as<std::vector<float>>());
+            CHECK(GltfUtil::getEmissiveFactor(mat) == expectedResults["emissiveFactor"].as<std::vector<float>>());
+        }
+
+        // Accessor smoke tests
+        PositionsAccessor positions;
+        IndicesAccessor indices;
+        positions = GltfUtil::getPositions(model, prim);
+        CHECK(positions.size() > 0);
+        indices = GltfUtil::getIndices(model, prim, positions);
+        CHECK(indices.size() > 0);
+        if (GltfUtil::hasNormals(model, prim, false)) {
+            CHECK(GltfUtil::getNormals(model, prim, positions, indices, false).size() > 0);
+        }
+        if (GltfUtil::hasVertexColors(model, prim, 0)) {
+            CHECK(GltfUtil::getVertexColors(model, prim, 0).size() > 0);
+        }
+        if (GltfUtil::hasTexcoords(model, prim, 0)) {
+            CHECK(GltfUtil::getTexcoords(model, prim, 0).size() > 0);
+        }
+        if (GltfUtil::hasImageryTexcoords(model, prim, 0)) {
+            CHECK(GltfUtil::getImageryTexcoords(model, prim, 0).size() > 0);
+        }
+        CHECK(GltfUtil::getExtent(model, prim) != std::nullopt);
+    }
+
+    TEST_CASE("Default getter smoke tests") {
+
+        CHECK_NOTHROW(GltfUtil::getDefaultBaseAlpha());
+        CHECK_NOTHROW(GltfUtil::getDefaultBaseColorFactor());
+        CHECK_NOTHROW(GltfUtil::getDefaultMetallicFactor());
+        CHECK_NOTHROW(GltfUtil::getDefaultRoughnessFactor());
+        CHECK_NOTHROW(GltfUtil::getDefaultEmissiveFactor());
+        CHECK_NOTHROW(GltfUtil::getDefaultWrapS());
+        CHECK_NOTHROW(GltfUtil::getDefaultWrapT());
+        CHECK_NOTHROW(GltfUtil::getDefaultAlphaCutoff());
+        CHECK_NOTHROW(GltfUtil::getDefaultAlphaMode());
+    }
+
+    TEST_CASE("Check helper functions on various models") {
+
+        std::vector<std::string> gltfFiles;
+
+        // get list of gltf test files
+        for (auto const& i : std::filesystem::directory_iterator(ASSET_DIR)) {
+            std::filesystem::path fname = i.path().filename();
+            if (fname.extension() == ".gltf" || fname.extension() == ".glb") {
+                gltfFiles.push_back(fname.string());
+            }
+        }
+
+        // parse test config yaml
+        const auto configRoot = YAML::LoadFile(CONFIG_PATH);
+        const auto basePath = std::filesystem::path(ASSET_DIR);
+
+        for (auto const& fileName : gltfFiles) {
+            // attach filename to any failed checks
+            CAPTURE(fileName);
+
+            const auto conf = getScenarioConfig(fileName, configRoot);
+
+            // the / operator concatonates file paths
+            checkGltfExpectedResults(basePath / fileName, conf);
+        }
+    }
+}

tests/ObjectPoolTests.cpp

@@ -1,8 +1,7 @@
-#include "doctestUtils.h"
+#include "testUtils.h"
 
 #include <cesium/omniverse/ObjectPool.h>
 #include <doctest/doctest.h>
-#include <sys/types.h>
 
 #include <algorithm>
 #include <cstdint>

tests/configs/exampleConfig.yaml

@@ -0,0 +1,29 @@
+---
+
+
+# One way to use the config file is to generate multiple scenarios with
+# variations on some known parameters. If most of the scenarios have a
+# parameter at one particular value, it can make sense to establish that as
+# the default, then we only need to list the changes from that default.
+# See the gltf test config for a real use-case
+scenarios:
+  default:
+      # currently supported data types for the testUtils methods:
+      # float
+      pi : 3.14159
+      # int
+      onlyEvenPrime : 2
+      # string
+      transmogrifierOutput : "foo"
+      # sequence
+      fibonacciSeq :
+        - 1
+        - 1
+        - 2
+        - 3
+        - 5
+
+
+  # an example override for a given item
+  scenario2:
+      transmogrifierOutput : "bar"