1 files changed, 104 insertions, 0 deletions
diff --git a/backend/unittests/CodeGen/CompilationUnitTest.cpp b/backend/unittests/CodeGen/CompilationUnitTest.cpp
new file mode 100644
index 0000000..141d6db
--- /dev/null
+++ b/backend/unittests/CodeGen/CompilationUnitTest.cpp
@@ -0,0 +1,104 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+#include "rcc/CodeGen/CompilationUnit.h"
+
+#include "rcc/CodeGen/MachineFunction.h"
+
+#include <cstddef>
+#include <iostream>
+#include <utility>
+
+namespace {
+
+int fail(const char *Message) {
+  std::cerr << Message << '\n';
+  return 1;
+}
+
+} // namespace
+
+int main() {
+  rcc::CompilationUnit Unit;
+  auto FirstAnonymous = Unit.createMachineFunction("");
+  auto SecondAnonymous = Unit.createMachineFunction("");
+  if (!FirstAnonymous || !SecondAnonymous || Unit.functionCount() != 2 ||
+      (*FirstAnonymous)->stableID().value() != 1 || (*SecondAnonymous)->stableID().value() != 2 ||
+      Unit.function("") != nullptr)
+    return fail("CompilationUnit must retain anonymous functions by order and StableID");
+
+  auto First = Unit.createMachineFunction("first");
+  if (!First || (*First)->stableID().value() != 3)
+    return fail("CompilationUnit must allocate the first stable function identity");
+
+  auto Duplicate = Unit.createMachineFunction("first");
+  if (Duplicate || Unit.functionCount() != 3)
+    return fail("CompilationUnit must reject duplicate function names atomically");
+
+  auto Second = Unit.createMachineFunction("second");
+  if (!Second || (*Second)->stableID().value() != 4)
+    return fail("Rejected function creation must not consume a StableID");
+  if (Unit.functionCount() != 4 || Unit.functionAt(0) != *FirstAnonymous ||
+      Unit.functionAt(1) != *SecondAnonymous || Unit.functionAt(2) != *First ||
+      Unit.functionAt(3) != *Second)
+    return fail("CompilationUnit must preserve function document order");
+  if (Unit.function("first") != *First || Unit.function("missing") != nullptr)
+    return fail("CompilationUnit must provide exact name lookup");
+  if (Unit.function((*Second)->stableID()) != *Second ||
+      Unit.function(rcc::MachineFunctionStableID::fromValue(99)) != nullptr)
+    return fail("CompilationUnit must provide exact StableID lookup");
+  if (Unit.functionAt(4) != nullptr)
+    return fail("CompilationUnit must reject an out-of-range ordered lookup");
+
+  auto Zero = rcc::GlobalInitializer::zeroFill(4);
+  if (!Zero)
+    return fail("Global initializer creation must succeed");
+  rcc::GlobalObjectDesc Object;
+  Object.Symbol = "global";
+  Object.ObjectType = rcc::GenericConstantType::byte();
+  Object.Size = 4;
+  Object.Initializer.emplace(std::move(*Zero));
+  auto Global = Unit.addGlobalObject(std::move(Object));
+  if (!Global || Unit.globalObjectCount() != 1 || Unit.globalObject("global") != *Global ||
+      Unit.globalObjectAt(0) != *Global || Unit.globalObjectAt(1) != nullptr)
+    return fail("CompilationUnit must own and index global objects");
+
+  auto ConflictingFunction = Unit.createMachineFunction("global");
+  if (ConflictingFunction || Unit.functionCount() != 4)
+    return fail("CompilationUnit must reject function/global symbol conflicts atomically");
+
+  rcc::GlobalObjectDesc ConflictingGlobal;
+  ConflictingGlobal.Symbol = "first";
+  ConflictingGlobal.ObjectType = rcc::GenericConstantType::byte();
+  ConflictingGlobal.Size = 1;
+  auto Byte = rcc::GlobalInitializer::bytes({std::byte{1}});
+  if (!Byte)
+    return fail("Byte initializer creation must succeed");
+  ConflictingGlobal.Initializer.emplace(std::move(*Byte));
+  if (Unit.addGlobalObject(std::move(ConflictingGlobal)) || Unit.globalObjectCount() != 1)
+    return fail("CompilationUnit must reject global/function symbol conflicts atomically");
+
+  auto MismatchedBytes = rcc::GlobalInitializer::bytes({std::byte{1}, std::byte{2}});
+  if (!MismatchedBytes)
+    return fail("Mismatched initializer construction must succeed before object verification");
+  rcc::GlobalObjectDesc MismatchedObject;
+  MismatchedObject.Symbol = "mismatched";
+  MismatchedObject.ObjectType = rcc::GenericConstantType::byte();
+  MismatchedObject.Size = 1;
+  MismatchedObject.Initializer.emplace(std::move(*MismatchedBytes));
+  if (Unit.addGlobalObject(std::move(MismatchedObject)) || Unit.globalObjectCount() != 1)
+    return fail("CompilationUnit must reject mismatched global initializer sizes atomically");
+
+  auto Verification = Unit.verify();
+  if (!Verification)
+    return fail("A valid CompilationUnit must pass verification");
+
+  rcc::CompilationUnit Moved = std::move(Unit);
+  if (Moved.functionCount() != 4 || Moved.functionAt(0) != *FirstAnonymous ||
+      Moved.functionAt(1) != *SecondAnonymous || Moved.function("first") != *First ||
+      Moved.function("second") != *Second || Moved.globalObject("global") != *Global)
+    return fail("Moving a CompilationUnit must preserve owned object addresses and indices");
+  Verification = Moved.verify();
+  if (!Verification)
+    return fail("A moved CompilationUnit must pass verification");
+  return 0;
+}