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/libexpr-test-support/.version

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

src/libexpr-test-support/build-utils-meson

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

src/libexpr-test-support/local.mk

@@ -0,0 +1,23 @@
+libraries += libexpr-test-support
+
+libexpr-test-support_NAME = libnixexpr-test-support
+
+libexpr-test-support_DIR := $(d)
+
+ifeq ($(INSTALL_UNIT_TESTS), yes)
+  libexpr-test-support_INSTALL_DIR := $(checklibdir)
+else
+  libexpr-test-support_INSTALL_DIR :=
+endif
+
+libexpr-test-support_SOURCES := \
+    $(wildcard $(d)/tests/*.cc) \
+    $(wildcard $(d)/tests/value/*.cc)
+
+libexpr-test-support_CXXFLAGS += $(libexpr-tests_EXTRA_INCLUDES)
+
+libexpr-test-support_LIBS = \
+    libstore-test-support libutil-test-support \
+    libexpr libstore libutil
+
+libexpr-test-support_LDFLAGS := $(THREAD_LDFLAGS) -lrapidcheck

src/libexpr-test-support/meson.build

@@ -0,0 +1,76 @@
+project('nix-expr-test-support', 'cpp',
+  version : files('.version'),
+  default_options : [
+    'cpp_std=c++2a',
+    # TODO(Qyriad): increase the warning level
+    'warning_level=1',
+    'debug=true',
+    'optimization=2',
+    'errorlogs=true', # Please print logs for tests that fail
+  ],
+  meson_version : '>= 1.1',
+  license : 'LGPL-2.1-or-later',
+)
+
+cxx = meson.get_compiler('cpp')
+
+subdir('build-utils-meson/deps-lists')
+
+deps_private_maybe_subproject = [
+]
+deps_public_maybe_subproject = [
+  dependency('nix-util'),
+  dependency('nix-util-test-support'),
+  dependency('nix-store'),
+  dependency('nix-store-test-support'),
+  dependency('nix-expr'),
+]
+subdir('build-utils-meson/subprojects')
+
+subdir('build-utils-meson/threads')
+
+rapidcheck = dependency('rapidcheck')
+deps_public += rapidcheck
+
+add_project_arguments(
+  # TODO(Qyriad): Yes this is how the autoconf+Make system did it.
+  # It would be nice for our headers to be idempotent instead.
+  '-include', 'config-util.hh',
+  '-include', 'config-store.hh',
+  '-include', 'config-expr.hh',
+  language : 'cpp',
+)
+
+subdir('build-utils-meson/diagnostics')
+
+sources = files(
+  'tests/value/context.cc',
+)
+
+include_dirs = [include_directories('.')]
+
+headers = files(
+  'tests/libexpr.hh',
+  'tests/nix_api_expr.hh',
+  'tests/value/context.hh',
+)
+
+subdir('build-utils-meson/export-all-symbols')
+
+this_library = library(
+  'nix-expr-test-support',
+  sources,
+  dependencies : deps_public + deps_private + deps_other,
+  include_directories : include_dirs,
+  # TODO: Remove `-lrapidcheck` when https://github.com/emil-e/rapidcheck/pull/326
+  #       is available. See also ../libutil/build.meson
+  link_args: linker_export_flags + ['-lrapidcheck'],
+  prelink : true, # For C++ static initializers
+  install : true,
+)
+
+install_headers(headers, subdir : 'nix', preserve_path : true)
+
+libraries_private = []
+
+subdir('build-utils-meson/export')

src/libexpr-test-support/package.nix

@@ -0,0 +1,60 @@
+{ lib
+, stdenv
+, mkMesonLibrary
+
+, nix-store-test-support
+, nix-expr
+
+, rapidcheck
+
+# Configuration Options
+
+, version
+}:
+
+let
+  inherit (lib) fileset;
+in
+
+mkMesonLibrary (finalAttrs: {
+  pname = "nix-util-test-support";
+  inherit version;
+
+  workDir = ./.;
+  fileset = fileset.unions [
+    ../../build-utils-meson
+    ./build-utils-meson
+    ../../.version
+    ./.version
+    ./meson.build
+    # ./meson.options
+    (fileset.fileFilter (file: file.hasExt "cc") ./.)
+    (fileset.fileFilter (file: file.hasExt "hh") ./.)
+  ];
+
+  propagatedBuildInputs = [
+    nix-store-test-support
+    nix-expr
+    rapidcheck
+  ];
+
+  preConfigure =
+    # "Inline" .version so it's not a symlink, and includes the suffix.
+    # Do the meson utils, without modification.
+    ''
+      chmod u+w ./.version
+      echo ${version} > ../../.version
+    '';
+
+  mesonFlags = [
+  ];
+
+  env = lib.optionalAttrs (stdenv.isLinux && !(stdenv.hostPlatform.isStatic && stdenv.system == "aarch64-linux")) {
+    LDFLAGS = "-fuse-ld=gold";
+  };
+
+  meta = {
+    platforms = lib.platforms.unix ++ lib.platforms.windows;
+  };
+
+})

src/libexpr-test-support/tests/libexpr.hh

@@ -0,0 +1,150 @@
+#pragma once
+///@file
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include "fetch-settings.hh"
+#include "value.hh"
+#include "nixexpr.hh"
+#include "nixexpr.hh"
+#include "eval.hh"
+#include "eval-gc.hh"
+#include "eval-inline.hh"
+#include "eval-settings.hh"
+
+#include "tests/libstore.hh"
+
+namespace nix {
+    class LibExprTest : public LibStoreTest {
+        public:
+            static void SetUpTestSuite() {
+                LibStoreTest::SetUpTestSuite();
+                initGC();
+            }
+
+        protected:
+            LibExprTest()
+                : LibStoreTest()
+                , state({}, store, fetchSettings, evalSettings, nullptr)
+            {
+                evalSettings.nixPath = {};
+            }
+            Value eval(std::string input, bool forceValue = true) {
+                Value v;
+                Expr * e = state.parseExprFromString(input, state.rootPath(CanonPath::root));
+                assert(e);
+                state.eval(e, v);
+                if (forceValue)
+                    state.forceValue(v, noPos);
+                return v;
+            }
+
+            Symbol createSymbol(const char * value) {
+                return state.symbols.create(value);
+            }
+
+            bool readOnlyMode = true;
+            fetchers::Settings fetchSettings{};
+            EvalSettings evalSettings{readOnlyMode};
+            EvalState state;
+    };
+
+    MATCHER(IsListType, "") {
+        return arg != nList;
+    }
+
+    MATCHER(IsList, "") {
+        return arg.type() == nList;
+    }
+
+    MATCHER(IsString, "") {
+        return arg.type() == nString;
+    }
+
+    MATCHER(IsNull, "") {
+        return arg.type() == nNull;
+    }
+
+    MATCHER(IsThunk, "") {
+        return arg.type() == nThunk;
+    }
+
+    MATCHER(IsAttrs, "") {
+        return arg.type() == nAttrs;
+    }
+
+    MATCHER_P(IsStringEq, s, fmt("The string is equal to \"%1%\"", s)) {
+        if (arg.type() != nString) {
+            return false;
+        }
+        return std::string_view(arg.c_str()) == s;
+    }
+
+    MATCHER_P(IsIntEq, v, fmt("The string is equal to \"%1%\"", v)) {
+        if (arg.type() != nInt) {
+            return false;
+        }
+        return arg.integer().value == v;
+    }
+
+    MATCHER_P(IsFloatEq, v, fmt("The float is equal to \"%1%\"", v)) {
+        if (arg.type() != nFloat) {
+            return false;
+        }
+        return arg.fpoint() == v;
+    }
+
+    MATCHER(IsTrue, "") {
+        if (arg.type() != nBool) {
+            return false;
+        }
+        return arg.boolean() == true;
+    }
+
+    MATCHER(IsFalse, "") {
+        if (arg.type() != nBool) {
+            return false;
+        }
+        return arg.boolean() == false;
+    }
+
+    MATCHER_P(IsPathEq, p, fmt("Is a path equal to \"%1%\"", p)) {
+        if (arg.type() != nPath) {
+            *result_listener << "Expected a path got " << arg.type();
+            return false;
+        } else {
+            auto path = arg.path();
+            if (path.path != CanonPath(p)) {
+                *result_listener << "Expected a path that equals \"" << p << "\" but got: " << path.path;
+                return false;
+            }
+        }
+        return true;
+    }
+
+
+    MATCHER_P(IsListOfSize, n, fmt("Is a list of size [%1%]", n)) {
+        if (arg.type() != nList) {
+            *result_listener << "Expected list got " << arg.type();
+            return false;
+        } else if (arg.listSize() != (size_t)n) {
+            *result_listener << "Expected as list of size " << n << " got " << arg.listSize();
+            return false;
+        }
+        return true;
+    }
+
+    MATCHER_P(IsAttrsOfSize, n, fmt("Is a set of size [%1%]", n)) {
+        if (arg.type() != nAttrs) {
+            *result_listener << "Expected set got " << arg.type();
+            return false;
+        } else if (arg.attrs()->size() != (size_t) n) {
+            *result_listener << "Expected a set with " << n << " attributes but got " << arg.attrs()->size();
+            return false;
+        }
+        return true;
+    }
+
+
+} /* namespace nix */

src/libexpr-test-support/tests/nix_api_expr.hh

@@ -0,0 +1,31 @@
+#pragma once
+///@file
+#include "nix_api_expr.h"
+#include "nix_api_value.h"
+#include "tests/nix_api_store.hh"
+
+#include <gtest/gtest.h>
+
+namespace nixC {
+
+class nix_api_expr_test : public nix_api_store_test
+{
+protected:
+
+    nix_api_expr_test()
+    {
+        nix_libexpr_init(ctx);
+        state = nix_state_create(nullptr, nullptr, store);
+        value = nix_alloc_value(nullptr, state);
+    }
+    ~nix_api_expr_test()
+    {
+        nix_gc_decref(nullptr, value);
+        nix_state_free(state);
+    }
+
+    EvalState * state;
+    nix_value * value;
+};
+
+}

src/libexpr-test-support/tests/value/context.cc

@@ -0,0 +1,30 @@
+#include <rapidcheck.h>
+
+#include "tests/path.hh"
+#include "tests/value/context.hh"
+
+namespace rc {
+using namespace nix;
+
+Gen<NixStringContextElem::DrvDeep> Arbitrary<NixStringContextElem::DrvDeep>::arbitrary()
+{
+    return gen::just(NixStringContextElem::DrvDeep {
+        .drvPath = *gen::arbitrary<StorePath>(),
+    });
+}
+
+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);
+    }
+}
+
+}

src/libexpr-test-support/tests/value/context.hh

@@ -0,0 +1,31 @@
+#pragma once
+///@file
+
+#include <rapidcheck/gen/Arbitrary.h>
+
+#include "value/context.hh"
+
+namespace rc {
+using namespace nix;
+
+template<>
+struct Arbitrary<NixStringContextElem::Opaque> {
+    static Gen<NixStringContextElem::Opaque> arbitrary();
+};
+
+template<>
+struct Arbitrary<NixStringContextElem::Built> {
+    static Gen<NixStringContextElem::Built> arbitrary();
+};
+
+template<>
+struct Arbitrary<NixStringContextElem::DrvDeep> {
+    static Gen<NixStringContextElem::DrvDeep> arbitrary();
+};
+
+template<>
+struct Arbitrary<NixStringContextElem> {
+    static Gen<NixStringContextElem> arbitrary();
+};
+
+}