Cleanup

Bigfoot/Tests/Engine/Asset/Asset.cpp

@@ -17,8 +17,6 @@
 #include <EngineTests/Asset/AssetB.hpp>
 #include <EngineTests/Asset/AssetC.hpp>
 
-#include <flatbuffers/minireflect.h>
-
 #include <gtest/gtest.h>
 
 namespace Bigfoot
@@ -218,6 +216,4 @@ TEST_F(AssetFixture, AssetCTests)
                                                      HardReference<AssetA> {assetAA.GetHeader().uuid}}));
     EXPECT_EQ(assetC.GetAsset().inner_table->asset_a_refs, assetC_dup.GetAsset().inner_table->asset_a_refs);
 }
-
-TEST_F(AssetFixture, MiniReflect) { }
 }   // namespace Bigfoot

Bigfoot/Tests/Engine/BigFile/BigFile.cpp

@@ -53,10 +53,12 @@ TEST_F(BigFileFixture, BigFileManipulation)
     UUID uuid2;
     UUID uuid3;
 
-    eastl::array<std::byte, 4> blob {std::byte {1}, std::byte {2}, std::byte {3}, std::byte {4}};
-    eastl::array<std::byte, 4> blob2 {std::byte {1}, std::byte {2}, std::byte {3}, std::byte {5}};
-    eastl::array<std::byte, 4> blob3 {std::byte {1}, std::byte {2}, std::byte {3}, std::byte {6}};
-    eastl::array<std::byte, 4> blob4 {std::byte {10}, std::byte {11}, std::byte {12}, std::byte {13}};
+    constexpr eastl::array<std::byte, 4> blob {std::byte {1}, std::byte {2}, std::byte {3}, std::byte {4}};
+    constexpr eastl::array<std::byte, 4> blob2 {std::byte {1}, std::byte {2}, std::byte {3}, std::byte {5}};
+    constexpr eastl::array<std::byte, 4> blob3 {std::byte {1}, std::byte {2}, std::byte {3}, std::byte {6}};
+    constexpr eastl::array<std::byte, 4> blob4 {std::byte {10}, std::byte {11}, std::byte {12}, std::byte {13}};
+
+    constexpr std::uint64_t typeIDRef = std::numeric_limits<std::uint64_t>::max() - 1;
 
     {
         BigFile::Request assetHeaderRequest {
@@ -64,7 +66,7 @@ TEST_F(BigFileFixture, BigFileManipulation)
           "INSERT INTO AssetHeader (UUID, Name, TypeID, TypeName) VALUES(?, ?, ?, ?)"};
         assetHeaderRequest.Bind(1, static_cast<std::span<const std::byte, UUID::UUID_BYTE_SIZE>>(uuid));
         assetHeaderRequest.Bind(2, "Test");
-        assetHeaderRequest.Bind(3, 42);
+        assetHeaderRequest.Bind(3, typeIDRef);
         assetHeaderRequest.Bind(4, "TypeTest");
 
         BigFile::Request assetRequest {m_bigFile, "INSERT INTO Asset (UUID, Asset) VALUES(?, ?)"};
@@ -76,7 +78,7 @@ TEST_F(BigFileFixture, BigFileManipulation)
           "INSERT INTO AssetHeader (UUID, Name, TypeID, TypeName) VALUES(?, ?, ?, ?)"};
         assetHeaderRequest2.Bind(1, static_cast<std::span<const std::byte, UUID::UUID_BYTE_SIZE>>(uuid2));
         assetHeaderRequest2.Bind(2, "Test2");
-        assetHeaderRequest2.Bind(3, 42);
+        assetHeaderRequest2.Bind(3, typeIDRef);
         assetHeaderRequest2.Bind(4, "TypeTest");
 
         BigFile::Request assetRequest2 {m_bigFile, "INSERT INTO Asset (UUID, Asset) VALUES(?, ?)"};
@@ -88,7 +90,7 @@ TEST_F(BigFileFixture, BigFileManipulation)
           "INSERT INTO AssetHeader (UUID, Name, TypeID, TypeName) VALUES(?, ?, ?, ?)"};
         assetHeaderRequest3.Bind(1, static_cast<std::span<const std::byte, UUID::UUID_BYTE_SIZE>>(uuid3));
         assetHeaderRequest3.Bind(2, "Test3");
-        assetHeaderRequest3.Bind(3, 42);
+        assetHeaderRequest3.Bind(3, typeIDRef);
         assetHeaderRequest3.Bind(4, "TypeTest");
 
         BigFile::Request assetRequest3 {m_bigFile, "INSERT INTO Asset (UUID, Asset) VALUES(?, ?)"};
@@ -96,20 +98,20 @@ TEST_F(BigFileFixture, BigFileManipulation)
         assetRequest3.Bind(2, blob4);
 
         m_bigFile.BeginTransaction();
-        [[maybe_unused]]
         std::uint32_t assetHeaderChangedCount = assetHeaderRequest.Execute();
-        [[maybe_unused]]
+        EXPECT_EQ(assetHeaderChangedCount, 1);
         std::uint32_t assetChangedCount = assetRequest.Execute();
+        EXPECT_EQ(assetChangedCount, 1);
 
-        [[maybe_unused]]
         std::uint32_t assetHeaderChangedCount2 = assetHeaderRequest2.Execute();
-        [[maybe_unused]]
+        EXPECT_EQ(assetHeaderChangedCount2, 1);
         std::uint32_t assetChangedCount2 = assetRequest2.Execute();
+        EXPECT_EQ(assetChangedCount2, 1);
 
-        [[maybe_unused]]
         std::uint32_t assetHeaderChangedCount3 = assetHeaderRequest3.Execute();
-        [[maybe_unused]]
+        EXPECT_EQ(assetHeaderChangedCount3, 1);
         std::uint32_t assetChangedCount3 = assetRequest3.Execute();
+        EXPECT_EQ(assetChangedCount3, 1);
 
         m_bigFile.CommitTransaction();
     }
@@ -120,8 +122,8 @@ TEST_F(BigFileFixture, BigFileManipulation)
         updateAsset.Bind(2, static_cast<std::span<const std::byte, UUID::UUID_BYTE_SIZE>>(uuid));
 
         m_bigFile.BeginTransaction();
-        [[maybe_unused]]
         std::uint32_t updateAssetChangedCount = updateAsset.Execute();
+        EXPECT_EQ(updateAssetChangedCount, 1);
         m_bigFile.CommitTransaction();
     }
 
@@ -131,53 +133,26 @@ TEST_F(BigFileFixture, BigFileManipulation)
           "SELECT Name, TypeID, TypeName, CreateTime, ModificationTime FROM AssetHeader WHERE UUID = ?"};
         request.Bind(1, static_cast<std::span<const std::byte, UUID::UUID_BYTE_SIZE>>(uuid));
 
-        [[maybe_unused]]
         const bool get = request.Step();
+        EXPECT_TRUE(get);
 
-        [[maybe_unused]]
         const eastl::string name {static_cast<eastl::string_view>(request.Get(0))};
-        [[maybe_unused]]
-        const std::uint32_t typeId = request.Get(1);
-        [[maybe_unused]]
+        EXPECT_STREQ(name.c_str(), "Test");
+        const std::uint64_t typeID = static_cast<std::uint64_t>(request.Get(1));
+        EXPECT_EQ(typeID, typeIDRef);
         const eastl::string typeName {static_cast<eastl::string_view>(request.Get(2))};
-        [[maybe_unused]]
-        const Time createTime = static_cast<std::int64_t>(request.Get(3));
-        [[maybe_unused]]
-        const Time modificationTime = static_cast<std::int64_t>(request.Get(4));
+        EXPECT_STREQ(typeName.c_str(), "TypeTest");
 
-        {
-            [[maybe_unused]]
-            const std::uint32_t year = createTime.Year();
-            [[maybe_unused]]
-            const std::uint32_t month = createTime.Month();
-            [[maybe_unused]]
-            const std::uint32_t day = createTime.Day();
-            [[maybe_unused]]
-            const std::uint32_t hour = createTime.Hour();
-            [[maybe_unused]]
-            const std::uint32_t minute = createTime.Minute();
-            [[maybe_unused]]
-            const std::uint32_t second = createTime.Second();
-            [[maybe_unused]]
-            const std::uint32_t microsecond = createTime.Microsecond();
-        }
+        const Time createTime = static_cast<std::uint64_t>(request.Get(3));
+        const Time modificationTime = static_cast<std::uint64_t>(request.Get(4));
 
-        {
-            [[maybe_unused]]
-            const std::uint32_t year = modificationTime.Year();
-            [[maybe_unused]]
-            const std::uint32_t month = modificationTime.Month();
-            [[maybe_unused]]
-            const std::uint32_t day = modificationTime.Day();
-            [[maybe_unused]]
-            const std::uint32_t hour = modificationTime.Hour();
-            [[maybe_unused]]
-            const std::uint32_t minute = modificationTime.Minute();
-            [[maybe_unused]]
-            const std::uint32_t second = modificationTime.Second();
-            [[maybe_unused]]
-            const std::uint32_t microsecond = modificationTime.Microsecond();
-        }
+        EXPECT_GT(createTime.Epoch(), 0);
+        EXPECT_GT(modificationTime.Epoch(), 0);
+
+        EXPECT_GE(createTime, modificationTime);
+
+        EXPECT_GT(createTime.Year(), 2025);
+        EXPECT_GT(modificationTime.Year(), 2025);
     }
 }
 }   // namespace Bigfoot

Bigfoot/Tests/Engine/Include/EngineTests/Asset/AssetA.hpp

@@ -27,12 +27,12 @@ class AssetA: public Asset<AssetATraits>
     {
     }
 
-    AssetA(const AssetA& p_asset) = default;
+    AssetA(const AssetA& p_asset) = delete;
     AssetA(AssetA&& p_asset) = default;
 
     ~AssetA() = default;
 
-    AssetA& operator=(const AssetA& p_asset) = default;
+    AssetA& operator=(const AssetA& p_asset) = delete;
     AssetA& operator=(AssetA&& p_asset) = default;
 };
 }   // namespace Bigfoot

Bigfoot/Tests/Engine/Include/EngineTests/Asset/AssetB.hpp

@@ -27,12 +27,12 @@ class AssetB: public Asset<AssetBTraits>
     {
     }
 
-    AssetB(const AssetB& p_asset) = default;
+    AssetB(const AssetB& p_asset) = delete;
     AssetB(AssetB&& p_asset) = default;
 
     ~AssetB() = default;
 
-    AssetB& operator=(const AssetB& p_asset) = default;
+    AssetB& operator=(const AssetB& p_asset) = delete;
     AssetB& operator=(AssetB&& p_asset) = default;
 };
 }   // namespace Bigfoot

Bigfoot/Tests/Engine/Include/EngineTests/Asset/AssetC.hpp

@@ -30,12 +30,12 @@ class AssetC: public Asset<AssetCTraits>
     {
     }
 
-    AssetC(const AssetC& p_asset) = default;
+    AssetC(const AssetC& p_asset) = delete;
     AssetC(AssetC&& p_asset) = default;
 
     ~AssetC() = default;
 
-    AssetC& operator=(const AssetC& p_asset) = default;
+    AssetC& operator=(const AssetC& p_asset) = delete;
     AssetC& operator=(AssetC&& p_asset) = default;
 };
 }   // namespace Bigfoot