diff --git a/src/libexpr-test-support/tests/value/context.cc b/src/libexpr-test-support/tests/value/context.cc
index 8658bdaef..36837cd6a 100644
--- a/src/libexpr-test-support/tests/value/context.cc
+++ b/src/libexpr-test-support/tests/value/context.cc
@@ -8,23 +8,32 @@ using namespace nix;
 
 Gen<NixStringContextElem::DrvDeep> Arbitrary<NixStringContextElem::DrvDeep>::arbitrary()
 {
-    return gen::just(NixStringContextElem::DrvDeep {
-        .drvPath = *gen::arbitrary<StorePath>(),
+    return gen::map(gen::arbitrary<StorePath>(), [](StorePath drvPath) {
+        return NixStringContextElem::DrvDeep{
+            .drvPath = drvPath,
+        };
     });
 }
 
 Gen<NixStringContextElem> Arbitrary<NixStringContextElem>::arbitrary()
 {
-    switch (*gen::inRange<uint8_t>(0, std::variant_size_v<NixStringContextElem::Raw>)) {
-    case 0:
-        return gen::just<NixStringContextElem>(*gen::arbitrary<NixStringContextElem::Opaque>());
-    case 1:
-        return gen::just<NixStringContextElem>(*gen::arbitrary<NixStringContextElem::DrvDeep>());
-    case 2:
-        return gen::just<NixStringContextElem>(*gen::arbitrary<NixStringContextElem::Built>());
-    default:
-        assert(false);
-    }
+    return gen::mapcat(
+        gen::inRange<uint8_t>(0, std::variant_size_v<NixStringContextElem::Raw>),
+        [](uint8_t n) -> Gen<NixStringContextElem> {
+            switch (n) {
+            case 0:
+                return gen::map(
+                    gen::arbitrary<NixStringContextElem::Opaque>(), [](NixStringContextElem a) { return a; });
+            case 1:
+                return gen::map(
+                    gen::arbitrary<NixStringContextElem::DrvDeep>(), [](NixStringContextElem a) { return a; });
+            case 2:
+                return gen::map(
+                    gen::arbitrary<NixStringContextElem::Built>(), [](NixStringContextElem a) { return a; });
+            default:
+                assert(false);
+            }
+        });
 }
 
 }
diff --git a/src/libstore-test-support/tests/derived-path.cc b/src/libstore-test-support/tests/derived-path.cc
index 078615bbd..b9f6a3171 100644
--- a/src/libstore-test-support/tests/derived-path.cc
+++ b/src/libstore-test-support/tests/derived-path.cc
@@ -9,49 +9,63 @@ using namespace nix;
 
 Gen<SingleDerivedPath::Opaque> Arbitrary<SingleDerivedPath::Opaque>::arbitrary()
 {
-    return gen::just(DerivedPath::Opaque {
-        .path = *gen::arbitrary<StorePath>(),
+    return gen::map(gen::arbitrary<StorePath>(), [](StorePath path) {
+        return DerivedPath::Opaque{
+            .path = path,
+        };
     });
 }
 
 Gen<SingleDerivedPath::Built> Arbitrary<SingleDerivedPath::Built>::arbitrary()
 {
-    return gen::just(SingleDerivedPath::Built {
-        .drvPath = make_ref<SingleDerivedPath>(*gen::arbitrary<SingleDerivedPath>()),
-        .output = (*gen::arbitrary<StorePathName>()).name,
+    return gen::mapcat(gen::arbitrary<SingleDerivedPath>(), [](SingleDerivedPath drvPath) {
+        return gen::map(gen::arbitrary<StorePathName>(), [drvPath](StorePathName outputPath) {
+            return SingleDerivedPath::Built{
+                .drvPath = make_ref<SingleDerivedPath>(drvPath),
+                .output = outputPath.name,
+            };
+        });
     });
 }
 
 Gen<DerivedPath::Built> Arbitrary<DerivedPath::Built>::arbitrary()
 {
-    return gen::just(DerivedPath::Built {
-        .drvPath = make_ref<SingleDerivedPath>(*gen::arbitrary<SingleDerivedPath>()),
-        .outputs = *gen::arbitrary<OutputsSpec>(),
+    return gen::mapcat(gen::arbitrary<SingleDerivedPath>(), [](SingleDerivedPath drvPath) {
+        return gen::map(gen::arbitrary<OutputsSpec>(), [drvPath](OutputsSpec outputs) {
+            return DerivedPath::Built{
+                .drvPath = make_ref<SingleDerivedPath>(drvPath),
+                .outputs = outputs,
+            };
+        });
     });
 }
 
 Gen<SingleDerivedPath> Arbitrary<SingleDerivedPath>::arbitrary()
 {
-    switch (*gen::inRange<uint8_t>(0, std::variant_size_v<SingleDerivedPath::Raw>)) {
-    case 0:
-        return gen::just<SingleDerivedPath>(*gen::arbitrary<SingleDerivedPath::Opaque>());
-    case 1:
-        return gen::just<SingleDerivedPath>(*gen::arbitrary<SingleDerivedPath::Built>());
-    default:
-        assert(false);
-    }
+    return gen::mapcat(gen::inRange<uint8_t>(0, std::variant_size_v<SingleDerivedPath::Raw>), [](uint8_t n) {
+        switch (n) {
+        case 0:
+            return gen::map(gen::arbitrary<SingleDerivedPath::Opaque>(), [](SingleDerivedPath a) { return a; });
+        case 1:
+            return gen::map(gen::arbitrary<SingleDerivedPath::Built>(), [](SingleDerivedPath a) { return a; });
+        default:
+            assert(false);
+        }
+    });
 }
 
 Gen<DerivedPath> Arbitrary<DerivedPath>::arbitrary()
 {
-    switch (*gen::inRange<uint8_t>(0, std::variant_size_v<DerivedPath::Raw>)) {
-    case 0:
-        return gen::just<DerivedPath>(*gen::arbitrary<DerivedPath::Opaque>());
-    case 1:
-        return gen::just<DerivedPath>(*gen::arbitrary<DerivedPath::Built>());
-    default:
-        assert(false);
-    }
+    return gen::mapcat(gen::inRange<uint8_t>(0, std::variant_size_v<DerivedPath::Raw>), [](uint8_t n) {
+        switch (n) {
+        case 0:
+            return gen::map(gen::arbitrary<DerivedPath::Opaque>(), [](DerivedPath a) { return a; });
+        case 1:
+            return gen::map(gen::arbitrary<DerivedPath::Built>(), [](DerivedPath a) { return a; });
+        default:
+            assert(false);
+        }
+    });
 }
 
 }
diff --git a/src/libstore-test-support/tests/outputs-spec.cc b/src/libstore-test-support/tests/outputs-spec.cc
index e9d602203..1a3020f17 100644
--- a/src/libstore-test-support/tests/outputs-spec.cc
+++ b/src/libstore-test-support/tests/outputs-spec.cc
@@ -7,18 +7,20 @@ using namespace nix;
 
 Gen<OutputsSpec> Arbitrary<OutputsSpec>::arbitrary()
 {
-    switch (*gen::inRange<uint8_t>(0, std::variant_size_v<OutputsSpec::Raw>)) {
-    case 0:
-        return gen::just((OutputsSpec) OutputsSpec::All { });
-    case 1:
-        return gen::just((OutputsSpec) OutputsSpec::Names {
-            *gen::nonEmpty(gen::container<StringSet>(gen::map(
-                gen::arbitrary<StorePathName>(),
-                [](StorePathName n) { return n.name; }))),
+    return gen::mapcat(
+        gen::inRange<uint8_t>(0, std::variant_size_v<OutputsSpec::Raw>), [](uint8_t n) -> Gen<OutputsSpec> {
+            switch (n) {
+            case 0:
+                return gen::just((OutputsSpec) OutputsSpec::All{});
+            case 1:
+                return gen::map(
+                    gen::nonEmpty(gen::container<StringSet>(
+                        gen::map(gen::arbitrary<StorePathName>(), [](StorePathName n) { return n.name; }))),
+                    [](StringSet names) { return (OutputsSpec) OutputsSpec::Names{names}; });
+            default:
+                assert(false);
+            }
         });
-    default:
-        assert(false);
-    }
 }
 
 }