nixos/nix
1
1
Fork 0
mirror of https://github.com/NixOS/nix.git synced 2025-12-11 19:41:04 +01:00
Code Activity

Merge remote-tracking branch 'origin/2.29-maintenance' into detsys-main

Browse source
This commit is contained in:
Eelco Dolstra 2025-05-16 12:48:44 +02:00
commit c20642ac7b
354 changed files with 6768 additions and 3808 deletions
Download patch file Download diff file Expand all files Collapse all files

28
src/libutil-tests/args.cc
View file

@ -9,7 +9,7 @@ namespace nix {
TEST(parseShebangContent, basic) {
std::list<std::string> r = parseShebangContent("hi there");
ASSERT_EQ(r.size(), 2);
ASSERT_EQ(r.size(), 2u);
auto i = r.begin();
ASSERT_EQ(*i++, "hi");
ASSERT_EQ(*i++, "there");
@ -17,26 +17,26 @@ namespace nix {
TEST(parseShebangContent, empty) {
std::list<std::string> r = parseShebangContent("");
ASSERT_EQ(r.size(), 0);
ASSERT_EQ(r.size(), 0u);
}
TEST(parseShebangContent, doubleBacktick) {
std::list<std::string> r = parseShebangContent("``\"ain't that nice\"``");
ASSERT_EQ(r.size(), 1);
ASSERT_EQ(r.size(), 1u);
auto i = r.begin();
ASSERT_EQ(*i++, "\"ain't that nice\"");
}
TEST(parseShebangContent, doubleBacktickEmpty) {
std::list<std::string> r = parseShebangContent("````");
ASSERT_EQ(r.size(), 1);
ASSERT_EQ(r.size(), 1u);
auto i = r.begin();
ASSERT_EQ(*i++, "");
}
TEST(parseShebangContent, doubleBacktickMarkdownInlineCode) {
std::list<std::string> r = parseShebangContent("``# I'm markdown section about `coolFunction` ``");
ASSERT_EQ(r.size(), 1);
ASSERT_EQ(r.size(), 1u);
auto i = r.begin();
ASSERT_EQ(*i++, "# I'm markdown section about `coolFunction`");
}
@ -44,49 +44,49 @@ namespace nix {
TEST(parseShebangContent, doubleBacktickMarkdownCodeBlockNaive) {
std::list<std::string> r = parseShebangContent("``Example 1\n```nix\na: a\n``` ``");
auto i = r.begin();
ASSERT_EQ(r.size(), 1);
ASSERT_EQ(r.size(), 1u);
ASSERT_EQ(*i++, "Example 1\n``nix\na: a\n``");
}
TEST(parseShebangContent, doubleBacktickMarkdownCodeBlockCorrect) {
std::list<std::string> r = parseShebangContent("``Example 1\n````nix\na: a\n```` ``");
auto i = r.begin();
ASSERT_EQ(r.size(), 1);
ASSERT_EQ(r.size(), 1u);
ASSERT_EQ(*i++, "Example 1\n```nix\na: a\n```");
}
TEST(parseShebangContent, doubleBacktickMarkdownCodeBlock2) {
std::list<std::string> r = parseShebangContent("``Example 1\n````nix\na: a\n````\nExample 2\n````nix\na: a\n```` ``");
auto i = r.begin();
ASSERT_EQ(r.size(), 1);
ASSERT_EQ(r.size(), 1u);
ASSERT_EQ(*i++, "Example 1\n```nix\na: a\n```\nExample 2\n```nix\na: a\n```");
}
TEST(parseShebangContent, singleBacktickInDoubleBacktickQuotes) {
std::list<std::string> r = parseShebangContent("``` ``");
auto i = r.begin();
ASSERT_EQ(r.size(), 1);
ASSERT_EQ(r.size(), 1u);
ASSERT_EQ(*i++, "`");
}
TEST(parseShebangContent, singleBacktickAndSpaceInDoubleBacktickQuotes) {
std::list<std::string> r = parseShebangContent("``` ``");
auto i = r.begin();
ASSERT_EQ(r.size(), 1);
ASSERT_EQ(r.size(), 1u);
ASSERT_EQ(*i++, "` ");
}
TEST(parseShebangContent, doubleBacktickInDoubleBacktickQuotes) {
std::list<std::string> r = parseShebangContent("````` ``");
auto i = r.begin();
ASSERT_EQ(r.size(), 1);
ASSERT_EQ(r.size(), 1u);
ASSERT_EQ(*i++, "``");
}
TEST(parseShebangContent, increasingQuotes) {
std::list<std::string> r = parseShebangContent("```` ``` `` ````` `` `````` ``");
auto i = r.begin();
ASSERT_EQ(r.size(), 4);
ASSERT_EQ(r.size(), 4u);
ASSERT_EQ(*i++, "");
ASSERT_EQ(*i++, "`");
ASSERT_EQ(*i++, "``");
@ -146,7 +146,7 @@ RC_GTEST_PROP(
auto escaped = escape(orig);
// RC_LOG() << "escaped: <[[" << escaped << "]]>" << std::endl;
auto ss = parseShebangContent(escaped);
RC_ASSERT(ss.size() == 1);
RC_ASSERT(ss.size() == 1u);
RC_ASSERT(*ss.begin() == orig);
}
@ -156,7 +156,7 @@ RC_GTEST_PROP(
(const std::string & one, const std::string & two))
{
auto ss = parseShebangContent(escape(one) + " " + escape(two));
RC_ASSERT(ss.size() == 2);
RC_ASSERT(ss.size() == 2u);
auto i = ss.begin();
RC_ASSERT(*i++ == one);
RC_ASSERT(*i++ == two);

6
src/libutil-tests/chunked-vector.cc
View file

@ -5,12 +5,12 @@
namespace nix {
TEST(ChunkedVector, InitEmpty) {
auto v = ChunkedVector<int, 2>(100);
ASSERT_EQ(v.size(), 0);
ASSERT_EQ(v.size(), 0u);
}
TEST(ChunkedVector, GrowsCorrectly) {
auto v = ChunkedVector<int, 2>(100);
for (auto i = 1; i < 20; i++) {
for (uint32_t i = 1; i < 20; i++) {
v.add(i);
ASSERT_EQ(v.size(), i);
}
@ -31,7 +31,7 @@ namespace nix {
for (auto i = 1; i < 20; i++) {
v.add(i);
}
int count = 0;
uint32_t count = 0;
v.forEach([&count](int elt) {
count++;
});

59
src/libutil-tests/file-system.cc
View file

@ -203,12 +203,10 @@ TEST(isInDir, notInDir)
ASSERT_EQ(p1, false);
}
// XXX: hm, bug or feature? :) Looking at the implementation
// this might be problematic.
TEST(isInDir, emptyDir)
{
auto p1 = isInDir("/zes/foo/bar", "");
ASSERT_EQ(p1, true);
ASSERT_EQ(p1, false);
}
/* ----------------------------------------------------------------------------
@ -233,14 +231,12 @@ TEST(isDirOrInDir, falseForDisjunctPaths)
TEST(isDirOrInDir, relativePaths)
{
ASSERT_EQ(isDirOrInDir("/foo/..", "/foo"), true);
ASSERT_EQ(isDirOrInDir("/foo/..", "/foo"), false);
}
// XXX: while it is possible to use "." or ".." in the
// first argument this doesn't seem to work in the second.
TEST(isDirOrInDir, DISABLED_shouldWork)
TEST(isDirOrInDir, relativePathsTwice)
{
ASSERT_EQ(isDirOrInDir("/foo/..", "/foo/."), true);
ASSERT_EQ(isDirOrInDir("/foo/..", "/foo/."), false);
}
/* ----------------------------------------------------------------------------
@ -275,4 +271,51 @@ TEST(makeParentCanonical, root)
{
ASSERT_EQ(makeParentCanonical("/"), "/");
}
/* ----------------------------------------------------------------------------
* chmodIfNeeded
* --------------------------------------------------------------------------*/
TEST(chmodIfNeeded, works)
{
auto [autoClose_, tmpFile] = nix::createTempFile();
auto deleteTmpFile = AutoDelete(tmpFile);
auto modes = std::vector<mode_t>{0755, 0644, 0422, 0600, 0777};
for (mode_t oldMode : modes) {
for (mode_t newMode : modes) {
chmod(tmpFile.c_str(), oldMode);
bool permissionsChanged = false;
ASSERT_NO_THROW(permissionsChanged = chmodIfNeeded(tmpFile, newMode));
ASSERT_EQ(permissionsChanged, oldMode != newMode);
}
}
}
TEST(chmodIfNeeded, nonexistent)
{
ASSERT_THROW(chmodIfNeeded("/schnitzel/darmstadt/pommes", 0755), SysError);
}
/* ----------------------------------------------------------------------------
* DirectoryIterator
* --------------------------------------------------------------------------*/
TEST(DirectoryIterator, works)
{
auto tmpDir = nix::createTempDir();
nix::AutoDelete delTmpDir(tmpDir, true);
nix::writeFile(tmpDir + "/somefile", "");
for (auto path : DirectoryIterator(tmpDir)) {
ASSERT_EQ(path.path().string(), tmpDir + "/somefile");
}
}
TEST(DirectoryIterator, nonexistent)
{
ASSERT_THROW(DirectoryIterator("/schnitzel/darmstadt/pommes"), SysError);
}
}

36
src/libutil-tests/json-utils.cc
View file

@ -50,7 +50,7 @@ TEST(from_json, optionalInt) {
TEST(from_json, vectorOfOptionalInts) {
nlohmann::json json = { 420, nullptr };
std::vector<std::optional<int>> vals = json;
ASSERT_EQ(vals.size(), 2);
ASSERT_EQ(vals.size(), 2u);
ASSERT_TRUE(vals.at(0).has_value());
ASSERT_EQ(*vals.at(0), 420);
ASSERT_FALSE(vals.at(1).has_value());
@ -63,9 +63,7 @@ TEST(valueAt, simpleObject) {
auto nested = R"({ "hello": { "world": "" } })"_json;
auto & nestedObject = valueAt(getObject(nested), "hello");
ASSERT_EQ(valueAt(nestedObject, "world"), "");
ASSERT_EQ(valueAt(valueAt(getObject(nested), "hello"), "world"), "");
}
TEST(valueAt, missingKey) {
@ -83,7 +81,7 @@ TEST(getObject, rightAssertions) {
auto nested = R"({ "object": { "object": {} } })"_json;
auto & nestedObject = getObject(valueAt(getObject(nested), "object"));
auto nestedObject = getObject(valueAt(getObject(nested), "object"));
ASSERT_EQ(nestedObject, getObject(nlohmann::json::parse(R"({ "object": {} })")));
ASSERT_EQ(getObject(valueAt(getObject(nestedObject), "object")), (nlohmann::json::object_t {}));
@ -130,19 +128,29 @@ TEST(getString, wrongAssertions) {
ASSERT_THROW(getString(valueAt(json, "boolean")), Error);
}
TEST(getInteger, rightAssertions) {
auto simple = R"({ "int": 0 })"_json;
TEST(getIntegralNumber, rightAssertions) {
auto simple = R"({ "int": 0, "signed": -1 })"_json;
ASSERT_EQ(getInteger(valueAt(getObject(simple), "int")), 0);
ASSERT_EQ(getUnsigned(valueAt(getObject(simple), "int")), 0);
ASSERT_EQ(getInteger<int8_t>(valueAt(getObject(simple), "int")), 0);
ASSERT_EQ(getInteger<int8_t>(valueAt(getObject(simple), "signed")), -1);
}
TEST(getInteger, wrongAssertions) {
auto json = R"({ "object": {}, "array": [], "string": "", "int": 0, "boolean": false })"_json;
TEST(getIntegralNumber, wrongAssertions) {
auto json = R"({ "object": {}, "array": [], "string": "", "int": 0, "signed": -256, "large": 128, "boolean": false })"_json;
ASSERT_THROW(getInteger(valueAt(json, "object")), Error);
ASSERT_THROW(getInteger(valueAt(json, "array")), Error);
ASSERT_THROW(getInteger(valueAt(json, "string")), Error);
ASSERT_THROW(getInteger(valueAt(json, "boolean")), Error);
ASSERT_THROW(getUnsigned(valueAt(json, "object")), Error);
ASSERT_THROW(getUnsigned(valueAt(json, "array")), Error);
ASSERT_THROW(getUnsigned(valueAt(json, "string")), Error);
ASSERT_THROW(getUnsigned(valueAt(json, "boolean")), Error);
ASSERT_THROW(getUnsigned(valueAt(json, "signed")), Error);
ASSERT_THROW(getInteger<int8_t>(valueAt(json, "object")), Error);
ASSERT_THROW(getInteger<int8_t>(valueAt(json, "array")), Error);
ASSERT_THROW(getInteger<int8_t>(valueAt(json, "string")), Error);
ASSERT_THROW(getInteger<int8_t>(valueAt(json, "boolean")), Error);
ASSERT_THROW(getInteger<int8_t>(valueAt(json, "large")), Error);
ASSERT_THROW(getInteger<int8_t>(valueAt(json, "signed")), Error);
}
TEST(getBoolean, rightAssertions) {

24
src/libutil-tests/lru-cache.cc
View file

@ -9,13 +9,13 @@ namespace nix {
TEST(LRUCache, sizeOfEmptyCacheIsZero) {
LRUCache<std::string, std::string> c(10);
ASSERT_EQ(c.size(), 0);
ASSERT_EQ(c.size(), 0u);
}
TEST(LRUCache, sizeOfSingleElementCacheIsOne) {
LRUCache<std::string, std::string> c(10);
c.upsert("foo", "bar");
ASSERT_EQ(c.size(), 1);
ASSERT_EQ(c.size(), 1u);
}
/* ----------------------------------------------------------------------------
@ -55,12 +55,12 @@ namespace nix {
auto val = c.get("foo");
ASSERT_EQ(val.value_or("error"), "bar");
ASSERT_EQ(c.size(), 1);
ASSERT_EQ(c.size(), 1u);
c.upsert("foo", "changed");
val = c.get("foo");
ASSERT_EQ(val.value_or("error"), "changed");
ASSERT_EQ(c.size(), 1);
ASSERT_EQ(c.size(), 1u);
}
TEST(LRUCache, overwriteOldestWhenCapacityIsReached) {
@ -69,13 +69,13 @@ namespace nix {
c.upsert("two", "zwei");
c.upsert("three", "drei");
ASSERT_EQ(c.size(), 3);
ASSERT_EQ(c.size(), 3u);
ASSERT_EQ(c.get("one").value_or("error"), "eins");
// exceed capacity
c.upsert("another", "whatever");
ASSERT_EQ(c.size(), 3);
ASSERT_EQ(c.size(), 3u);
// Retrieving "one" makes it the most recent element thus
// two will be the oldest one and thus replaced.
ASSERT_EQ(c.get("two").has_value(), false);
@ -89,7 +89,7 @@ namespace nix {
TEST(LRUCache, clearEmptyCache) {
LRUCache<std::string, std::string> c(10);
c.clear();
ASSERT_EQ(c.size(), 0);
ASSERT_EQ(c.size(), 0u);
}
TEST(LRUCache, clearNonEmptyCache) {
@ -97,9 +97,9 @@ namespace nix {
c.upsert("one", "eins");
c.upsert("two", "zwei");
c.upsert("three", "drei");
ASSERT_EQ(c.size(), 3);
ASSERT_EQ(c.size(), 3u);
c.clear();
ASSERT_EQ(c.size(), 0);
ASSERT_EQ(c.size(), 0u);
}
/* ----------------------------------------------------------------------------
@ -109,14 +109,14 @@ namespace nix {
TEST(LRUCache, eraseFromEmptyCache) {
LRUCache<std::string, std::string> c(10);
ASSERT_EQ(c.erase("foo"), false);
ASSERT_EQ(c.size(), 0);
ASSERT_EQ(c.size(), 0u);
}
TEST(LRUCache, eraseMissingFromNonEmptyCache) {
LRUCache<std::string, std::string> c(10);
c.upsert("one", "eins");
ASSERT_EQ(c.erase("foo"), false);
ASSERT_EQ(c.size(), 1);
ASSERT_EQ(c.size(), 1u);
ASSERT_EQ(c.get("one").value_or("error"), "eins");
}
@ -124,7 +124,7 @@ namespace nix {
LRUCache<std::string, std::string> c(10);
c.upsert("one", "eins");
ASSERT_EQ(c.erase("one"), true);
ASSERT_EQ(c.size(), 0);
ASSERT_EQ(c.size(), 0u);
ASSERT_EQ(c.get("one").value_or("empty"), "empty");
}
}

22
src/libutil-tests/pool.cc
View file

@ -26,8 +26,8 @@ namespace nix {
Pool<TestResource> pool = Pool<TestResource>((size_t)1, createResource, isGood);
ASSERT_EQ(pool.count(), 0);
ASSERT_EQ(pool.capacity(), 1);
ASSERT_EQ(pool.count(), 0u);
ASSERT_EQ(pool.capacity(), 1u);
}
TEST(Pool, freshPoolCanGetAResource) {
@ -35,12 +35,12 @@ namespace nix {
auto createResource = []() { return make_ref<TestResource>(); };
Pool<TestResource> pool = Pool<TestResource>((size_t)1, createResource, isGood);
ASSERT_EQ(pool.count(), 0);
ASSERT_EQ(pool.count(), 0u);
TestResource r = *(pool.get());
ASSERT_EQ(pool.count(), 1);
ASSERT_EQ(pool.capacity(), 1);
ASSERT_EQ(pool.count(), 1u);
ASSERT_EQ(pool.capacity(), 1u);
ASSERT_EQ(r.dummyValue, 1);
ASSERT_EQ(r.good, true);
}
@ -50,9 +50,9 @@ namespace nix {
auto createResource = []() { return make_ref<TestResource>(); };
Pool<TestResource> pool = Pool<TestResource>((size_t)1, createResource, isGood);
ASSERT_EQ(pool.capacity(), 1);
ASSERT_EQ(pool.capacity(), 1u);
pool.incCapacity();
ASSERT_EQ(pool.capacity(), 2);
ASSERT_EQ(pool.capacity(), 2u);
}
TEST(Pool, capacityCanBeDecremented) {
@ -60,9 +60,9 @@ namespace nix {
auto createResource = []() { return make_ref<TestResource>(); };
Pool<TestResource> pool = Pool<TestResource>((size_t)1, createResource, isGood);
ASSERT_EQ(pool.capacity(), 1);
ASSERT_EQ(pool.capacity(), 1u);
pool.decCapacity();
ASSERT_EQ(pool.capacity(), 0);
ASSERT_EQ(pool.capacity(), 0u);
}
TEST(Pool, flushBadDropsOutOfScopeResources) {
@ -73,11 +73,11 @@ namespace nix {
{
auto _r = pool.get();
ASSERT_EQ(pool.count(), 1);
ASSERT_EQ(pool.count(), 1u);
}
pool.flushBad();
ASSERT_EQ(pool.count(), 0);
ASSERT_EQ(pool.count(), 0u);
}
// Test that the resources we allocate are being reused when they are still good.

4
src/libutil-tests/suggestions.cc
View file

@ -34,10 +34,10 @@ namespace nix {
TEST(Suggestions, Trim) {
auto suggestions = Suggestions::bestMatches({"foooo", "bar", "fo", "gao"}, "foo");
auto onlyOne = suggestions.trim(1);
ASSERT_EQ(onlyOne.suggestions.size(), 1);
ASSERT_EQ(onlyOne.suggestions.size(), 1u);
ASSERT_TRUE(onlyOne.suggestions.begin()->suggestion == "fo");
auto closest = suggestions.trim(999, 2);
ASSERT_EQ(closest.suggestions.size(), 3);
ASSERT_EQ(closest.suggestions.size(), 3u);
}
}

8
src/libutil-tests/terminal.cc
View file

@ -66,4 +66,12 @@ TEST(filterANSIEscapes, osc8)
ASSERT_EQ(filterANSIEscapes("\e]8;;http://example.com\e\\This is a link\e]8;;\e\\"), "This is a link");
}
TEST(filterANSIEscapes, osc8_bell_as_sep)
{
// gcc-14 uses \a as a separator, xterm style:
// https://gist.github.com/egmontkob/eb114294efbcd5adb1944c9f3cb5feda
ASSERT_EQ(filterANSIEscapes("\e]8;;http://example.com\aThis is a link\e]8;;\a"), "This is a link");
ASSERT_EQ(filterANSIEscapes("\e]8;;http://example.com\a\\This is a link\e]8;;\a"), "\\This is a link");
}
} // namespace nix

2
src/libutil-tests/util.cc
View file

@ -79,7 +79,7 @@ TEST(base64Encode, encodeAndDecodeNonPrintable)
auto encoded = base64Encode(s);
auto decoded = base64Decode(encoded);
EXPECT_EQ(decoded.length(), 255);
EXPECT_EQ(decoded.length(), 255u);
ASSERT_EQ(decoded, s);
}