Move unit tests to the location Meson expects them to be

Everything that is a separate subproject should live in the subprojects
directory.

Progress on #2503

This reverts commit 451f8a8c19.

src/libstore-tests/.version

@@ -0,0 +1 @@
+../../.version

src/libstore-tests/build-utils-meson

@@ -0,0 +1 @@
+../../build-utils-meson

src/libstore-tests/common-protocol.cc

@@ -0,0 +1,187 @@
+#include <regex>
+
+#include <nlohmann/json.hpp>
+#include <gtest/gtest.h>
+
+#include "common-protocol.hh"
+#include "common-protocol-impl.hh"
+#include "build-result.hh"
+#include "tests/protocol.hh"
+#include "tests/characterization.hh"
+
+namespace nix {
+
+const char commonProtoDir[] = "common-protocol";
+
+class CommonProtoTest : public ProtoTest<CommonProto, commonProtoDir>
+{
+public:
+    /**
+     * Golden test for `T` reading
+     */
+    template<typename T>
+    void readProtoTest(PathView testStem, const T & expected)
+    {
+        CharacterizationTest::readTest(testStem, [&](const auto & encoded) {
+            T got = ({
+                StringSource from { encoded };
+                CommonProto::Serialise<T>::read(
+                    *store,
+                    CommonProto::ReadConn { .from = from });
+            });
+
+            ASSERT_EQ(got, expected);
+        });
+    }
+
+    /**
+     * Golden test for `T` write
+     */
+    template<typename T>
+    void writeProtoTest(PathView testStem, const T & decoded)
+    {
+        CharacterizationTest::writeTest(testStem, [&]() -> std::string {
+            StringSink to;
+            CommonProto::Serialise<T>::write(
+                *store,
+                CommonProto::WriteConn { .to = to },
+                decoded);
+            return to.s;
+        });
+    }
+};
+
+#define CHARACTERIZATION_TEST(NAME, STEM, VALUE) \
+    TEST_F(CommonProtoTest, NAME ## _read) { \
+        readProtoTest(STEM, VALUE); \
+    } \
+    TEST_F(CommonProtoTest, NAME ## _write) { \
+        writeProtoTest(STEM, VALUE); \
+    }
+
+CHARACTERIZATION_TEST(
+    string,
+    "string",
+    (std::tuple<std::string, std::string, std::string, std::string, std::string> {
+        "",
+        "hi",
+        "white rabbit",
+        "大白兔",
+        "oh no \0\0\0 what was that!",
+    }))
+
+CHARACTERIZATION_TEST(
+    storePath,
+    "store-path",
+    (std::tuple<StorePath, StorePath> {
+        StorePath { "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo" },
+        StorePath { "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo-bar" },
+    }))
+
+CHARACTERIZATION_TEST(
+    contentAddress,
+    "content-address",
+    (std::tuple<ContentAddress, ContentAddress, ContentAddress> {
+        ContentAddress {
+            .method = ContentAddressMethod::Raw::Text,
+            .hash = hashString(HashAlgorithm::SHA256, "Derive(...)"),
+        },
+        ContentAddress {
+            .method = ContentAddressMethod::Raw::Flat,
+            .hash = hashString(HashAlgorithm::SHA1, "blob blob..."),
+        },
+        ContentAddress {
+            .method = ContentAddressMethod::Raw::NixArchive,
+            .hash = hashString(HashAlgorithm::SHA256, "(...)"),
+        },
+    }))
+
+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(
+    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 = ContentAddressMethod::Raw::Flat,
+                .hash = hashString(HashAlgorithm::SHA1, "blob blob..."),
+            },
+        },
+    }))
+
+}

src/libstore-tests/content-address.cc

@@ -0,0 +1,37 @@
+#include <gtest/gtest.h>
+
+#include "content-address.hh"
+
+namespace nix {
+
+/* ----------------------------------------------------------------------------
+ * ContentAddressMethod::parse, ContentAddressMethod::render
+ * --------------------------------------------------------------------------*/
+
+TEST(ContentAddressMethod, testRoundTripPrintParse_1) {
+    for (ContentAddressMethod cam : {
+        ContentAddressMethod::Raw::Text,
+        ContentAddressMethod::Raw::Flat,
+        ContentAddressMethod::Raw::NixArchive,
+        ContentAddressMethod::Raw::Git,
+    }) {
+        EXPECT_EQ(ContentAddressMethod::parse(cam.render()), cam);
+    }
+}
+
+TEST(ContentAddressMethod, testRoundTripPrintParse_2) {
+    for (const std::string_view camS : {
+        "text",
+        "flat",
+        "nar",
+        "git",
+    }) {
+        EXPECT_EQ(ContentAddressMethod::parse(camS).render(), camS);
+    }
+}
+
+TEST(ContentAddressMethod, testParseContentAddressMethodOptException) {
+    EXPECT_THROW(ContentAddressMethod::parse("narwhal"), UsageError);
+}
+
+}

src/libstore-tests/data/derivation/advanced-attributes-defaults.drv

@@ -0,0 +1 @@
+../../../../tests/functional/derivation/advanced-attributes-defaults.drv

src/libstore-tests/data/derivation/advanced-attributes-defaults.json

@@ -0,0 +1,22 @@
+{
+  "args": [
+    "-c",
+    "echo hello > $out"
+  ],
+  "builder": "/bin/bash",
+  "env": {
+    "builder": "/bin/bash",
+    "name": "advanced-attributes-defaults",
+    "out": "/nix/store/1qsc7svv43m4dw2prh6mvyf7cai5czji-advanced-attributes-defaults",
+    "system": "my-system"
+  },
+  "inputDrvs": {},
+  "inputSrcs": [],
+  "name": "advanced-attributes-defaults",
+  "outputs": {
+    "out": {
+      "path": "/nix/store/1qsc7svv43m4dw2prh6mvyf7cai5czji-advanced-attributes-defaults"
+    }
+  },
+  "system": "my-system"
+}

src/libstore-tests/data/derivation/advanced-attributes-structured-attrs-defaults.drv

@@ -0,0 +1 @@
+../../../../tests/functional/derivation/advanced-attributes-structured-attrs-defaults.drv

src/libstore-tests/data/derivation/advanced-attributes-structured-attrs-defaults.json

@@ -0,0 +1,24 @@
+{
+  "args": [
+    "-c",
+    "echo hello > $out"
+  ],
+  "builder": "/bin/bash",
+  "env": {
+    "__json": "{\"builder\":\"/bin/bash\",\"name\":\"advanced-attributes-structured-attrs-defaults\",\"outputs\":[\"out\",\"dev\"],\"system\":\"my-system\"}",
+    "dev": "/nix/store/8bazivnbipbyi569623skw5zm91z6kc2-advanced-attributes-structured-attrs-defaults-dev",
+    "out": "/nix/store/f8f8nvnx32bxvyxyx2ff7akbvwhwd9dw-advanced-attributes-structured-attrs-defaults"
+  },
+  "inputDrvs": {},
+  "inputSrcs": [],
+  "name": "advanced-attributes-structured-attrs-defaults",
+  "outputs": {
+    "dev": {
+      "path": "/nix/store/8bazivnbipbyi569623skw5zm91z6kc2-advanced-attributes-structured-attrs-defaults-dev"
+    },
+    "out": {
+      "path": "/nix/store/f8f8nvnx32bxvyxyx2ff7akbvwhwd9dw-advanced-attributes-structured-attrs-defaults"
+    }
+  },
+  "system": "my-system"
+}

src/libstore-tests/data/derivation/advanced-attributes-structured-attrs.drv

@@ -0,0 +1 @@
+../../../../tests/functional/derivation/advanced-attributes-structured-attrs.drv

src/libstore-tests/data/derivation/advanced-attributes-structured-attrs.json

@@ -0,0 +1,41 @@
+{
+  "args": [
+    "-c",
+    "echo hello > $out"
+  ],
+  "builder": "/bin/bash",
+  "env": {
+    "__json": "{\"__darwinAllowLocalNetworking\":true,\"__impureHostDeps\":[\"/usr/bin/ditto\"],\"__noChroot\":true,\"__sandboxProfile\":\"sandcastle\",\"allowSubstitutes\":false,\"builder\":\"/bin/bash\",\"impureEnvVars\":[\"UNICORN\"],\"name\":\"advanced-attributes-structured-attrs\",\"outputChecks\":{\"bin\":{\"disallowedReferences\":[\"/nix/store/7rhsm8i393hm1wcsmph782awg1hi2f7x-bar\"],\"disallowedRequisites\":[\"/nix/store/7rhsm8i393hm1wcsmph782awg1hi2f7x-bar\"]},\"dev\":{\"maxClosureSize\":5909,\"maxSize\":789},\"out\":{\"allowedReferences\":[\"/nix/store/3c08bzb71z4wiag719ipjxr277653ynp-foo\"],\"allowedRequisites\":[\"/nix/store/3c08bzb71z4wiag719ipjxr277653ynp-foo\"]}},\"outputs\":[\"out\",\"bin\",\"dev\"],\"preferLocalBuild\":true,\"requiredSystemFeatures\":[\"rainbow\",\"uid-range\"],\"system\":\"my-system\"}",
+    "bin": "/nix/store/pbzb48v0ycf80jgligcp4n8z0rblna4n-advanced-attributes-structured-attrs-bin",
+    "dev": "/nix/store/7xapi8jv7flcz1qq8jhw55ar8ag8hldh-advanced-attributes-structured-attrs-dev",
+    "out": "/nix/store/mpq3l1l1qc2yr50q520g08kprprwv79f-advanced-attributes-structured-attrs"
+  },
+  "inputDrvs": {
+    "/nix/store/4xm4wccqsvagz9gjksn24s7rip2fdy7v-foo.drv": {
+      "dynamicOutputs": {},
+      "outputs": [
+        "out"
+      ]
+    },
+    "/nix/store/plsq5jbr5nhgqwcgb2qxw7jchc09dnl8-bar.drv": {
+      "dynamicOutputs": {},
+      "outputs": [
+        "out"
+      ]
+    }
+  },
+  "inputSrcs": [],
+  "name": "advanced-attributes-structured-attrs",
+  "outputs": {
+    "bin": {
+      "path": "/nix/store/pbzb48v0ycf80jgligcp4n8z0rblna4n-advanced-attributes-structured-attrs-bin"
+    },
+    "dev": {
+      "path": "/nix/store/7xapi8jv7flcz1qq8jhw55ar8ag8hldh-advanced-attributes-structured-attrs-dev"
+    },
+    "out": {
+      "path": "/nix/store/mpq3l1l1qc2yr50q520g08kprprwv79f-advanced-attributes-structured-attrs"
+    }
+  },
+  "system": "my-system"
+}

src/libstore-tests/data/derivation/advanced-attributes.drv

@@ -0,0 +1 @@
+../../../../tests/functional/derivation/advanced-attributes.drv

src/libstore-tests/data/derivation/bad-old-version-dyn-deps.drv

@@ -0,0 +1 @@
+Derive([],[("/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-dep2.drv",(["cat","dog"],[("cat",["kitten"]),("goose",["gosling"])]))],["/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-dep1"],"wasm-sel4","foo",["bar","baz"],[("BIG_BAD","WOLF")])

src/libstore-tests/data/derivation/bad-version.drv

@@ -0,0 +1 @@
+DrvWithVersion("invalid-version",[],[("/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-dep2.drv",["cat","dog"])],["/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-dep1"],"wasm-sel4","foo",["bar","baz"],[("BIG_BAD","WOLF")])

src/libstore-tests/data/derivation/dynDerivationDeps.drv

@@ -0,0 +1 @@
+DrvWithVersion("xp-dyn-drv",[],[("/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-dep2.drv",(["cat","dog"],[("cat",["kitten"]),("goose",["gosling"])]))],["/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-dep1"],"wasm-sel4","foo",["bar","baz"],[("BIG_BAD","WOLF")])

src/libstore-tests/data/derivation/dynDerivationDeps.json

@@ -0,0 +1,38 @@
+{
+  "args": [
+    "bar",
+    "baz"
+  ],
+  "builder": "foo",
+  "env": {
+    "BIG_BAD": "WOLF"
+  },
+  "inputDrvs": {
+    "/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-dep2.drv": {
+      "dynamicOutputs": {
+        "cat": {
+          "dynamicOutputs": {},
+          "outputs": [
+            "kitten"
+          ]
+        },
+        "goose": {
+          "dynamicOutputs": {},
+          "outputs": [
+            "gosling"
+          ]
+        }
+      },
+      "outputs": [
+        "cat",
+        "dog"
+      ]
+    }
+  },
+  "inputSrcs": [
+    "/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-dep1"
+  ],
+  "name": "dyn-dep-derivation",
+  "outputs": {},
+  "system": "wasm-sel4"
+}

src/libstore-tests/data/derivation/output-caFixedFlat.json

@@ -0,0 +1,6 @@
+{
+  "hash": "894517c9163c896ec31a2adbd33c0681fd5f45b2c0ef08a64c92a03fb97f390f",
+  "hashAlgo": "sha256",
+  "method": "flat",
+  "path": "/nix/store/rhcg9h16sqvlbpsa6dqm57sbr2al6nzg-drv-name-output-name"
+}

src/libstore-tests/data/derivation/output-caFixedNAR.json

@@ -0,0 +1,6 @@
+{
+  "hash": "894517c9163c896ec31a2adbd33c0681fd5f45b2c0ef08a64c92a03fb97f390f",
+  "hashAlgo": "sha256",
+  "method": "nar",
+  "path": "/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-drv-name-output-name"
+}

src/libstore-tests/data/derivation/output-caFixedText.json

@@ -0,0 +1,6 @@
+{
+  "hash": "894517c9163c896ec31a2adbd33c0681fd5f45b2c0ef08a64c92a03fb97f390f",
+  "hashAlgo": "sha256",
+  "method": "text",
+  "path": "/nix/store/6s1zwabh956jvhv4w9xcdb5jiyanyxg1-drv-name-output-name"
+}

src/libstore-tests/data/derivation/output-caFloating.json

@@ -0,0 +1,4 @@
+{
+  "hashAlgo": "sha256",
+  "method": "nar"
+}

src/libstore-tests/data/derivation/output-deferred.json

@@ -0,0 +1 @@
+{}

src/libstore-tests/data/derivation/output-impure.json

@@ -0,0 +1,5 @@
+{
+  "hashAlgo": "sha256",
+  "impure": true,
+  "method": "nar"
+}

src/libstore-tests/data/derivation/output-inputAddressed.json

@@ -0,0 +1,3 @@
+{
+  "path": "/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-drv-name-output-name"
+}

src/libstore-tests/data/derivation/simple.drv

@@ -0,0 +1 @@
+Derive([],[("/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-dep2.drv",["cat","dog"])],["/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-dep1"],"wasm-sel4","foo",["bar","baz"],[("BIG_BAD","WOLF")])

src/libstore-tests/data/derivation/simple.json

@@ -0,0 +1,25 @@
+{
+  "args": [
+    "bar",
+    "baz"
+  ],
+  "builder": "foo",
+  "env": {
+    "BIG_BAD": "WOLF"
+  },
+  "inputDrvs": {
+    "/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-dep2.drv": {
+      "dynamicOutputs": {},
+      "outputs": [
+        "cat",
+        "dog"
+      ]
+    }
+  },
+  "inputSrcs": [
+    "/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-dep1"
+  ],
+  "name": "simple-derivation",
+  "outputs": {},
+  "system": "wasm-sel4"
+}

src/libstore-tests/data/machines/bad_format

@@ -0,0 +1 @@
+nix@scratchy.labs.cs.uu.nl - - eight

src/libstore-tests/data/machines/valid

@@ -0,0 +1,3 @@
+nix@scratchy.labs.cs.uu.nl  i686-linux      /home/nix/.ssh/id_scratchy_auto        8 1 kvm
+nix@itchy.labs.cs.uu.nl     i686-linux      /home/nix/.ssh/id_scratchy_auto        8 2
+nix@poochie.labs.cs.uu.nl   i686-linux      /home/nix/.ssh/id_scratchy_auto        1 2 kvm benchmark c3NoLXJzYSBBQUFBQjNOemFDMXljMkVBQUFBREFRQUJBQUFDQVFDWWV5R1laNTNzd1VjMUZNSHBWL1BCcXlKaFR5S1JoRkpWWVRpRHlQN2h5c1JGa0w4VDlLOGdhL2Y2L3c3QjN2SjNHSFRIUFkybENiUEdZbGNLd2h6M2ZRbFNNOEViNi95b3ZLajdvM1FsMEx5Y0dzdGJvRmcwWkZKNldncUxsR0ltS0NobUlxOGZ3TW5ZTWUxbnRQeTBUZFZjSU1tOTV3YzF3SjBMd2c3cEVMRmtHazdkeTVvYnM4a3lGZ0pORDVRSmFwQWJjeWp4Z1QzdzdMcktNZ2xzeWhhd01JNVpkMGZsQTVudW5OZ3pid3plYVhLaUsyTW0vdGJXYTU1YTd4QmNYdHpIZGlPSWdSajJlRWxaMGh5bk10YjBmcklsdmxIcEtLaVFaZ3pQdCtIVXQ2bXpRMkRVME52MGYyYnNSU0krOGpJU2pQcmdlcVVHRldMUzVIUTg2N2xSMlpiaWtyclhZNTdqbVFEZk5DRHY1VFBHZU9UekFEd2pjMDc2aFZ3VFJCd3VTZFhtaWNxTS95b3lrWitkV1dnZ25MenE5QU1tdlNZcDhmZkZDcS9CSDBZNUFXWTFHay9vS3hMVTNaOWt3ZDd2UWNFQWFCQ2dxdnVZRGdTaHE1RlhndDM3OVZESWtEL05ZSTg2QXVvajVDRmVNTzlRM2pJSlRadlh6c1VldjVoSnA2djcxSVh5ODVtbTY5R20zcXdicVE1SjVQZDU1Um56SitpaW5BNjZxTEFSc0Y4amNsSnd5ekFXclBoYU9DRVY2bjVMeVhVazhzMW9EVVR4V1pWN25rVkFTbHJ0MllGcjN5dzdjRTRXQVhsemhHcDhocmdLMVVkMUlyeDVnZWRaSnBWcy9uNWVybmJFMUxmb2x5UHUvRUFIWlh6VGd4dHVDUFNobXc9PQo=

src/libstore-tests/data/nar-info/impure.json

@@ -0,0 +1,20 @@
+{
+  "ca": "fixed:r:sha256:1lr187v6dck1rjh2j6svpikcfz53wyl3qrlcbb405zlh13x0khhh",
+  "compression": "xz",
+  "deriver": "/nix/store/g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar.drv",
+  "downloadHash": "sha256-FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc=",
+  "downloadSize": 4029176,
+  "narHash": "sha256-FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc=",
+  "narSize": 34878,
+  "references": [
+    "/nix/store/g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar",
+    "/nix/store/n5wkd9frr45pa74if5gpz9j7mifg27fh-foo"
+  ],
+  "registrationTime": 23423,
+  "signatures": [
+    "asdf",
+    "qwer"
+  ],
+  "ultimate": true,
+  "url": "nar/1w1fff338fvdw53sqgamddn1b2xgds473pv6y13gizdbqjv4i5p3.nar.xz"
+}

src/libstore-tests/data/nar-info/pure.json

@@ -0,0 +1,9 @@
+{
+  "ca": "fixed:r:sha256:1lr187v6dck1rjh2j6svpikcfz53wyl3qrlcbb405zlh13x0khhh",
+  "narHash": "sha256-FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc=",
+  "narSize": 34878,
+  "references": [
+    "/nix/store/g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar",
+    "/nix/store/n5wkd9frr45pa74if5gpz9j7mifg27fh-foo"
+  ]
+}

src/libstore-tests/data/path-info/empty_impure.json

@@ -0,0 +1,10 @@
+{
+  "ca": null,
+  "deriver": null,
+  "narHash": "sha256-FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc=",
+  "narSize": 0,
+  "references": [],
+  "registrationTime": null,
+  "signatures": [],
+  "ultimate": false
+}

src/libstore-tests/data/path-info/empty_pure.json

@@ -0,0 +1,6 @@
+{
+  "ca": null,
+  "narHash": "sha256-FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc=",
+  "narSize": 0,
+  "references": []
+}

src/libstore-tests/data/path-info/impure.json

@@ -0,0 +1,16 @@
+{
+  "ca": "fixed:r:sha256:1lr187v6dck1rjh2j6svpikcfz53wyl3qrlcbb405zlh13x0khhh",
+  "deriver": "/nix/store/g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar.drv",
+  "narHash": "sha256-FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc=",
+  "narSize": 34878,
+  "references": [
+    "/nix/store/g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar",
+    "/nix/store/n5wkd9frr45pa74if5gpz9j7mifg27fh-foo"
+  ],
+  "registrationTime": 23423,
+  "signatures": [
+    "asdf",
+    "qwer"
+  ],
+  "ultimate": true
+}

src/libstore-tests/data/path-info/pure.json

@@ -0,0 +1,9 @@
+{
+  "ca": "fixed:r:sha256:1lr187v6dck1rjh2j6svpikcfz53wyl3qrlcbb405zlh13x0khhh",
+  "narHash": "sha256-FePFYIlMuycIXPZbWi7LGEiMmZSX9FMbaQenWBzm1Sc=",
+  "narSize": 34878,
+  "references": [
+    "/nix/store/g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar",
+    "/nix/store/n5wkd9frr45pa74if5gpz9j7mifg27fh-foo"
+  ]
+}

src/libstore-tests/data/store-reference/auto.txt

@@ -0,0 +1 @@
+auto

src/libstore-tests/data/store-reference/auto_param.txt

@@ -0,0 +1 @@
+auto?root=/foo/bar/baz

src/libstore-tests/data/store-reference/local_1.txt

@@ -0,0 +1 @@
+local://?root=/foo/bar/baz

src/libstore-tests/data/store-reference/local_2.txt

@@ -0,0 +1 @@
+local:///foo/bar/baz?trusted=true

src/libstore-tests/data/store-reference/local_shorthand_1.txt

@@ -0,0 +1 @@
+local?root=/foo/bar/baz

src/libstore-tests/data/store-reference/local_shorthand_2.txt

@@ -0,0 +1 @@
+/foo/bar/baz?trusted=true

src/libstore-tests/data/store-reference/ssh.txt

@@ -0,0 +1 @@
+ssh://localhost

src/libstore-tests/data/store-reference/unix.txt

@@ -0,0 +1 @@
+unix://?max-connections=7&trusted=true

src/libstore-tests/data/store-reference/unix_shorthand.txt

@@ -0,0 +1 @@
+daemon?max-connections=7&trusted=true

src/libstore-tests/derivation-advanced-attrs.cc

@@ -0,0 +1,234 @@
+#include <gtest/gtest.h>
+#include <optional>
+
+#include "experimental-features.hh"
+#include "derivations.hh"
+
+#include "tests/libstore.hh"
+#include "tests/characterization.hh"
+#include "parsed-derivations.hh"
+#include "types.hh"
+#include "json-utils.hh"
+
+namespace nix {
+
+using nlohmann::json;
+
+class DerivationAdvancedAttrsTest : public CharacterizationTest, public LibStoreTest
+{
+    std::filesystem::path unitTestData = getUnitTestData() / "derivation";
+
+public:
+    std::filesystem::path goldenMaster(std::string_view testStem) const override
+    {
+        return unitTestData / testStem;
+    }
+};
+
+#define TEST_ATERM_JSON(STEM, NAME)                                                                   \
+    TEST_F(DerivationAdvancedAttrsTest, Derivation_##STEM##_from_json)                                \
+    {                                                                                                 \
+        readTest(NAME ".json", [&](const auto & encoded_) {                                           \
+            auto encoded = json::parse(encoded_);                                                     \
+            /* Use DRV file instead of C++ literal as source of truth. */                             \
+            auto aterm = readFile(goldenMaster(NAME ".drv"));                                         \
+            auto expected = parseDerivation(*store, std::move(aterm), NAME);                          \
+            Derivation got = Derivation::fromJSON(*store, encoded);                                   \
+            EXPECT_EQ(got, expected);                                                                 \
+        });                                                                                           \
+    }                                                                                                 \
+                                                                                                      \
+    TEST_F(DerivationAdvancedAttrsTest, Derivation_##STEM##_to_json)                                  \
+    {                                                                                                 \
+        writeTest(                                                                                    \
+            NAME ".json",                                                                             \
+            [&]() -> json {                                                                           \
+                /* Use DRV file instead of C++ literal as source of truth. */                         \
+                auto aterm = readFile(goldenMaster(NAME ".drv"));                                     \
+                return parseDerivation(*store, std::move(aterm), NAME).toJSON(*store);                \
+            },                                                                                        \
+            [](const auto & file) { return json::parse(readFile(file)); },                            \
+            [](const auto & file, const auto & got) { return writeFile(file, got.dump(2) + "\n"); }); \
+    }                                                                                                 \
+                                                                                                      \
+    TEST_F(DerivationAdvancedAttrsTest, Derivation_##STEM##_from_aterm)                               \
+    {                                                                                                 \
+        readTest(NAME ".drv", [&](auto encoded) {                                                     \
+            /* Use JSON file instead of C++ literal as source of truth. */                            \
+            auto json = json::parse(readFile(goldenMaster(NAME ".json")));                            \
+            auto expected = Derivation::fromJSON(*store, json);                                       \
+            auto got = parseDerivation(*store, std::move(encoded), NAME);                             \
+            EXPECT_EQ(got.toJSON(*store), expected.toJSON(*store));                                   \
+            EXPECT_EQ(got, expected);                                                                 \
+        });                                                                                           \
+    }                                                                                                 \
+                                                                                                      \
+    /* No corresponding write test, because we need to read the drv to write the json file */
+
+TEST_ATERM_JSON(advancedAttributes_defaults, "advanced-attributes-defaults");
+TEST_ATERM_JSON(advancedAttributes, "advanced-attributes-defaults");
+TEST_ATERM_JSON(advancedAttributes_structuredAttrs_defaults, "advanced-attributes-structured-attrs");
+TEST_ATERM_JSON(advancedAttributes_structuredAttrs, "advanced-attributes-structured-attrs-defaults");
+
+#undef TEST_ATERM_JSON
+
+TEST_F(DerivationAdvancedAttrsTest, Derivation_advancedAttributes_defaults)
+{
+    readTest("advanced-attributes-defaults.drv", [&](auto encoded) {
+        auto got = parseDerivation(*store, std::move(encoded), "foo");
+
+        auto drvPath = writeDerivation(*store, got, NoRepair, true);
+
+        ParsedDerivation parsedDrv(drvPath, got);
+
+        EXPECT_EQ(parsedDrv.getStringAttr("__sandboxProfile").value_or(""), "");
+        EXPECT_EQ(parsedDrv.getBoolAttr("__noChroot"), false);
+        EXPECT_EQ(parsedDrv.getStringsAttr("__impureHostDeps").value_or(Strings()), Strings());
+        EXPECT_EQ(parsedDrv.getStringsAttr("impureEnvVars").value_or(Strings()), Strings());
+        EXPECT_EQ(parsedDrv.getBoolAttr("__darwinAllowLocalNetworking"), false);
+        EXPECT_EQ(parsedDrv.getStringsAttr("allowedReferences"), std::nullopt);
+        EXPECT_EQ(parsedDrv.getStringsAttr("allowedRequisites"), std::nullopt);
+        EXPECT_EQ(parsedDrv.getStringsAttr("disallowedReferences"), std::nullopt);
+        EXPECT_EQ(parsedDrv.getStringsAttr("disallowedRequisites"), std::nullopt);
+        EXPECT_EQ(parsedDrv.getRequiredSystemFeatures(), StringSet());
+        EXPECT_EQ(parsedDrv.canBuildLocally(*store), false);
+        EXPECT_EQ(parsedDrv.willBuildLocally(*store), false);
+        EXPECT_EQ(parsedDrv.substitutesAllowed(), true);
+        EXPECT_EQ(parsedDrv.useUidRange(), false);
+    });
+};
+
+TEST_F(DerivationAdvancedAttrsTest, Derivation_advancedAttributes)
+{
+    readTest("advanced-attributes.drv", [&](auto encoded) {
+        auto got = parseDerivation(*store, std::move(encoded), "foo");
+
+        auto drvPath = writeDerivation(*store, got, NoRepair, true);
+
+        ParsedDerivation parsedDrv(drvPath, got);
+
+        StringSet systemFeatures{"rainbow", "uid-range"};
+
+        EXPECT_EQ(parsedDrv.getStringAttr("__sandboxProfile").value_or(""), "sandcastle");
+        EXPECT_EQ(parsedDrv.getBoolAttr("__noChroot"), true);
+        EXPECT_EQ(parsedDrv.getStringsAttr("__impureHostDeps").value_or(Strings()), Strings{"/usr/bin/ditto"});
+        EXPECT_EQ(parsedDrv.getStringsAttr("impureEnvVars").value_or(Strings()), Strings{"UNICORN"});
+        EXPECT_EQ(parsedDrv.getBoolAttr("__darwinAllowLocalNetworking"), true);
+        EXPECT_EQ(
+            parsedDrv.getStringsAttr("allowedReferences"), Strings{"/nix/store/3c08bzb71z4wiag719ipjxr277653ynp-foo"});
+        EXPECT_EQ(
+            parsedDrv.getStringsAttr("allowedRequisites"), Strings{"/nix/store/3c08bzb71z4wiag719ipjxr277653ynp-foo"});
+        EXPECT_EQ(
+            parsedDrv.getStringsAttr("disallowedReferences"),
+            Strings{"/nix/store/7rhsm8i393hm1wcsmph782awg1hi2f7x-bar"});
+        EXPECT_EQ(
+            parsedDrv.getStringsAttr("disallowedRequisites"),
+            Strings{"/nix/store/7rhsm8i393hm1wcsmph782awg1hi2f7x-bar"});
+        EXPECT_EQ(parsedDrv.getRequiredSystemFeatures(), systemFeatures);
+        EXPECT_EQ(parsedDrv.canBuildLocally(*store), false);
+        EXPECT_EQ(parsedDrv.willBuildLocally(*store), false);
+        EXPECT_EQ(parsedDrv.substitutesAllowed(), false);
+        EXPECT_EQ(parsedDrv.useUidRange(), true);
+    });
+};
+
+TEST_F(DerivationAdvancedAttrsTest, Derivation_advancedAttributes_structuredAttrs_defaults)
+{
+    readTest("advanced-attributes-structured-attrs-defaults.drv", [&](auto encoded) {
+        auto got = parseDerivation(*store, std::move(encoded), "foo");
+
+        auto drvPath = writeDerivation(*store, got, NoRepair, true);
+
+        ParsedDerivation parsedDrv(drvPath, got);
+
+        EXPECT_EQ(parsedDrv.getStringAttr("__sandboxProfile").value_or(""), "");
+        EXPECT_EQ(parsedDrv.getBoolAttr("__noChroot"), false);
+        EXPECT_EQ(parsedDrv.getStringsAttr("__impureHostDeps").value_or(Strings()), Strings());
+        EXPECT_EQ(parsedDrv.getStringsAttr("impureEnvVars").value_or(Strings()), Strings());
+        EXPECT_EQ(parsedDrv.getBoolAttr("__darwinAllowLocalNetworking"), false);
+
+        {
+            auto structuredAttrs_ = parsedDrv.getStructuredAttrs();
+            ASSERT_TRUE(structuredAttrs_);
+            auto & structuredAttrs = *structuredAttrs_;
+
+            auto outputChecks_ = get(structuredAttrs, "outputChecks");
+            ASSERT_FALSE(outputChecks_);
+        }
+
+        EXPECT_EQ(parsedDrv.getRequiredSystemFeatures(), StringSet());
+        EXPECT_EQ(parsedDrv.canBuildLocally(*store), false);
+        EXPECT_EQ(parsedDrv.willBuildLocally(*store), false);
+        EXPECT_EQ(parsedDrv.substitutesAllowed(), true);
+        EXPECT_EQ(parsedDrv.useUidRange(), false);
+    });
+};
+
+TEST_F(DerivationAdvancedAttrsTest, Derivation_advancedAttributes_structuredAttrs)
+{
+    readTest("advanced-attributes-structured-attrs.drv", [&](auto encoded) {
+        auto got = parseDerivation(*store, std::move(encoded), "foo");
+
+        auto drvPath = writeDerivation(*store, got, NoRepair, true);
+
+        ParsedDerivation parsedDrv(drvPath, got);
+
+        StringSet systemFeatures{"rainbow", "uid-range"};
+
+        EXPECT_EQ(parsedDrv.getStringAttr("__sandboxProfile").value_or(""), "sandcastle");
+        EXPECT_EQ(parsedDrv.getBoolAttr("__noChroot"), true);
+        EXPECT_EQ(parsedDrv.getStringsAttr("__impureHostDeps").value_or(Strings()), Strings{"/usr/bin/ditto"});
+        EXPECT_EQ(parsedDrv.getStringsAttr("impureEnvVars").value_or(Strings()), Strings{"UNICORN"});
+        EXPECT_EQ(parsedDrv.getBoolAttr("__darwinAllowLocalNetworking"), true);
+
+        {
+            auto structuredAttrs_ = parsedDrv.getStructuredAttrs();
+            ASSERT_TRUE(structuredAttrs_);
+            auto & structuredAttrs = *structuredAttrs_;
+
+            auto outputChecks_ = get(structuredAttrs, "outputChecks");
+            ASSERT_TRUE(outputChecks_);
+            auto & outputChecks = *outputChecks_;
+
+            {
+                auto output_ = get(outputChecks, "out");
+                ASSERT_TRUE(output_);
+                auto & output = *output_;
+                EXPECT_EQ(
+                    get(output, "allowedReferences")->get<Strings>(),
+                    Strings{"/nix/store/3c08bzb71z4wiag719ipjxr277653ynp-foo"});
+                EXPECT_EQ(
+                    get(output, "allowedRequisites")->get<Strings>(),
+                    Strings{"/nix/store/3c08bzb71z4wiag719ipjxr277653ynp-foo"});
+            }
+
+            {
+                auto output_ = get(outputChecks, "bin");
+                ASSERT_TRUE(output_);
+                auto & output = *output_;
+                EXPECT_EQ(
+                    get(output, "disallowedReferences")->get<Strings>(),
+                    Strings{"/nix/store/7rhsm8i393hm1wcsmph782awg1hi2f7x-bar"});
+                EXPECT_EQ(
+                    get(output, "disallowedRequisites")->get<Strings>(),
+                    Strings{"/nix/store/7rhsm8i393hm1wcsmph782awg1hi2f7x-bar"});
+            }
+
+            {
+                auto output_ = get(outputChecks, "dev");
+                ASSERT_TRUE(output_);
+                auto & output = *output_;
+                EXPECT_EQ(get(output, "maxSize")->get<uint64_t>(), 789);
+                EXPECT_EQ(get(output, "maxClosureSize")->get<uint64_t>(), 5909);
+            }
+        }
+
+        EXPECT_EQ(parsedDrv.getRequiredSystemFeatures(), systemFeatures);
+        EXPECT_EQ(parsedDrv.canBuildLocally(*store), false);
+        EXPECT_EQ(parsedDrv.willBuildLocally(*store), false);
+        EXPECT_EQ(parsedDrv.substitutesAllowed(), false);
+        EXPECT_EQ(parsedDrv.useUidRange(), true);
+    });
+};
+
+}

src/libstore-tests/derivation.cc

@@ -0,0 +1,299 @@
+#include <nlohmann/json.hpp>
+#include <gtest/gtest.h>
+
+#include "experimental-features.hh"
+#include "derivations.hh"
+
+#include "tests/libstore.hh"
+#include "tests/characterization.hh"
+
+namespace nix {
+
+using nlohmann::json;
+
+class DerivationTest : public CharacterizationTest, public LibStoreTest
+{
+    std::filesystem::path unitTestData = getUnitTestData() / "derivation";
+
+public:
+    std::filesystem::path goldenMaster(std::string_view testStem) const override {
+        return unitTestData / testStem;
+    }
+
+    /**
+     * We set these in tests rather than the regular globals so we don't have
+     * to worry about race conditions if the tests run concurrently.
+     */
+    ExperimentalFeatureSettings mockXpSettings;
+};
+
+class CaDerivationTest : public DerivationTest
+{
+    void SetUp() override
+    {
+        mockXpSettings.set("experimental-features", "ca-derivations");
+    }
+};
+
+class DynDerivationTest : public DerivationTest
+{
+    void SetUp() override
+    {
+        mockXpSettings.set("experimental-features", "dynamic-derivations ca-derivations");
+    }
+};
+
+class ImpureDerivationTest : public DerivationTest
+{
+    void SetUp() override
+    {
+        mockXpSettings.set("experimental-features", "impure-derivations");
+    }
+};
+
+TEST_F(DerivationTest, BadATerm_version) {
+    ASSERT_THROW(
+        parseDerivation(
+            *store,
+            readFile(goldenMaster("bad-version.drv")),
+            "whatever",
+            mockXpSettings),
+        FormatError);
+}
+
+TEST_F(DynDerivationTest, BadATerm_oldVersionDynDeps) {
+    ASSERT_THROW(
+        parseDerivation(
+            *store,
+            readFile(goldenMaster("bad-old-version-dyn-deps.drv")),
+            "dyn-dep-derivation",
+            mockXpSettings),
+        FormatError);
+}
+
+#define TEST_JSON(FIXTURE, NAME, VAL, DRV_NAME, OUTPUT_NAME)              \
+    TEST_F(FIXTURE, DerivationOutput_ ## NAME ## _from_json) {            \
+        readTest("output-" #NAME ".json", [&](const auto & encoded_) {    \
+            auto encoded = json::parse(encoded_);                         \
+            DerivationOutput got = DerivationOutput::fromJSON(            \
+                *store,                                                   \
+                DRV_NAME,                                                 \
+                OUTPUT_NAME,                                              \
+                encoded,                                                  \
+                mockXpSettings);                                          \
+            DerivationOutput expected { VAL };                            \
+            ASSERT_EQ(got, expected);                                     \
+        });                                                               \
+    }                                                                     \
+                                                                          \
+    TEST_F(FIXTURE, DerivationOutput_ ## NAME ## _to_json) {              \
+        writeTest("output-" #NAME ".json", [&]() -> json {                \
+            return DerivationOutput { (VAL) }.toJSON(                     \
+                *store,                                                   \
+                (DRV_NAME),                                               \
+                (OUTPUT_NAME));                                           \
+        }, [](const auto & file) {                                        \
+            return json::parse(readFile(file));                           \
+        }, [](const auto & file, const auto & got) {                      \
+            return writeFile(file, got.dump(2) + "\n");                   \
+        });                                                               \
+    }
+
+TEST_JSON(DerivationTest, inputAddressed,
+    (DerivationOutput::InputAddressed {
+        .path = store->parseStorePath("/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-drv-name-output-name"),
+    }),
+    "drv-name", "output-name")
+
+TEST_JSON(DerivationTest, caFixedFlat,
+    (DerivationOutput::CAFixed {
+        .ca = {
+            .method = ContentAddressMethod::Raw::Flat,
+            .hash = Hash::parseAnyPrefixed("sha256-iUUXyRY8iW7DGirb0zwGgf1fRbLA7wimTJKgP7l/OQ8="),
+        },
+    }),
+    "drv-name", "output-name")
+
+TEST_JSON(DerivationTest, caFixedNAR,
+    (DerivationOutput::CAFixed {
+        .ca = {
+            .method = ContentAddressMethod::Raw::NixArchive,
+            .hash = Hash::parseAnyPrefixed("sha256-iUUXyRY8iW7DGirb0zwGgf1fRbLA7wimTJKgP7l/OQ8="),
+        },
+    }),
+    "drv-name", "output-name")
+
+TEST_JSON(DynDerivationTest, caFixedText,
+    (DerivationOutput::CAFixed {
+        .ca = {
+            .method = ContentAddressMethod::Raw::Text,
+            .hash = Hash::parseAnyPrefixed("sha256-iUUXyRY8iW7DGirb0zwGgf1fRbLA7wimTJKgP7l/OQ8="),
+        },
+    }),
+    "drv-name", "output-name")
+
+TEST_JSON(CaDerivationTest, caFloating,
+    (DerivationOutput::CAFloating {
+        .method = ContentAddressMethod::Raw::NixArchive,
+        .hashAlgo = HashAlgorithm::SHA256,
+    }),
+    "drv-name", "output-name")
+
+TEST_JSON(DerivationTest, deferred,
+    DerivationOutput::Deferred { },
+    "drv-name", "output-name")
+
+TEST_JSON(ImpureDerivationTest, impure,
+    (DerivationOutput::Impure {
+        .method = ContentAddressMethod::Raw::NixArchive,
+        .hashAlgo = HashAlgorithm::SHA256,
+    }),
+    "drv-name", "output-name")
+
+#undef TEST_JSON
+
+#define TEST_JSON(FIXTURE, NAME, VAL)                                     \
+    TEST_F(FIXTURE, Derivation_ ## NAME ## _from_json) {                  \
+        readTest(#NAME ".json", [&](const auto & encoded_) {              \
+            auto encoded = json::parse(encoded_);                         \
+            Derivation expected { VAL };                                  \
+            Derivation got = Derivation::fromJSON(                        \
+                *store,                                                   \
+                encoded,                                                  \
+                mockXpSettings);                                          \
+            ASSERT_EQ(got, expected);                                     \
+        });                                                               \
+    }                                                                     \
+                                                                          \
+    TEST_F(FIXTURE, Derivation_ ## NAME ## _to_json) {                    \
+        writeTest(#NAME ".json", [&]() -> json {                          \
+            return Derivation { VAL }.toJSON(*store);                     \
+        }, [](const auto & file) {                                        \
+            return json::parse(readFile(file));                           \
+        }, [](const auto & file, const auto & got) {                      \
+            return writeFile(file, got.dump(2) + "\n");                   \
+        });                                                               \
+    }
+
+#define TEST_ATERM(FIXTURE, NAME, VAL, DRV_NAME)                          \
+    TEST_F(FIXTURE, Derivation_ ## NAME ## _from_aterm) {                 \
+        readTest(#NAME ".drv", [&](auto encoded) {                        \
+            Derivation expected { VAL };                                  \
+            auto got = parseDerivation(                                   \
+                *store,                                                   \
+                std::move(encoded),                                       \
+                DRV_NAME,                                                 \
+                mockXpSettings);                                          \
+            ASSERT_EQ(got.toJSON(*store), expected.toJSON(*store)) ;      \
+            ASSERT_EQ(got, expected);                                     \
+        });                                                               \
+    }                                                                     \
+                                                                          \
+    TEST_F(FIXTURE, Derivation_ ## NAME ## _to_aterm) {                   \
+        writeTest(#NAME ".drv", [&]() -> std::string {                    \
+            return (VAL).unparse(*store, false);                          \
+        });                                                               \
+    }
+
+Derivation makeSimpleDrv(const Store & store) {
+    Derivation drv;
+    drv.name = "simple-derivation";
+    drv.inputSrcs = {
+        store.parseStorePath("/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-dep1"),
+    };
+    drv.inputDrvs = {
+        .map = {
+            {
+                store.parseStorePath("/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-dep2.drv"),
+                {
+                    .value = {
+                        "cat",
+                        "dog",
+                    },
+                },
+            },
+        },
+    };
+    drv.platform = "wasm-sel4";
+    drv.builder = "foo";
+    drv.args = {
+        "bar",
+        "baz",
+    };
+    drv.env = {
+        {
+            "BIG_BAD",
+            "WOLF",
+        },
+    };
+    return drv;
+}
+
+TEST_JSON(DerivationTest, simple, makeSimpleDrv(*store))
+
+TEST_ATERM(DerivationTest, simple,
+    makeSimpleDrv(*store),
+    "simple-derivation")
+
+Derivation makeDynDepDerivation(const Store & store) {
+    Derivation drv;
+    drv.name = "dyn-dep-derivation";
+    drv.inputSrcs = {
+        store.parseStorePath("/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-dep1"),
+    };
+    drv.inputDrvs = {
+        .map = {
+            {
+                store.parseStorePath("/nix/store/c015dhfh5l0lp6wxyvdn7bmwhbbr6hr9-dep2.drv"),
+                DerivedPathMap<StringSet>::ChildNode {
+                    .value = {
+                        "cat",
+                        "dog",
+                    },
+                    .childMap = {
+                        {
+                            "cat",
+                            DerivedPathMap<StringSet>::ChildNode {
+                                .value = {
+                                    "kitten",
+                                },
+                            },
+                        },
+                        {
+                            "goose",
+                            DerivedPathMap<StringSet>::ChildNode {
+                                .value = {
+                                    "gosling",
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    };
+    drv.platform = "wasm-sel4";
+    drv.builder = "foo";
+    drv.args = {
+        "bar",
+        "baz",
+    };
+    drv.env = {
+        {
+            "BIG_BAD",
+            "WOLF",
+        },
+    };
+    return drv;
+}
+
+TEST_JSON(DynDerivationTest, dynDerivationDeps, makeDynDepDerivation(*store))
+
+TEST_ATERM(DynDerivationTest, dynDerivationDeps,
+    makeDynDepDerivation(*store),
+    "dyn-dep-derivation")
+
+#undef TEST_JSON
+#undef TEST_ATERM
+
+}

src/libstore-tests/derived-path.cc

@@ -0,0 +1,100 @@
+#include <regex>
+
+#include <gtest/gtest.h>
+#include <rapidcheck/gtest.h>
+
+#include "tests/derived-path.hh"
+#include "tests/libstore.hh"
+
+namespace nix {
+
+class DerivedPathTest : public LibStoreTest
+{
+};
+
+/**
+ * Round trip (string <-> data structure) test for
+ * `DerivedPath::Opaque`.
+ */
+TEST_F(DerivedPathTest, opaque) {
+    std::string_view opaque = "/nix/store/g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-x";
+    auto elem = DerivedPath::parse(*store, opaque);
+    auto * p = std::get_if<DerivedPath::Opaque>(&elem);
+    ASSERT_TRUE(p);
+    ASSERT_EQ(p->path, store->parseStorePath(opaque));
+    ASSERT_EQ(elem.to_string(*store), opaque);
+}
+
+/**
+ * Round trip (string <-> data structure) test for a simpler
+ * `DerivedPath::Built`.
+ */
+TEST_F(DerivedPathTest, built_opaque) {
+    std::string_view built = "/nix/store/g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-x.drv^bar,foo";
+    auto elem = DerivedPath::parse(*store, built);
+    auto * p = std::get_if<DerivedPath::Built>(&elem);
+    ASSERT_TRUE(p);
+    ASSERT_EQ(p->outputs, ((OutputsSpec) OutputsSpec::Names { "foo", "bar" }));
+    ASSERT_EQ(*p->drvPath, ((SingleDerivedPath) SingleDerivedPath::Opaque {
+        .path = store->parseStorePath(built.substr(0, 49)),
+    }));
+    ASSERT_EQ(elem.to_string(*store), built);
+}
+
+/**
+ * Round trip (string <-> data structure) test for a more complex,
+ * inductive `DerivedPath::Built`.
+ */
+TEST_F(DerivedPathTest, built_built) {
+    /**
+     * We set these in tests rather than the regular globals so we don't have
+     * to worry about race conditions if the tests run concurrently.
+     */
+    ExperimentalFeatureSettings mockXpSettings;
+    mockXpSettings.set("experimental-features", "dynamic-derivations ca-derivations");
+
+    std::string_view built = "/nix/store/g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-x.drv^foo^bar,baz";
+    auto elem = DerivedPath::parse(*store, built, mockXpSettings);
+    auto * p = std::get_if<DerivedPath::Built>(&elem);
+    ASSERT_TRUE(p);
+    ASSERT_EQ(p->outputs, ((OutputsSpec) OutputsSpec::Names { "bar", "baz" }));
+    auto * drvPath = std::get_if<SingleDerivedPath::Built>(&*p->drvPath);
+    ASSERT_TRUE(drvPath);
+    ASSERT_EQ(drvPath->output, "foo");
+    ASSERT_EQ(*drvPath->drvPath, ((SingleDerivedPath) SingleDerivedPath::Opaque {
+        .path = store->parseStorePath(built.substr(0, 49)),
+    }));
+    ASSERT_EQ(elem.to_string(*store), built);
+}
+
+/**
+ * Without the right experimental features enabled, we cannot parse a
+ * complex inductive derived path.
+ */
+TEST_F(DerivedPathTest, built_built_xp) {
+    ASSERT_THROW(
+        DerivedPath::parse(*store, "/nix/store/g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-x.drv^foo^bar,baz"),
+        MissingExperimentalFeature);
+}
+
+#ifndef COVERAGE
+
+RC_GTEST_FIXTURE_PROP(
+    DerivedPathTest,
+    prop_legacy_round_rip,
+    (const DerivedPath & o))
+{
+    RC_ASSERT(o == DerivedPath::parseLegacy(*store, o.to_string_legacy(*store)));
+}
+
+RC_GTEST_FIXTURE_PROP(
+    DerivedPathTest,
+    prop_round_rip,
+    (const DerivedPath & o))
+{
+    RC_ASSERT(o == DerivedPath::parse(*store, o.to_string(*store)));
+}
+
+#endif
+
+}

src/libstore-tests/downstream-placeholder.cc

@@ -0,0 +1,41 @@
+#include <gtest/gtest.h>
+
+#include "downstream-placeholder.hh"
+
+namespace nix {
+
+TEST(DownstreamPlaceholder, unknownCaOutput) {
+    /**
+     * We set these in tests rather than the regular globals so we don't have
+     * to worry about race conditions if the tests run concurrently.
+     */
+    ExperimentalFeatureSettings mockXpSettings;
+    mockXpSettings.set("experimental-features", "ca-derivations");
+
+    ASSERT_EQ(
+        DownstreamPlaceholder::unknownCaOutput(
+            StorePath { "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo.drv" },
+            "out",
+            mockXpSettings).render(),
+        "/0c6rn30q4frawknapgwq386zq358m8r6msvywcvc89n6m5p2dgbz");
+}
+
+TEST(DownstreamPlaceholder, unknownDerivation) {
+    /**
+     * Same reason as above
+     */
+    ExperimentalFeatureSettings mockXpSettings;
+    mockXpSettings.set("experimental-features", "dynamic-derivations ca-derivations");
+
+    ASSERT_EQ(
+        DownstreamPlaceholder::unknownDerivation(
+            DownstreamPlaceholder::unknownCaOutput(
+                StorePath { "g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-foo.drv.drv" },
+                "out",
+                mockXpSettings),
+            "out",
+            mockXpSettings).render(),
+        "/0gn6agqxjyyalf0dpihgyf49xq5hqxgw100f0wydnj6yqrhqsb3w");
+}
+
+}

src/libstore-tests/http-binary-cache-store.cc

@@ -0,0 +1,21 @@
+#include <gtest/gtest.h>
+
+#include "http-binary-cache-store.hh"
+
+namespace nix {
+
+TEST(HttpBinaryCacheStore, constructConfig)
+{
+    HttpBinaryCacheStoreConfig config{"http", "foo.bar.baz", {}};
+
+    EXPECT_EQ(config.cacheUri, "http://foo.bar.baz");
+}
+
+TEST(HttpBinaryCacheStore, constructConfigNoTrailingSlash)
+{
+    HttpBinaryCacheStoreConfig config{"https", "foo.bar.baz/a/b/", {}};
+
+    EXPECT_EQ(config.cacheUri, "https://foo.bar.baz/a/b");
+}
+
+} // namespace nix

src/libstore-tests/legacy-ssh-store.cc

@@ -0,0 +1,26 @@
+#include <gtest/gtest.h>
+
+#include "legacy-ssh-store.hh"
+
+namespace nix {
+
+TEST(LegacySSHStore, constructConfig)
+{
+    LegacySSHStoreConfig config{
+        "ssh",
+        "localhost",
+        StoreConfig::Params{
+            {
+                "remote-program",
+                // TODO #11106, no more split on space
+                "foo bar",
+            },
+        }};
+    EXPECT_EQ(
+        config.remoteProgram.get(),
+        (Strings{
+            "foo",
+            "bar",
+        }));
+}
+}