Merge remote-tracking branch 'origin/master' into nix-profile-stable-names

tests/functional/eval-store.sh

@@ -40,3 +40,11 @@ if [[ ! -n "${NIX_TESTS_CA_BY_DEFAULT:-}" ]]; then
     (! ls $NIX_STORE_DIR/*.drv)
 fi
 ls $eval_store/nix/store/*.drv
+
+clearStore
+rm -rf "$eval_store"
+
+# Confirm that import-from-derivation builds on the build store
+[[ $(nix eval --eval-store "$eval_store?require-sigs=false" --impure --raw --file ./ifd.nix) = hi ]]
+ls $NIX_STORE_DIR/*dependencies-top/foobar
+(! ls $eval_store/nix/store/*dependencies-top/foobar)

tests/functional/fixed.nix

@@ -48,6 +48,15 @@ rec {
     (f ./fixed.builder1.sh "flat" "md5" "ddd8be4b179a529afa5f2ffae4b9858")
   ];
 
+  badReferences = mkDerivation rec {
+    name = "bad-hash";
+    builder = script;
+    script = builtins.toFile "installer.sh" "echo $script >$out";
+    outputHash = "1ixr6yd3297ciyp9im522dfxpqbkhcw0pylkb2aab915278fqaik";
+    outputHashAlgo = "sha256";
+    outputHashMode = "flat";
+  };
+
   # Test for building two derivations in parallel that produce the
   # same output path because they're fixed-output derivations.
   parallelSame = [

tests/functional/fixed.sh

@@ -26,6 +26,11 @@ nix-build fixed.nix -A good2 --no-out-link
 echo 'testing reallyBad...'
 nix-instantiate fixed.nix -A reallyBad && fail "should fail"
 
+if isDaemonNewer "2.20pre20240108"; then
+    echo 'testing fixed with references...'
+    expectStderr 1 nix-build fixed.nix -A badReferences | grepQuiet "not allowed to refer to other store paths"
+fi
+
 # While we're at it, check attribute selection a bit more.
 echo 'testing attribute selection...'
 test $(nix-instantiate fixed.nix -A good.1 | wc -l) = 1

tests/functional/ifd.nix

@@ -0,0 +1,10 @@
+with import ./config.nix;
+import (
+  mkDerivation {
+    name = "foo";
+    bla = import ./dependencies.nix {};
+    buildCommand = "
+      echo \\\"hi\\\" > $out
+    ";
+  }
+)

tests/functional/lang/eval-fail-duplicate-traces.err.exp

@@ -0,0 +1,44 @@
+error:
+       … from call site
+         at /pwd/lang/eval-fail-duplicate-traces.nix:9:3:
+            8| in
+            9|   throwAfter 2
+             |   ^
+           10|
+
+       … while calling 'throwAfter'
+         at /pwd/lang/eval-fail-duplicate-traces.nix:4:16:
+            3| let
+            4|   throwAfter = n:
+             |                ^
+            5|     if n > 0
+
+       … from call site
+         at /pwd/lang/eval-fail-duplicate-traces.nix:6:10:
+            5|     if n > 0
+            6|     then throwAfter (n - 1)
+             |          ^
+            7|     else throw "Uh oh!";
+
+       … while calling 'throwAfter'
+         at /pwd/lang/eval-fail-duplicate-traces.nix:4:16:
+            3| let
+            4|   throwAfter = n:
+             |                ^
+            5|     if n > 0
+
+       … from call site
+         at /pwd/lang/eval-fail-duplicate-traces.nix:6:10:
+            5|     if n > 0
+            6|     then throwAfter (n - 1)
+             |          ^
+            7|     else throw "Uh oh!";
+
+       … while calling 'throwAfter'
+         at /pwd/lang/eval-fail-duplicate-traces.nix:4:16:
+            3| let
+            4|   throwAfter = n:
+             |                ^
+            5|     if n > 0
+
+       error: Uh oh!

tests/functional/lang/eval-fail-duplicate-traces.nix

@@ -0,0 +1,9 @@
+# Check that we only omit duplicate stack traces when there's a bunch of them.
+# Here, there's only a couple duplicate entries, so we output them all.
+let
+  throwAfter = n:
+    if n > 0
+    then throwAfter (n - 1)
+    else throw "Uh oh!";
+in
+  throwAfter 2

tests/functional/lang/eval-fail-infinite-recursion-lambda.err.exp

@@ -0,0 +1,38 @@
+error:
+       … from call site
+         at /pwd/lang/eval-fail-infinite-recursion-lambda.nix:1:1:
+            1| (x: x x) (x: x x)
+             | ^
+            2|
+
+       … while calling anonymous lambda
+         at /pwd/lang/eval-fail-infinite-recursion-lambda.nix:1:2:
+            1| (x: x x) (x: x x)
+             |  ^
+            2|
+
+       … from call site
+         at /pwd/lang/eval-fail-infinite-recursion-lambda.nix:1:5:
+            1| (x: x x) (x: x x)
+             |     ^
+            2|
+
+       … while calling anonymous lambda
+         at /pwd/lang/eval-fail-infinite-recursion-lambda.nix:1:11:
+            1| (x: x x) (x: x x)
+             |           ^
+            2|
+
+       … from call site
+         at /pwd/lang/eval-fail-infinite-recursion-lambda.nix:1:14:
+            1| (x: x x) (x: x x)
+             |              ^
+            2|
+
+       (19997 duplicate frames omitted)
+
+       error: stack overflow; max-call-depth exceeded
+       at /pwd/lang/eval-fail-infinite-recursion-lambda.nix:1:14:
+            1| (x: x x) (x: x x)
+             |              ^
+            2|

tests/functional/lang/eval-fail-infinite-recursion-lambda.nix

@@ -0,0 +1 @@
+(x: x x) (x: x x)

tests/functional/lang/eval-fail-mutual-recursion.err.exp

@@ -0,0 +1,57 @@
+error:
+       … from call site
+         at /pwd/lang/eval-fail-mutual-recursion.nix:36:3:
+           35| in
+           36|   throwAfterA true 10
+             |   ^
+           37|
+
+       … while calling 'throwAfterA'
+         at /pwd/lang/eval-fail-mutual-recursion.nix:29:26:
+           28|
+           29|   throwAfterA = recurse: n:
+             |                          ^
+           30|     if n > 0
+
+       … from call site
+         at /pwd/lang/eval-fail-mutual-recursion.nix:31:10:
+           30|     if n > 0
+           31|     then throwAfterA recurse (n - 1)
+             |          ^
+           32|     else if recurse
+
+       (19 duplicate frames omitted)
+
+       … from call site
+         at /pwd/lang/eval-fail-mutual-recursion.nix:33:10:
+           32|     else if recurse
+           33|     then throwAfterB true 10
+             |          ^
+           34|     else throw "Uh oh!";
+
+       … while calling 'throwAfterB'
+         at /pwd/lang/eval-fail-mutual-recursion.nix:22:26:
+           21| let
+           22|   throwAfterB = recurse: n:
+             |                          ^
+           23|     if n > 0
+
+       … from call site
+         at /pwd/lang/eval-fail-mutual-recursion.nix:24:10:
+           23|     if n > 0
+           24|     then throwAfterB recurse (n - 1)
+             |          ^
+           25|     else if recurse
+
+       (19 duplicate frames omitted)
+
+       … from call site
+         at /pwd/lang/eval-fail-mutual-recursion.nix:26:10:
+           25|     else if recurse
+           26|     then throwAfterA false 10
+             |          ^
+           27|     else throw "Uh oh!";
+
+       (21 duplicate frames omitted)
+
+       error: Uh oh!

tests/functional/lang/eval-fail-mutual-recursion.nix

@@ -0,0 +1,36 @@
+# Check that stack frame deduplication only affects consecutive intervals, and
+# that they are reported independently of any preceding sections, even if
+# they're indistinguishable.
+#
+# In terms of the current implementation, we check that we clear the set of
+# "seen frames" after eliding a group of frames.
+#
+# Suppose we have:
+# - 10 frames in a function A
+# - 10 frames in a function B
+# - 10 frames in a function A
+#
+# We want to output:
+# - a few frames of A (skip the rest)
+# - a few frames of B (skip the rest)
+# - a few frames of A (skip the rest)
+#
+# If we implemented this in the naive manner, we'd instead get:
+# - a few frames of A (skip the rest)
+# - a few frames of B (skip the rest, _and_ skip the remaining frames of A)
+let
+  throwAfterB = recurse: n:
+    if n > 0
+    then throwAfterB recurse (n - 1)
+    else if recurse
+    then throwAfterA false 10
+    else throw "Uh oh!";
+
+  throwAfterA = recurse: n:
+    if n > 0
+    then throwAfterA recurse (n - 1)
+    else if recurse
+    then throwAfterB true 10
+    else throw "Uh oh!";
+in
+  throwAfterA true 10

tests/functional/lang/eval-okay-print.err.exp

@@ -1 +1 @@
-trace: [ <CODE> ]
+trace: [ «thunk» ]

tests/functional/lang/eval-okay-repeated-empty-attrs.exp

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

tests/functional/lang/eval-okay-repeated-empty-attrs.nix

@@ -0,0 +1,2 @@
+# Tests that empty attribute sets are not printed as `«repeated»`.
+[ {} {} ]

tests/functional/lang/eval-okay-repeated-empty-list.exp

@@ -0,0 +1 @@
+[ [ ] [ ] ]

tests/functional/lang/eval-okay-repeated-empty-list.nix

@@ -0,0 +1 @@
+[ [] [] ]

tests/functional/local.mk

@@ -129,15 +129,15 @@ nix_tests = \
   impure-env.sh
 
 ifeq ($(HAVE_LIBCPUID), 1)
-	nix_tests += compute-levels.sh
+  nix_tests += compute-levels.sh
 endif
 
 ifeq ($(ENABLE_BUILD), yes)
-	nix_tests += test-libstoreconsumer.sh
+  nix_tests += test-libstoreconsumer.sh
 
-	ifeq ($(BUILD_SHARED_LIBS), 1)
-		nix_tests += plugins.sh
-	endif
+  ifeq ($(BUILD_SHARED_LIBS), 1)
+    nix_tests += plugins.sh
+  endif
 endif
 
 $(d)/test-libstoreconsumer.sh.test $(d)/test-libstoreconsumer.sh.test-debug: \

tests/functional/remote-store.sh

@@ -19,18 +19,7 @@ else
 fi
 
 # Test import-from-derivation through the daemon.
-[[ $(nix eval --impure --raw --expr '
-  with import ./config.nix;
-  import (
-    mkDerivation {
-      name = "foo";
-      bla = import ./dependencies.nix {};
-      buildCommand = "
-        echo \\\"hi\\\" > $out
-      ";
-    }
-  )
-') = hi ]]
+[[ $(nix eval --impure --raw --file ./ifd.nix) = hi ]]
 
 storeCleared=1 NIX_REMOTE_=$NIX_REMOTE $SHELL ./user-envs.sh
 

tests/functional/shell-hello.nix

@@ -23,4 +23,20 @@ with import ./config.nix;
         chmod +x $dev/bin/hello2
       '';
   };
+
+  salve-mundi = mkDerivation {
+    name = "salve-mundi";
+    outputs = [ "out" ];
+    meta.outputsToInstall = [ "out" ];
+    buildCommand =
+      ''
+        mkdir -p $out/bin
+
+        cat > $out/bin/hello <<EOF
+        #! ${shell}
+        echo "Salve Mundi from $out/bin/hello"
+        EOF
+        chmod +x $out/bin/hello
+      '';
+  };
 }

tests/functional/shell.sh

@@ -10,6 +10,14 @@ nix shell -f shell-hello.nix hello -c hello NixOS | grep 'Hello NixOS'
 nix shell -f shell-hello.nix hello^dev -c hello2 | grep 'Hello2'
 nix shell -f shell-hello.nix 'hello^*' -c hello2 | grep 'Hello2'
 
+
+if isDaemonNewer "2.20.0pre20231220"; then
+    # Test that command line attribute ordering is reflected in the PATH
+    # https://github.com/NixOS/nix/issues/7905
+    nix shell -f shell-hello.nix hello salve-mundi -c hello | grep 'Hello World'
+    nix shell -f shell-hello.nix salve-mundi hello -c hello | grep 'Salve Mundi'
+fi
+
 requireSandboxSupport
 
 chmod -R u+w $TEST_ROOT/store0 || true

tests/functional/test-libstoreconsumer/local.mk

@@ -12,4 +12,4 @@ test-libstoreconsumer_CXXFLAGS += -I src/libutil -I src/libstore
 
 test-libstoreconsumer_LIBS = libstore libutil
 
-test-libstoreconsumer_LDFLAGS = -pthread $(SODIUM_LIBS) $(EDITLINE_LIBS) $(BOOST_LDFLAGS) $(LOWDOWN_LIBS)
+test-libstoreconsumer_LDFLAGS = $(THREAD_LDFLAGS) $(SODIUM_LIBS) $(EDITLINE_LIBS) $(BOOST_LDFLAGS) $(LOWDOWN_LIBS)

tests/nixos/default.nix

@@ -10,7 +10,6 @@ let
     hostPkgs = nixpkgsFor.${system}.native;
     defaults = {
       nixpkgs.pkgs = nixpkgsFor.${system}.native;
-      nix.checkAllErrors = false;
     };
     _module.args.nixpkgs = nixpkgs;
   };

tests/unit/libexpr-support/local.mk

@@ -20,4 +20,4 @@ libexpr-test-support_LIBS = \
     libstore-test-support libutil-test-support \
     libexpr libstore libutil
 
-libexpr-test-support_LDFLAGS := -pthread -lrapidcheck
+libexpr-test-support_LDFLAGS := $(THREAD_LDFLAGS) -lrapidcheck

tests/unit/libexpr/flake/url-name.cc

@@ -1,15 +1,17 @@
-#include "url-name.hh"
+#include "flake/url-name.hh"
 #include <gtest/gtest.h>
 
 namespace nix {
 
 /* ----------- tests for url-name.hh --------------------------------------------------*/
 
-    TEST(getNameFromURL, getsNameFromURL) {
+    TEST(getNameFromURL, getNameFromURL) {
         ASSERT_EQ(getNameFromURL(parseURL("path:/home/user/project")), "project");
         ASSERT_EQ(getNameFromURL(parseURL("path:~/repos/nixpkgs#packages.x86_64-linux.hello")), "hello");
-        ASSERT_EQ(getNameFromURL(parseURL("path:.#nonStandardAttr.mylaptop")), "nonStandardAttr.mylaptop");
-        ASSERT_EQ(getNameFromURL(parseURL("path:./repos/myflake#nonStandardAttr.mylaptop")), "nonStandardAttr.mylaptop");
+        ASSERT_EQ(getNameFromURL(parseURL("path:~/repos/nixpkgs#legacyPackages.x86_64-linux.hello")), "hello");
+        ASSERT_EQ(getNameFromURL(parseURL("path:~/repos/nixpkgs#packages.x86_64-linux.Hello")), "Hello");
+        ASSERT_EQ(getNameFromURL(parseURL("path:.#nonStandardAttr.mylaptop")), "mylaptop");
+        ASSERT_EQ(getNameFromURL(parseURL("path:./repos/myflake#nonStandardAttr.mylaptop")), "mylaptop");
         ASSERT_EQ(getNameFromURL(parseURL("path:./nixpkgs#packages.x86_64-linux.complex^bin,man")), "complex");
         ASSERT_EQ(getNameFromURL(parseURL("path:./myproj#packages.x86_64-linux.default^*")), "myproj");
 

tests/unit/libexpr/local.mk

@@ -16,7 +16,8 @@ endif
 
 libexpr-tests_SOURCES := \
     $(wildcard $(d)/*.cc) \
-    $(wildcard $(d)/value/*.cc)
+    $(wildcard $(d)/value/*.cc) \
+    $(wildcard $(d)/flake/*.cc)
 
 libexpr-tests_EXTRA_INCLUDES = \
     -I tests/unit/libexpr-support \

tests/unit/libexpr/value/print.cc

@@ -1,6 +1,7 @@
 #include "tests/libexpr.hh"
 
 #include "value.hh"
+#include "print.hh"
 
 namespace nix {
 
@@ -12,7 +13,7 @@ struct ValuePrintingTests : LibExprTest
     void test(Value v, std::string_view expected, A... args)
     {
         std::stringstream out;
-        v.print(state.symbols, out, args...);
+        v.print(state, out, args...);
         ASSERT_EQ(out.str(), expected);
     }
 };
@@ -84,7 +85,7 @@ TEST_F(ValuePrintingTests, tList)
     vList.bigList.elems[1] = &vTwo;
     vList.bigList.size = 3;
 
-    test(vList, "[ 1 2 (nullptr) ]");
+    test(vList, "[ 1 2 «nullptr» ]");
 }
 
 TEST_F(ValuePrintingTests, vThunk)
@@ -92,7 +93,7 @@ TEST_F(ValuePrintingTests, vThunk)
     Value vThunk;
     vThunk.mkThunk(nullptr, nullptr);
 
-    test(vThunk, "<CODE>");
+    test(vThunk, "«thunk»");
 }
 
 TEST_F(ValuePrintingTests, vApp)
@@ -100,32 +101,55 @@ TEST_F(ValuePrintingTests, vApp)
     Value vApp;
     vApp.mkApp(nullptr, nullptr);
 
-    test(vApp, "<CODE>");
+    test(vApp, "«thunk»");
 }
 
 TEST_F(ValuePrintingTests, vLambda)
 {
-    Value vLambda;
-    vLambda.mkLambda(nullptr, nullptr);
+    Env env {
+        .up = nullptr,
+        .values = { }
+    };
+    PosTable::Origin origin((std::monostate()));
+    auto posIdx = state.positions.add(origin, 1, 1);
+    auto body = ExprInt(0);
+    auto formals = Formals {};
 
-    test(vLambda, "<LAMBDA>");
+    ExprLambda eLambda(posIdx, createSymbol("a"), &formals, &body);
+
+    Value vLambda;
+    vLambda.mkLambda(&env, &eLambda);
+
+    test(vLambda, "«lambda @ «none»:1:1»");
+
+    eLambda.setName(createSymbol("puppy"));
+
+    test(vLambda, "«lambda puppy @ «none»:1:1»");
 }
 
 TEST_F(ValuePrintingTests, vPrimOp)
 {
     Value vPrimOp;
-    PrimOp primOp{};
+    PrimOp primOp{
+        .name = "puppy"
+    };
     vPrimOp.mkPrimOp(&primOp);
 
-    test(vPrimOp, "<PRIMOP>");
+    test(vPrimOp, "«primop puppy»");
 }
 
 TEST_F(ValuePrintingTests, vPrimOpApp)
 {
-    Value vPrimOpApp;
-    vPrimOpApp.mkPrimOpApp(nullptr, nullptr);
+    PrimOp primOp{
+        .name = "puppy"
+    };
+    Value vPrimOp;
+    vPrimOp.mkPrimOp(&primOp);
 
-    test(vPrimOpApp, "<PRIMOP-APP>");
+    Value vPrimOpApp;
+    vPrimOpApp.mkPrimOpApp(&vPrimOp, nullptr);
+
+    test(vPrimOpApp, "«partially applied primop puppy»");
 }
 
 TEST_F(ValuePrintingTests, vExternal)
@@ -176,9 +200,14 @@ TEST_F(ValuePrintingTests, depthAttrs)
     Value vTwo;
     vTwo.mkInt(2);
 
+    BindingsBuilder builderEmpty(state, state.allocBindings(0));
+    Value vAttrsEmpty;
+    vAttrsEmpty.mkAttrs(builderEmpty.finish());
+
     BindingsBuilder builder(state, state.allocBindings(10));
     builder.insert(state.symbols.create("one"), &vOne);
     builder.insert(state.symbols.create("two"), &vTwo);
+    builder.insert(state.symbols.create("nested"), &vAttrsEmpty);
 
     Value vAttrs;
     vAttrs.mkAttrs(builder.finish());
@@ -191,10 +220,10 @@ TEST_F(ValuePrintingTests, depthAttrs)
     Value vNested;
     vNested.mkAttrs(builder2.finish());
 
-    test(vNested, "{ nested = «too deep»; one = «too deep»; two = «too deep»; }", false, 1);
-    test(vNested, "{ nested = { one = «too deep»; two = «too deep»; }; one = 1; two = 2; }", false, 2);
-    test(vNested, "{ nested = { one = 1; two = 2; }; one = 1; two = 2; }", false, 3);
-    test(vNested, "{ nested = { one = 1; two = 2; }; one = 1; two = 2; }", false, 4);
+    test(vNested, "{ nested = { ... }; one = 1; two = 2; }", PrintOptions { .maxDepth = 1 });
+    test(vNested, "{ nested = { nested = { ... }; one = 1; two = 2; }; one = 1; two = 2; }", PrintOptions { .maxDepth = 2 });
+    test(vNested, "{ nested = { nested = { }; one = 1; two = 2; }; one = 1; two = 2; }", PrintOptions { .maxDepth = 3 });
+    test(vNested, "{ nested = { nested = { }; one = 1; two = 2; }; one = 1; two = 2; }", PrintOptions { .maxDepth = 4 });
 }
 
 TEST_F(ValuePrintingTests, depthList)
@@ -227,11 +256,561 @@ TEST_F(ValuePrintingTests, depthList)
     vList.bigList.elems[2] = &vNested;
     vList.bigList.size = 3;
 
-    test(vList, "[ «too deep» «too deep» «too deep» ]", false, 1);
-    test(vList, "[ 1 2 { nested = «too deep»; one = «too deep»; two = «too deep»; } ]", false, 2);
-    test(vList, "[ 1 2 { nested = { one = «too deep»; two = «too deep»; }; one = 1; two = 2; } ]", false, 3);
-    test(vList, "[ 1 2 { nested = { one = 1; two = 2; }; one = 1; two = 2; } ]", false, 4);
-    test(vList, "[ 1 2 { nested = { one = 1; two = 2; }; one = 1; two = 2; } ]", false, 5);
+    test(vList, "[ 1 2 { ... } ]", PrintOptions { .maxDepth = 1 });
+    test(vList, "[ 1 2 { nested = { ... }; one = 1; two = 2; } ]", PrintOptions { .maxDepth = 2 });
+    test(vList, "[ 1 2 { nested = { one = 1; two = 2; }; one = 1; two = 2; } ]", PrintOptions { .maxDepth = 3 });
+    test(vList, "[ 1 2 { nested = { one = 1; two = 2; }; one = 1; two = 2; } ]", PrintOptions { .maxDepth = 4 });
+    test(vList, "[ 1 2 { nested = { one = 1; two = 2; }; one = 1; two = 2; } ]", PrintOptions { .maxDepth = 5 });
+}
+
+struct StringPrintingTests : LibExprTest
+{
+    template<class... A>
+    void test(std::string_view literal, std::string_view expected, unsigned int maxLength, A... args)
+    {
+        Value v;
+        v.mkString(literal);
+
+        std::stringstream out;
+        printValue(state, out, v, PrintOptions {
+            .maxStringLength = maxLength
+        });
+        ASSERT_EQ(out.str(), expected);
+    }
+};
+
+TEST_F(StringPrintingTests, maxLengthTruncation)
+{
+    test("abcdefghi", "\"abcdefghi\"", 10);
+    test("abcdefghij", "\"abcdefghij\"", 10);
+    test("abcdefghijk", "\"abcdefghij\" «1 byte elided»", 10);
+    test("abcdefghijkl", "\"abcdefghij\" «2 bytes elided»", 10);
+    test("abcdefghijklm", "\"abcdefghij\" «3 bytes elided»", 10);
+}
+
+// Check that printing an attrset shows 'important' attributes like `type`
+// first, but only reorder the attrs when we have a maxAttrs budget.
+TEST_F(ValuePrintingTests, attrsTypeFirst)
+{
+    Value vType;
+    vType.mkString("puppy");
+
+    Value vApple;
+    vApple.mkString("apple");
+
+    BindingsBuilder builder(state, state.allocBindings(10));
+    builder.insert(state.symbols.create("type"), &vType);
+    builder.insert(state.symbols.create("apple"), &vApple);
+
+    Value vAttrs;
+    vAttrs.mkAttrs(builder.finish());
+
+    test(vAttrs,
+         "{ type = \"puppy\"; apple = \"apple\"; }",
+         PrintOptions {
+            .maxAttrs = 100
+         });
+
+    test(vAttrs,
+         "{ apple = \"apple\"; type = \"puppy\"; }",
+         PrintOptions { });
+}
+
+TEST_F(ValuePrintingTests, ansiColorsInt)
+{
+    Value v;
+    v.mkInt(10);
+
+    test(v,
+         ANSI_CYAN "10" ANSI_NORMAL,
+         PrintOptions {
+             .ansiColors = true
+         });
+}
+
+TEST_F(ValuePrintingTests, ansiColorsFloat)
+{
+    Value v;
+    v.mkFloat(1.6);
+
+    test(v,
+         ANSI_CYAN "1.6" ANSI_NORMAL,
+         PrintOptions {
+             .ansiColors = true
+         });
+}
+
+TEST_F(ValuePrintingTests, ansiColorsBool)
+{
+    Value v;
+    v.mkBool(true);
+
+    test(v,
+         ANSI_CYAN "true" ANSI_NORMAL,
+         PrintOptions {
+             .ansiColors = true
+         });
+}
+
+TEST_F(ValuePrintingTests, ansiColorsString)
+{
+    Value v;
+    v.mkString("puppy");
+
+    test(v,
+         ANSI_MAGENTA "\"puppy\"" ANSI_NORMAL,
+         PrintOptions {
+             .ansiColors = true
+        });
+}
+
+TEST_F(ValuePrintingTests, ansiColorsStringElided)
+{
+    Value v;
+    v.mkString("puppy");
+
+    test(v,
+         ANSI_MAGENTA "\"pup\"" ANSI_FAINT " «2 bytes elided»" ANSI_NORMAL,
+         PrintOptions {
+             .ansiColors = true,
+             .maxStringLength = 3
+         });
+}
+
+TEST_F(ValuePrintingTests, ansiColorsPath)
+{
+    Value v;
+    v.mkPath(state.rootPath(CanonPath("puppy")));
+
+    test(v,
+         ANSI_GREEN "/puppy" ANSI_NORMAL,
+         PrintOptions {
+             .ansiColors = true
+         });
+}
+
+TEST_F(ValuePrintingTests, ansiColorsNull)
+{
+    Value v;
+    v.mkNull();
+
+    test(v,
+         ANSI_CYAN "null" ANSI_NORMAL,
+         PrintOptions {
+             .ansiColors = true
+         });
+}
+
+TEST_F(ValuePrintingTests, ansiColorsAttrs)
+{
+    Value vOne;
+    vOne.mkInt(1);
+
+    Value vTwo;
+    vTwo.mkInt(2);
+
+    BindingsBuilder builder(state, state.allocBindings(10));
+    builder.insert(state.symbols.create("one"), &vOne);
+    builder.insert(state.symbols.create("two"), &vTwo);
+
+    Value vAttrs;
+    vAttrs.mkAttrs(builder.finish());
+
+    test(vAttrs,
+         "{ one = " ANSI_CYAN "1" ANSI_NORMAL "; two = " ANSI_CYAN "2" ANSI_NORMAL "; }",
+         PrintOptions {
+             .ansiColors = true
+         });
+}
+
+TEST_F(ValuePrintingTests, ansiColorsDerivation)
+{
+    Value vDerivation;
+    vDerivation.mkString("derivation");
+
+    BindingsBuilder builder(state, state.allocBindings(10));
+    builder.insert(state.sType, &vDerivation);
+
+    Value vAttrs;
+    vAttrs.mkAttrs(builder.finish());
+
+    test(vAttrs,
+         ANSI_GREEN "«derivation»" ANSI_NORMAL,
+         PrintOptions {
+             .ansiColors = true,
+             .force = true,
+             .derivationPaths = true
+         });
+
+    test(vAttrs,
+         "{ type = " ANSI_MAGENTA "\"derivation\"" ANSI_NORMAL "; }",
+         PrintOptions {
+             .ansiColors = true,
+             .force = true
+         });
+}
+
+TEST_F(ValuePrintingTests, ansiColorsError)
+{
+    Value throw_ = state.getBuiltin("throw");
+    Value message;
+    message.mkString("uh oh!");
+    Value vError;
+    vError.mkApp(&throw_, &message);
+
+    test(vError,
+         ANSI_RED
+         "«"
+         ANSI_RED
+         "error:"
+         ANSI_NORMAL
+         "\n       … while calling the '"
+         ANSI_MAGENTA
+         "throw"
+         ANSI_NORMAL
+         "' builtin\n\n       "
+         ANSI_RED
+         "error:"
+         ANSI_NORMAL
+         " uh oh!»"
+         ANSI_NORMAL,
+         PrintOptions {
+             .ansiColors = true,
+             .force = true,
+         });
+}
+
+TEST_F(ValuePrintingTests, ansiColorsDerivationError)
+{
+    Value throw_ = state.getBuiltin("throw");
+    Value message;
+    message.mkString("uh oh!");
+    Value vError;
+    vError.mkApp(&throw_, &message);
+
+    Value vDerivation;
+    vDerivation.mkString("derivation");
+
+    BindingsBuilder builder(state, state.allocBindings(10));
+    builder.insert(state.sType, &vDerivation);
+    builder.insert(state.sDrvPath, &vError);
+
+    Value vAttrs;
+    vAttrs.mkAttrs(builder.finish());
+
+    test(vAttrs,
+         "{ drvPath = "
+         ANSI_RED
+         "«"
+         ANSI_RED
+         "error:"
+         ANSI_NORMAL
+         "\n       … while calling the '"
+         ANSI_MAGENTA
+         "throw"
+         ANSI_NORMAL
+         "' builtin\n\n       "
+         ANSI_RED
+         "error:"
+         ANSI_NORMAL
+         " uh oh!»"
+         ANSI_NORMAL
+         "; type = "
+         ANSI_MAGENTA
+         "\"derivation\""
+         ANSI_NORMAL
+         "; }",
+         PrintOptions {
+             .ansiColors = true,
+             .force = true
+         });
+
+    test(vAttrs,
+         ANSI_RED
+         "«"
+         ANSI_RED
+         "error:"
+         ANSI_NORMAL
+         "\n       … while calling the '"
+         ANSI_MAGENTA
+         "throw"
+         ANSI_NORMAL
+         "' builtin\n\n       "
+         ANSI_RED
+         "error:"
+         ANSI_NORMAL
+         " uh oh!»"
+         ANSI_NORMAL,
+         PrintOptions {
+             .ansiColors = true,
+             .force = true,
+             .derivationPaths = true,
+         });
+}
+
+TEST_F(ValuePrintingTests, ansiColorsAssert)
+{
+    ExprVar eFalse(state.symbols.create("false"));
+    eFalse.bindVars(state, state.staticBaseEnv);
+    ExprInt eInt(1);
+
+    ExprAssert expr(noPos, &eFalse, &eInt);
+
+    Value v;
+    state.mkThunk_(v, &expr);
+
+    test(v,
+         ANSI_RED "«" ANSI_RED "error:" ANSI_NORMAL " assertion '" ANSI_MAGENTA "false" ANSI_NORMAL "' failed»" ANSI_NORMAL,
+         PrintOptions {
+             .ansiColors = true,
+             .force = true
+         });
+}
+
+TEST_F(ValuePrintingTests, ansiColorsList)
+{
+    Value vOne;
+    vOne.mkInt(1);
+
+    Value vTwo;
+    vTwo.mkInt(2);
+
+    Value vList;
+    state.mkList(vList, 5);
+    vList.bigList.elems[0] = &vOne;
+    vList.bigList.elems[1] = &vTwo;
+    vList.bigList.size = 3;
+
+    test(vList,
+         "[ " ANSI_CYAN "1" ANSI_NORMAL " " ANSI_CYAN "2" ANSI_NORMAL " " ANSI_MAGENTA "«nullptr»" ANSI_NORMAL " ]",
+         PrintOptions {
+             .ansiColors = true
+         });
+}
+
+TEST_F(ValuePrintingTests, ansiColorsLambda)
+{
+    Env env {
+        .up = nullptr,
+        .values = { }
+    };
+    PosTable::Origin origin((std::monostate()));
+    auto posIdx = state.positions.add(origin, 1, 1);
+    auto body = ExprInt(0);
+    auto formals = Formals {};
+
+    ExprLambda eLambda(posIdx, createSymbol("a"), &formals, &body);
+
+    Value vLambda;
+    vLambda.mkLambda(&env, &eLambda);
+
+    test(vLambda,
+         ANSI_BLUE "«lambda @ «none»:1:1»" ANSI_NORMAL,
+         PrintOptions {
+             .ansiColors = true,
+             .force = true
+         });
+
+    eLambda.setName(createSymbol("puppy"));
+
+    test(vLambda,
+         ANSI_BLUE "«lambda puppy @ «none»:1:1»" ANSI_NORMAL,
+         PrintOptions {
+             .ansiColors = true,
+             .force = true
+         });
+}
+
+TEST_F(ValuePrintingTests, ansiColorsPrimOp)
+{
+    PrimOp primOp{
+        .name = "puppy"
+    };
+    Value v;
+    v.mkPrimOp(&primOp);
+
+    test(v,
+         ANSI_BLUE "«primop puppy»" ANSI_NORMAL,
+         PrintOptions {
+             .ansiColors = true
+         });
+}
+
+TEST_F(ValuePrintingTests, ansiColorsPrimOpApp)
+{
+    PrimOp primOp{
+        .name = "puppy"
+    };
+    Value vPrimOp;
+    vPrimOp.mkPrimOp(&primOp);
+
+    Value v;
+    v.mkPrimOpApp(&vPrimOp, nullptr);
+
+    test(v,
+         ANSI_BLUE "«partially applied primop puppy»" ANSI_NORMAL,
+         PrintOptions {
+             .ansiColors = true
+         });
+}
+
+TEST_F(ValuePrintingTests, ansiColorsThunk)
+{
+    Value v;
+    v.mkThunk(nullptr, nullptr);
+
+    test(v,
+         ANSI_MAGENTA "«thunk»" ANSI_NORMAL,
+         PrintOptions {
+             .ansiColors = true
+         });
+}
+
+TEST_F(ValuePrintingTests, ansiColorsBlackhole)
+{
+    Value v;
+    v.mkBlackhole();
+
+    test(v,
+         ANSI_RED "«potential infinite recursion»" ANSI_NORMAL,
+         PrintOptions {
+             .ansiColors = true
+         });
+}
+
+TEST_F(ValuePrintingTests, ansiColorsAttrsRepeated)
+{
+    BindingsBuilder emptyBuilder(state, state.allocBindings(1));
+
+    Value vEmpty;
+    vEmpty.mkAttrs(emptyBuilder.finish());
+
+    BindingsBuilder builder(state, state.allocBindings(10));
+    builder.insert(state.symbols.create("a"), &vEmpty);
+    builder.insert(state.symbols.create("b"), &vEmpty);
+
+    Value vAttrs;
+    vAttrs.mkAttrs(builder.finish());
+
+    test(vAttrs,
+         "{ a = { }; b = " ANSI_MAGENTA "«repeated»" ANSI_NORMAL "; }",
+         PrintOptions {
+             .ansiColors = true
+         });
+}
+
+TEST_F(ValuePrintingTests, ansiColorsListRepeated)
+{
+    BindingsBuilder emptyBuilder(state, state.allocBindings(1));
+
+    Value vEmpty;
+    vEmpty.mkAttrs(emptyBuilder.finish());
+
+    Value vList;
+    state.mkList(vList, 3);
+    vList.bigList.elems[0] = &vEmpty;
+    vList.bigList.elems[1] = &vEmpty;
+    vList.bigList.size = 2;
+
+    test(vList,
+         "[ { } " ANSI_MAGENTA "«repeated»" ANSI_NORMAL " ]",
+         PrintOptions {
+             .ansiColors = true
+         });
+}
+
+TEST_F(ValuePrintingTests, listRepeated)
+{
+    BindingsBuilder emptyBuilder(state, state.allocBindings(1));
+
+    Value vEmpty;
+    vEmpty.mkAttrs(emptyBuilder.finish());
+
+    Value vList;
+    state.mkList(vList, 3);
+    vList.bigList.elems[0] = &vEmpty;
+    vList.bigList.elems[1] = &vEmpty;
+    vList.bigList.size = 2;
+
+    test(vList, "[ { } «repeated» ]", PrintOptions { });
+    test(vList,
+         "[ { } { } ]",
+         PrintOptions {
+             .trackRepeated = false
+         });
+}
+
+TEST_F(ValuePrintingTests, ansiColorsAttrsElided)
+{
+    Value vOne;
+    vOne.mkInt(1);
+
+    Value vTwo;
+    vTwo.mkInt(2);
+
+    BindingsBuilder builder(state, state.allocBindings(10));
+    builder.insert(state.symbols.create("one"), &vOne);
+    builder.insert(state.symbols.create("two"), &vTwo);
+
+    Value vAttrs;
+    vAttrs.mkAttrs(builder.finish());
+
+    test(vAttrs,
+         "{ one = " ANSI_CYAN "1" ANSI_NORMAL "; " ANSI_FAINT " «1 attribute elided»" ANSI_NORMAL "}",
+         PrintOptions {
+             .ansiColors = true,
+             .maxAttrs = 1
+         });
+
+    Value vThree;
+    vThree.mkInt(3);
+
+    builder.insert(state.symbols.create("three"), &vThree);
+    vAttrs.mkAttrs(builder.finish());
+
+    test(vAttrs,
+         "{ one = " ANSI_CYAN "1" ANSI_NORMAL "; " ANSI_FAINT " «2 attributes elided»" ANSI_NORMAL "}",
+         PrintOptions {
+             .ansiColors = true,
+             .maxAttrs = 1
+         });
+}
+
+TEST_F(ValuePrintingTests, ansiColorsListElided)
+{
+    BindingsBuilder emptyBuilder(state, state.allocBindings(1));
+
+    Value vOne;
+    vOne.mkInt(1);
+
+    Value vTwo;
+    vTwo.mkInt(2);
+
+    Value vList;
+    state.mkList(vList, 4);
+    vList.bigList.elems[0] = &vOne;
+    vList.bigList.elems[1] = &vTwo;
+    vList.bigList.size = 2;
+
+    test(vList,
+         "[ " ANSI_CYAN "1" ANSI_NORMAL " " ANSI_FAINT " «1 item elided»" ANSI_NORMAL "]",
+         PrintOptions {
+             .ansiColors = true,
+             .maxListItems = 1
+         });
+
+    Value vThree;
+    vThree.mkInt(3);
+
+    vList.bigList.elems[2] = &vThree;
+    vList.bigList.size = 3;
+
+    test(vList,
+         "[ " ANSI_CYAN "1" ANSI_NORMAL " " ANSI_FAINT " «2 items elided»" ANSI_NORMAL "]",
+         PrintOptions {
+             .ansiColors = true,
+             .maxListItems = 1
+         });
 }
 
 } // namespace nix

tests/unit/libstore-support/local.mk

@@ -18,4 +18,4 @@ libstore-test-support_LIBS = \
     libutil-test-support \
     libstore libutil
 
-libstore-test-support_LDFLAGS := -pthread -lrapidcheck
+libstore-test-support_LDFLAGS := $(THREAD_LDFLAGS) -lrapidcheck

tests/unit/libutil-support/local.mk

@@ -16,4 +16,4 @@ libutil-test-support_CXXFLAGS += $(libutil-tests_EXTRA_INCLUDES)
 
 libutil-test-support_LIBS = libutil
 
-libutil-test-support_LDFLAGS := -pthread -lrapidcheck
+libutil-test-support_LDFLAGS := $(THREAD_LDFLAGS) -lrapidcheck