Test the rest of the worker protocol serializers

Part of the `BuildResult` test is commented out because we have caught a
roundtrip bug! A future PR will fix the bug and uncomment that test.

src/libstore/build-result.cc

@@ -0,0 +1,18 @@
+#include "build-result.hh"
+
+namespace nix {
+
+GENERATE_CMP_EXT(
+    ,
+    BuildResult,
+    me->status,
+    me->errorMsg,
+    me->timesBuilt,
+    me->isNonDeterministic,
+    me->builtOutputs,
+    me->startTime,
+    me->stopTime,
+    me->cpuUser,
+    me->cpuSystem);
+
+}

src/libstore/build-result.hh

@@ -3,6 +3,7 @@
 
 #include "realisation.hh"
 #include "derived-path.hh"
+#include "comparator.hh"
 
 #include <string>
 #include <chrono>
@@ -100,6 +101,8 @@ struct BuildResult
      */
     std::optional<std::chrono::microseconds> cpuUser, cpuSystem;
 
+    DECLARE_CMP(BuildResult);
+
     bool success()
     {
         return status == Built || status == Substituted || status == AlreadyValid || status == ResolvesToAlreadyValid;

src/libstore/tests/worker-protocol.cc

@@ -6,6 +6,7 @@
 #include "worker-protocol.hh"
 #include "worker-protocol-impl.hh"
 #include "derived-path.hh"
+#include "build-result.hh"
 #include "tests/libstore.hh"
 
 namespace nix {
@@ -136,4 +137,192 @@ CHARACTERIZATION_TEST(
         },
     }))
 
+CHARACTERIZATION_TEST(
+    drvOutput,
+    "drv-output",
+    (std::tuple<DrvOutput, DrvOutput> {
+        {
+            .drvHash = Hash::parseSRI("sha256-FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc="),
+            .outputName = "baz",
+        },
+        DrvOutput {
+            .drvHash = Hash::parseSRI("sha256-b4afnqKCO9oWXgYHb9DeQ2berSwOjS27rSd9TxXDc/U="),
+            .outputName = "quux",
+        },
+    }))
+
+CHARACTERIZATION_TEST(
+    realisation,
+    "realisation",
+    (std::tuple<Realisation, Realisation> {
+        Realisation {
+            .id = DrvOutput {
+                .drvHash = Hash::parseSRI("sha256-FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc="),
+                .outputName = "baz",
+            },
+            .outPath = StorePath { "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo" },
+            .signatures = { "asdf", "qwer" },
+        },
+        Realisation {
+            .id = {
+                .drvHash = Hash::parseSRI("sha256-FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc="),
+                .outputName = "baz",
+            },
+            .outPath = StorePath { "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo" },
+            .signatures = { "asdf", "qwer" },
+            .dependentRealisations = {
+                {
+                    DrvOutput {
+                        .drvHash = Hash::parseSRI("sha256-b4afnqKCO9oWXgYHb9DeQ2berSwOjS27rSd9TxXDc/U="),
+                        .outputName = "quux",
+                    },
+                    StorePath { "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo" },
+                },
+            },
+        },
+    }))
+
+CHARACTERIZATION_TEST(
+    buildResult,
+    "build-result",
+    ({
+        using namespace std::literals::chrono_literals;
+        std::tuple<BuildResult, BuildResult/*, BuildResult*/> t {
+            BuildResult {
+                .status = BuildResult::OutputRejected,
+                .errorMsg = "no idea why",
+            },
+            BuildResult {
+                .status = BuildResult::NotDeterministic,
+                .errorMsg = "no idea why",
+                .timesBuilt = 3,
+                .isNonDeterministic = true,
+                .startTime = 30,
+                .stopTime = 50,
+            },
+#if 0
+            // This is commented because this test would fail!
+            // FIXME uncomment this and fix the underlying bug.
+            BuildResult {
+                .status = BuildResult::Built,
+                .timesBuilt = 1,
+                .builtOutputs = {
+                    {
+                        "foo",
+                        {
+                            .id = DrvOutput {
+                                .drvHash = Hash::parseSRI("sha256-b4afnqKCO9oWXgYHb9DeQ2berSwOjS27rSd9TxXDc/U="),
+                                .outputName = "foo",
+                            },
+                            .outPath = StorePath { "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo" },
+                        },
+                    },
+                    {
+                        "bar",
+                        {
+                            .id = DrvOutput {
+                                .drvHash = Hash::parseSRI("sha256-b4afnqKCO9oWXgYHb9DeQ2berSwOjS27rSd9TxXDc/U="),
+                                .outputName = "bar",
+                            },
+                            .outPath = StorePath { "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar" },
+                        },
+                    },
+                },
+                .startTime = 30,
+                .stopTime = 50,
+                .cpuUser = std::chrono::milliseconds(500s),
+                .cpuSystem = std::chrono::milliseconds(604s),
+            },
+#endif
+        };
+        t;
+    }))
+
+CHARACTERIZATION_TEST(
+    keyedBuildResult,
+    "keyed-build-result",
+    ({
+        using namespace std::literals::chrono_literals;
+        std::tuple<KeyedBuildResult, KeyedBuildResult/*, KeyedBuildResult*/> t {
+            KeyedBuildResult {
+                {
+                    .status = KeyedBuildResult::OutputRejected,
+                    .errorMsg = "no idea why",
+                },
+                /* .path = */ DerivedPath::Opaque {
+                    StorePath { "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-xxx" },
+                },
+            },
+            KeyedBuildResult {
+                {
+                    .status = KeyedBuildResult::NotDeterministic,
+                    .errorMsg = "no idea why",
+                    .timesBuilt = 3,
+                    .isNonDeterministic = true,
+                    .startTime = 30,
+                    .stopTime = 50,
+                },
+                /* .path = */ DerivedPath::Built {
+                    .drvPath = makeConstantStorePathRef(StorePath {
+                        "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar.drv",
+                    }),
+                    .outputs = OutputsSpec::Names { "out" },
+                },
+            },
+        };
+        t;
+    }))
+
+CHARACTERIZATION_TEST(
+    optionalTrustedFlag,
+    "optional-trusted-flag",
+    (std::tuple<std::optional<TrustedFlag>, std::optional<TrustedFlag>, std::optional<TrustedFlag>> {
+        std::nullopt,
+        std::optional { Trusted },
+        std::optional { NotTrusted },
+    }))
+
+CHARACTERIZATION_TEST(
+    vector,
+    "vector",
+    (std::tuple<std::vector<std::string>, std::vector<std::string>, std::vector<std::string>, std::vector<std::vector<std::string>>> {
+        { },
+        { "" },
+        { "", "foo", "bar" },
+        { {}, { "" }, { "", "1", "2" } },
+    }))
+
+CHARACTERIZATION_TEST(
+    set,
+    "set",
+    (std::tuple<std::set<std::string>, std::set<std::string>, std::set<std::string>, std::set<std::set<std::string>>> {
+        { },
+        { "" },
+        { "", "foo", "bar" },
+        { {}, { "" }, { "", "1", "2" } },
+    }))
+
+CHARACTERIZATION_TEST(
+    optionalStorePath,
+    "optional-store-path",
+    (std::tuple<std::optional<StorePath>, std::optional<StorePath>> {
+        std::nullopt,
+        std::optional {
+            StorePath { "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo-bar" },
+        },
+    }))
+
+CHARACTERIZATION_TEST(
+    optionalContentAddress,
+    "optional-content-address",
+    (std::tuple<std::optional<ContentAddress>, std::optional<ContentAddress>> {
+        std::nullopt,
+        std::optional {
+            ContentAddress {
+                .method = FileIngestionMethod::Flat,
+                .hash = hashString(HashType::htSHA1, "blob blob..."),
+            },
+        },
+    }))
+
 }

src/libstore/worker-protocol.hh

@@ -208,10 +208,10 @@ MAKE_WORKER_PROTO(ContentAddress);
 template<>
 MAKE_WORKER_PROTO(DerivedPath);
 template<>
-MAKE_WORKER_PROTO(Realisation);
-template<>
 MAKE_WORKER_PROTO(DrvOutput);
 template<>
+MAKE_WORKER_PROTO(Realisation);
+template<>
 MAKE_WORKER_PROTO(BuildResult);
 template<>
 MAKE_WORKER_PROTO(KeyedBuildResult);