Something went wrong. Try again.
What happens if I push all of nixpkgs
Something went wrong. Try again.
Nix
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465/** Nix evaluation tests for various lib functions.
Since these tests are implemented with Nix evaluation, error checking is limited to what `builtins.tryEval` can detect, which is `throw`'s and `abort`'s, without error messages.
If you need to test error messages or more complex evaluations, see `lib/tests/modules.sh`, `lib/tests/sources.sh` or `lib/tests/filesystem.sh` as examples.
To run these tests:
[nixpkgs]$ nix-instantiate --eval --strict lib/tests/misc.nix
If the resulting list is empty, all tests passed. Alternatively, to run all `lib` tests:
[nixpkgs]$ nix-build lib/tests/release.nix*/
let lib = import ../default.nix;
inherit (lib) allUnique and attrNames attrsets attrsToList bitAnd bitOr bitXor boolToString callPackagesWith callPackageWith cartesianProduct cli composeExtensions composeManyExtensions concatLines concatMapAttrs concatMapStrings concatStrings concatStringsSep const escapeXML evalModules filter fix fold foldAttrs foldl foldl' foldlAttrs foldr functionArgs generators genList getExe getExe' getLicenseFromSpdxIdOr groupBy groupBy' hasAttrByPath hasInfix id ifilter0 isStorePath lazyDerivation length lists listToAttrs makeExtensible makeIncludePath makeOverridable mapAttrs mapCartesianProduct matchAttrs mergeAttrs meta mod nameValuePair optionalDrvAttr optionAttrSetToDocList overrideExisting packagesFromDirectoryRecursive pipe range recursiveUpdateUntil removePrefix replicate runTests setFunctionArgs showAttrPath sort sortOn stringLength strings stringToCharacters systems tail take testAllTrue toBaseDigits toHexString fromHexString toInt toIntBase10 toShellVars types updateManyAttrsByPath versions xor ;
testingThrow = expr: { expr = (builtins.tryEval (builtins.seq expr "didn't throw")); expected = { success = false; value = false; }; }; testingEval = expr: { expr = (builtins.tryEval expr).success; expected = true; };
testSanitizeDerivationName = { name, expected }: let drv = derivation { name = strings.sanitizeDerivationName name; builder = "x"; system = "x"; }; in { # Evaluate the derivation so an invalid name would be caught expr = builtins.seq drv.drvPath drv.name; inherit expected; };
in
runTests {
# CUSTOMIZATION
testFunctionArgsMakeOverridable = { expr = functionArgs (makeOverridable ({ a, b, c ? null}: {})); expected = { a = false; b = false; c = true; }; };
testFunctionArgsMakeOverridableOverride = { expr = functionArgs (makeOverridable ({ a, b, c ? null }: {}) { a = 1; b = 2; }).override; expected = { a = false; b = false; c = true; }; };
testCallPackageWithOverridePreservesArguments = let f = { a ? 0, b }: {}; f' = callPackageWith { a = 1; b = 2; } f {}; in { expr = functionArgs f'.override; expected = functionArgs f; };
testCallPackagesWithOverridePreservesArguments = let f = { a ? 0, b }: { nested = {}; }; f' = callPackagesWith { a = 1; b = 2; } f {}; in { expr = functionArgs f'.nested.override; expected = functionArgs f; };
# TRIVIAL
testId = { expr = id 1; expected = 1; };
testConst = { expr = const 2 3; expected = 2; };
testPipe = { expr = pipe 2 [ (x: x + 2) # 2 + 2 = 4 (x: x * 2) # 4 * 2 = 8 ]; expected = 8; };
testPipeEmpty = { expr = pipe 2 []; expected = 2; };
testPipeStrings = { expr = pipe [ 3 4 ] [ (map toString) (map (s: s + "\n")) concatStrings ]; expected = '' 3 4 ''; };
/* testOr = { expr = or true false; expected = true; }; */
testAnd = { expr = and true false; expected = false; };
testXor = { expr = [ (xor true false) (xor true true) (xor false false) (xor false true) ]; expected = [ true false false true ]; };
testFix = { expr = fix (x: {a = if x ? a then "a" else "b";}); expected = {a = "a";}; };
testComposeExtensions = { expr = let obj = makeExtensible (self: { foo = self.bar; }); f = self: super: { bar = false; baz = true; }; g = self: super: { bar = super.baz or false; }; f_o_g = composeExtensions f g; composed = obj.extend f_o_g; in composed.foo; expected = true; };
testComposeManyExtensions0 = { expr = let obj = makeExtensible (self: { foo = true; }); emptyComposition = composeManyExtensions []; composed = obj.extend emptyComposition; in composed.foo; expected = true; };
testComposeManyExtensions = let f = self: super: { bar = false; baz = true; }; g = self: super: { bar = super.baz or false; }; h = self: super: { qux = super.bar or false; }; obj = makeExtensible (self: { foo = self.qux; }); in { expr = let composition = composeManyExtensions [f g h]; composed = obj.extend composition; in composed.foo; expected = (obj.extend (composeExtensions f (composeExtensions g h))).foo; };
testBitAnd = { expr = (bitAnd 3 10); expected = 2; };
testBitOr = { expr = (bitOr 3 10); expected = 11; };
testBitXor = { expr = (bitXor 3 10); expected = 9; };
testToHexString = { expr = toHexString 250; expected = "FA"; };
testFromHexStringFirstExample = { expr = fromHexString "FF"; expected = 255; };
testFromHexStringSecondExample = { expr = fromHexString (builtins.hashString "sha256" "test"); expected = 9223372036854775807; };
testFromHexStringWithPrefix = { expr = fromHexString "0Xf"; expected = 15; };
testToBaseDigits = { expr = toBaseDigits 2 6; expected = [ 1 1 0 ]; };
testFunctionArgsFunctor = { expr = functionArgs { __functor = self: { a, b }: null; }; expected = { a = false; b = false; }; };
testFunctionArgsSetFunctionArgs = { expr = functionArgs (setFunctionArgs (args: args.x) { x = false; }); expected = { x = false; }; };
# STRINGS
testConcatMapStrings = { expr = concatMapStrings (x: x + ";") ["a" "b" "c"]; expected = "a;b;c;"; };
testConcatStringsSep = { expr = concatStringsSep "," ["a" "b" "c"]; expected = "a,b,c"; };
testConcatLines = { expr = concatLines ["a" "b" "c"]; expected = "a\nb\nc\n"; };
testMakeIncludePathWithPkgs = { expr = (makeIncludePath [ # makeIncludePath preferably selects the "dev" output { dev.outPath = "/dev"; out.outPath = "/out"; outPath = "/default"; } # "out" is used if "dev" is not found { out.outPath = "/out"; outPath = "/default"; } # And it returns the derivation directly if there's no "out" either { outPath = "/default"; } # Same if the output is specified explicitly, even if there's a "dev" { dev.outPath = "/dev"; outPath = "/default"; outputSpecified = true; } ]); expected = "/dev/include:/out/include:/default/include:/default/include"; };
testMakeIncludePathWithEmptyList = { expr = (makeIncludePath [ ]); expected = ""; };
testMakeIncludePathWithOneString = { expr = (makeIncludePath [ "/usr" ]); expected = "/usr/include"; };
testMakeIncludePathWithManyString = { expr = (makeIncludePath [ "/usr" "/usr/local" ]); expected = "/usr/include:/usr/local/include"; };
testReplicateString = { expr = strings.replicate 5 "hello"; expected = "hellohellohellohellohello"; };
# Test various strings are trimmed correctly testTrimString = { expr = let testValues = f: mapAttrs (_: f) { empty = ""; cr = "\r"; lf = "\n"; tab = "\t"; spaces = " "; leading = " Hello, world"; trailing = "Hello, world "; mixed = " Hello, world "; mixed-tabs = " \t\tHello, world \t \t "; multiline = " Hello,\n world! "; multiline-crlf = " Hello,\r\n world! "; }; in { leading = testValues (strings.trimWith { start = true; }); trailing = testValues (strings.trimWith { end = true; }); both = testValues strings.trim; }; expected = { leading = { empty = ""; cr = ""; lf = ""; tab = ""; spaces = ""; leading = "Hello, world"; trailing = "Hello, world "; mixed = "Hello, world "; mixed-tabs = "Hello, world \t \t "; multiline = "Hello,\n world! "; multiline-crlf = "Hello,\r\n world! "; }; trailing = { empty = ""; cr = ""; lf = ""; tab = ""; spaces = ""; leading = " Hello, world"; trailing = "Hello, world"; mixed = " Hello, world"; mixed-tabs = " \t\tHello, world"; multiline = " Hello,\n world!"; multiline-crlf = " Hello,\r\n world!"; }; both = { empty = ""; cr = ""; lf = ""; tab = ""; spaces = ""; leading = "Hello, world"; trailing = "Hello, world"; mixed = "Hello, world"; mixed-tabs = "Hello, world"; multiline = "Hello,\n world!"; multiline-crlf = "Hello,\r\n world!"; }; }; };
testSplitStringsSimple = { expr = strings.splitString "." "a.b.c.d"; expected = [ "a" "b" "c" "d" ]; };
testSplitStringsEmpty = { expr = strings.splitString "." "a..b"; expected = [ "a" "" "b" ]; };
testSplitStringsOne = { expr = strings.splitString ":" "a.b"; expected = [ "a.b" ]; };
testSplitStringsNone = { expr = strings.splitString "." ""; expected = [ "" ]; };
testSplitStringsFirstEmpty = { expr = strings.splitString "/" "/a/b/c"; expected = [ "" "a" "b" "c" ]; };
testSplitStringsLastEmpty = { expr = strings.splitString ":" "2001:db8:0:0042::8a2e:370:"; expected = [ "2001" "db8" "0" "0042" "" "8a2e" "370" "" ]; };
testSplitStringsRegex = { expr = strings.splitString "\\[{}]()^$?*+|." "A\\[{}]()^$?*+|.B"; expected = [ "A" "B" ]; };
testSplitStringsDerivation = { expr = take 3 (strings.splitString "/" (derivation { name = "name"; builder = "builder"; system = "system"; })); expected = ["" "nix" "store"]; };
testSplitVersionSingle = { expr = versions.splitVersion "1"; expected = [ "1" ]; };
testSplitVersionDouble = { expr = versions.splitVersion "1.2"; expected = [ "1" "2" ]; };
testSplitVersionTriple = { expr = versions.splitVersion "1.2.3"; expected = [ "1" "2" "3" ]; };
testPadVersionLess = { expr = versions.pad 3 "1.2"; expected = "1.2.0"; };
testPadVersionLessExtra = { expr = versions.pad 3 "1.3-rc1"; expected = "1.3.0-rc1"; };
testPadVersionMore = { expr = versions.pad 3 "1.2.3.4"; expected = "1.2.3"; };
testIsStorePath = { expr = let goodPath = "${builtins.storeDir}/d945ibfx9x185xf04b890y4f9g3cbb63-python-2.7.11"; in { storePath = isStorePath goodPath; storePathDerivation = isStorePath (import ../.. { system = "x86_64-linux"; }).hello; storePathAppendix = isStorePath "${goodPath}/bin/python"; nonAbsolute = isStorePath (concatStrings (tail (stringToCharacters goodPath))); asPath = isStorePath (/. + goodPath); otherPath = isStorePath "/something/else"; otherVals = { attrset = isStorePath {}; list = isStorePath []; int = isStorePath 42; }; }; expected = { storePath = true; storePathDerivation = true; storePathAppendix = false; nonAbsolute = false; asPath = true; otherPath = false; otherVals = { attrset = false; list = false; int = false; }; }; };
testEscapeXML = { expr = escapeXML ''"test" 'test' < & >''; expected = ""test" 'test' < & >"; };
testToShellVars = { expr = '' ${toShellVars { STRing01 = "just a 'string'"; _array_ = [ "with" "more strings" ]; assoc."with some" = '' strings possibly newlines ''; drv = { outPath = "/drv"; foo = "ignored attribute"; }; path = /path; stringable = { __toString = _: "hello toString"; bar = "ignored attribute"; }; }} ''; expected = '' STRing01='just a '\'''string'\'''' declare -a _array_=('with' 'more strings') declare -A assoc=(['with some']='strings possibly newlines ') drv='/drv' path='/path' stringable='hello toString' ''; };
testHasInfixFalse = { expr = hasInfix "c" "abde"; expected = false; };
testHasInfixTrue = { expr = hasInfix "c" "abcde"; expected = true; };
testHasInfixDerivation = { expr = hasInfix "hello" (import ../.. { system = "x86_64-linux"; }).hello; expected = true; };
testHasInfixPath = { expr = hasInfix "tests" ./.; expected = true; };
testHasInfixPathStoreDir = { expr = hasInfix builtins.storeDir ./.; expected = true; };
testHasInfixToString = { expr = hasInfix "a" { __toString = _: "a"; }; expected = true; };
testRemovePrefixExample1 = { expr = removePrefix "foo." "foo.bar.baz"; expected = "bar.baz"; }; testRemovePrefixExample2 = { expr = removePrefix "xxx" "foo.bar.baz"; expected = "foo.bar.baz"; }; testRemovePrefixEmptyPrefix = { expr = removePrefix "" "foo"; expected = "foo"; }; testRemovePrefixEmptyString = { expr = removePrefix "foo" ""; expected = ""; }; testRemovePrefixEmptyBoth = { expr = removePrefix "" ""; expected = ""; };
testNormalizePath = { expr = strings.normalizePath "//a/b//c////d/"; expected = "/a/b/c/d/"; };
testCharToInt = { expr = strings.charToInt "A"; expected = 65; };
testEscapeC = { expr = strings.escapeC [ " " ] "Hello World"; expected = "Hello\\x20World"; };
testEscapeURL = testAllTrue [ ("" == strings.escapeURL "") ("Hello" == strings.escapeURL "Hello") ("Hello%20World" == strings.escapeURL "Hello World") ("Hello%2FWorld" == strings.escapeURL "Hello/World") ("42%25" == strings.escapeURL "42%") ("%20%3F%26%3D%23%2B%25%21%3C%3E%23%22%7B%7D%7C%5C%5E%5B%5D%60%09%3A%2F%40%24%27%28%29%2A%2C%3B" == strings.escapeURL " ?&=#+%!<>#\"{}|\\^[]`\t:/@$'()*,;") ];
testToInt = testAllTrue [ # Naive (123 == toInt "123") (0 == toInt "0") # Whitespace Padding (123 == toInt " 123") (123 == toInt "123 ") (123 == toInt " 123 ") (123 == toInt " 123 ") (0 == toInt " 0") (0 == toInt "0 ") (0 == toInt " 0 ") (-1 == toInt "-1") (-1 == toInt " -1 ") ];
testToIntFails = testAllTrue [ ( builtins.tryEval (toInt "") == { success = false; value = false; } ) ( builtins.tryEval (toInt "123 123") == { success = false; value = false; } ) ( builtins.tryEval (toInt "0 123") == { success = false; value = false; } ) ( builtins.tryEval (toInt " 0d ") == { success = false; value = false; } ) ( builtins.tryEval (toInt " 1d ") == { success = false; value = false; } ) ( builtins.tryEval (toInt " d0 ") == { success = false; value = false; } ) ( builtins.tryEval (toInt "00") == { success = false; value = false; } ) ( builtins.tryEval (toInt "01") == { success = false; value = false; } ) ( builtins.tryEval (toInt "002") == { success = false; value = false; } ) ( builtins.tryEval (toInt " 002 ") == { success = false; value = false; } ) ( builtins.tryEval (toInt " foo ") == { success = false; value = false; } ) ( builtins.tryEval (toInt " foo 123 ") == { success = false; value = false; } ) ( builtins.tryEval (toInt " foo123 ") == { success = false; value = false; } ) ];
testToIntBase10 = testAllTrue [ # Naive (123 == toIntBase10 "123") (0 == toIntBase10 "0") # Whitespace Padding (123 == toIntBase10 " 123") (123 == toIntBase10 "123 ") (123 == toIntBase10 " 123 ") (123 == toIntBase10 " 123 ") (0 == toIntBase10 " 0") (0 == toIntBase10 "0 ") (0 == toIntBase10 " 0 ") # Zero Padding (123 == toIntBase10 "0123") (123 == toIntBase10 "0000123") (0 == toIntBase10 "000000") # Whitespace and Zero Padding (123 == toIntBase10 " 0123") (123 == toIntBase10 "0123 ") (123 == toIntBase10 " 0123 ") (123 == toIntBase10 " 0000123") (123 == toIntBase10 "0000123 ") (123 == toIntBase10 " 0000123 ") (0 == toIntBase10 " 000000") (0 == toIntBase10 "000000 ") (0 == toIntBase10 " 000000 ") (-1 == toIntBase10 "-1") (-1 == toIntBase10 " -1 ") ];
testToIntBase10Fails = testAllTrue [ ( builtins.tryEval (toIntBase10 "") == { success = false; value = false; } ) ( builtins.tryEval (toIntBase10 "123 123") == { success = false; value = false; } ) ( builtins.tryEval (toIntBase10 "0 123") == { success = false; value = false; } ) ( builtins.tryEval (toIntBase10 " 0d ") == { success = false; value = false; } ) ( builtins.tryEval (toIntBase10 " 1d ") == { success = false; value = false; } ) ( builtins.tryEval (toIntBase10 " d0 ") == { success = false; value = false; } ) ( builtins.tryEval (toIntBase10 " foo ") == { success = false; value = false; } ) ( builtins.tryEval (toIntBase10 " foo 123 ") == { success = false; value = false; } ) ( builtins.tryEval (toIntBase10 " foo 00123 ") == { success = false; value = false; } ) ( builtins.tryEval (toIntBase10 " foo00123 ") == { success = false; value = false; } ) ];
# LISTS
testFilter = { expr = filter (x: x != "a") ["a" "b" "c" "a"]; expected = ["b" "c"]; };
testIfilter0Example = { expr = ifilter0 (i: v: i == 0 || v > 2) [ 1 2 3 ]; expected = [ 1 3 ]; }; testIfilter0Empty = { expr = ifilter0 (i: v: abort "shouldn't be evaluated!") [ ]; expected = [ ]; }; testIfilter0IndexOnly = { expr = length (ifilter0 (i: v: mod i 2 == 0) [ (throw "0") (throw "1") (throw "2") (throw "3")]); expected = 2; }; testIfilter0All = { expr = ifilter0 (i: v: true) [ 10 11 12 13 14 15 ]; expected = [ 10 11 12 13 14 15 ]; }; testIfilter0First = { expr = ifilter0 (i: v: i == 0) [ 10 11 12 13 14 15 ]; expected = [ 10 ]; }; testIfilter0Last = { expr = ifilter0 (i: v: i == 5) [ 10 11 12 13 14 15 ]; expected = [ 15 ]; };
testFold = let f = op: fold: fold op 0 (range 0 100); # fold with associative operator assoc = f builtins.add; # fold with non-associative operator nonAssoc = f builtins.sub; in { expr = { assocRight = assoc foldr; # right fold with assoc operator is same as left fold assocRightIsLeft = assoc foldr == assoc foldl; nonAssocRight = nonAssoc foldr; nonAssocLeft = nonAssoc foldl; # with non-assoc operator the fold results are not the same nonAssocRightIsNotLeft = nonAssoc foldl != nonAssoc foldr; # fold is an alias for foldr foldIsRight = nonAssoc fold == nonAssoc foldr; }; expected = { assocRight = 5050; assocRightIsLeft = true; nonAssocRight = 50; nonAssocLeft = (-5050); nonAssocRightIsNotLeft = true; foldIsRight = true; }; };
testFoldl'Empty = { expr = foldl' (acc: el: abort "operation not called") 0 [ ]; expected = 0; };
testFoldl'IntegerAdding = { expr = foldl' (acc: el: acc + el) 0 [ 1 2 3 ]; expected = 6; };
# The accumulator isn't forced deeply testFoldl'NonDeep = { expr = take 3 (foldl' (acc: el: [ el ] ++ acc) [ (abort "unevaluated list entry") ] [ 1 2 3 ]); expected = [ 3 2 1 ]; };
# Compared to builtins.foldl', lib.foldl' evaluates the first accumulator strictly too testFoldl'StrictInitial = { expr = (builtins.tryEval (foldl' (acc: el: el) (throw "hello") [])).success; expected = false; };
# Make sure we don't get a stack overflow for large lists # This number of elements would notably cause a stack overflow if it was implemented without the `foldl'` builtin testFoldl'Large = { expr = foldl' (acc: el: acc + el) 0 (range 0 100000); expected = 5000050000; };
testTake = testAllTrue [ ([] == (take 0 [ 1 2 3 ])) ([1] == (take 1 [ 1 2 3 ])) ([ 1 2 ] == (take 2 [ 1 2 3 ])) ([ 1 2 3 ] == (take 3 [ 1 2 3 ])) ([ 1 2 3 ] == (take 4 [ 1 2 3 ])) ];
testListHasPrefixExample1 = { expr = lists.hasPrefix [ 1 2 ] [ 1 2 3 4 ]; expected = true; }; testListHasPrefixExample2 = { expr = lists.hasPrefix [ 0 1 ] [ 1 2 3 4 ]; expected = false; }; testListHasPrefixLazy = { expr = lists.hasPrefix [ 1 ] [ 1 (abort "lib.lists.hasPrefix is not lazy") ]; expected = true; }; testListHasPrefixEmptyPrefix = { expr = lists.hasPrefix [ ] [ 1 2 ]; expected = true; }; testListHasPrefixEmptyList = { expr = lists.hasPrefix [ 1 2 ] [ ]; expected = false; };
testListRemovePrefixExample1 = { expr = lists.removePrefix [ 1 2 ] [ 1 2 3 4 ]; expected = [ 3 4 ]; }; testListRemovePrefixExample2 = { expr = (builtins.tryEval (lists.removePrefix [ 0 1 ] [ 1 2 3 4 ])).success; expected = false; }; testListRemovePrefixEmptyPrefix = { expr = lists.removePrefix [ ] [ 1 2 ]; expected = [ 1 2 ]; }; testListRemovePrefixEmptyList = { expr = (builtins.tryEval (lists.removePrefix [ 1 2 ] [ ])).success; expected = false; };
testFoldAttrs = { expr = foldAttrs (n: a: [n] ++ a) [] [ { a = 2; b = 7; } { a = 3; c = 8; } ]; expected = { a = [ 2 3 ]; b = [7]; c = [8];}; };
testListCommonPrefixExample1 = { expr = lists.commonPrefix [ 1 2 3 4 5 6 ] [ 1 2 4 8 ]; expected = [ 1 2 ]; }; testListCommonPrefixExample2 = { expr = lists.commonPrefix [ 1 2 3 ] [ 1 2 3 4 5 ]; expected = [ 1 2 3 ]; }; testListCommonPrefixExample3 = { expr = lists.commonPrefix [ 1 2 3 ] [ 4 5 6 ]; expected = [ ]; }; testListCommonPrefixEmpty = { expr = lists.commonPrefix [ ] [ 1 2 3 ]; expected = [ ]; }; testListCommonPrefixSame = { expr = lists.commonPrefix [ 1 2 3 ] [ 1 2 3 ]; expected = [ 1 2 3 ]; }; testListCommonPrefixLazy = { expr = lists.commonPrefix [ 1 ] [ 1 (abort "lib.lists.commonPrefix shouldn't evaluate this")]; expected = [ 1 ]; }; # This would stack overflow if `commonPrefix` were implemented using recursion testListCommonPrefixLong = let longList = genList (n: n) 100000; in { expr = lists.commonPrefix longList longList; expected = longList; };
testSort = { expr = sort builtins.lessThan [ 40 2 30 42 ]; expected = [2 30 40 42]; };
testSortOn = { expr = sortOn stringLength [ "aa" "b" "cccc" ]; expected = [ "b" "aa" "cccc" ]; };
testSortOnEmpty = { expr = sortOn (throw "nope") [ ]; expected = [ ]; };
testSortOnIncomparable = { expr = map (x: x.f x.ok) (sortOn (x: x.ok) [ { ok = 1; f = x: x; } { ok = 3; f = x: x + 3; } { ok = 2; f = x: x; } ]); expected = [ 1 2 6 ]; };
testReplicate = { expr = replicate 3 "a"; expected = ["a" "a" "a"]; };
testToIntShouldConvertStringToInt = { expr = toInt "27"; expected = 27; };
testToIntShouldThrowErrorIfItCouldNotConvertToInt = { expr = builtins.tryEval (toInt "\"foo\""); expected = { success = false; value = false; }; };
testHasAttrByPathTrue = { expr = hasAttrByPath ["a" "b"] { a = { b = "yey"; }; }; expected = true; };
testHasAttrByPathFalse = { expr = hasAttrByPath ["a" "b"] { a = { c = "yey"; }; }; expected = false; };
testHasAttrByPathNonStrict = { expr = hasAttrByPath [] (throw "do not use"); expected = true; };
testLongestValidPathPrefix_empty_empty = { expr = attrsets.longestValidPathPrefix [ ] { }; expected = [ ]; };
testLongestValidPathPrefix_empty_nonStrict = { expr = attrsets.longestValidPathPrefix [ ] (throw "do not use"); expected = [ ]; };
testLongestValidPathPrefix_zero = { expr = attrsets.longestValidPathPrefix [ "a" (throw "do not use") ] { d = null; }; expected = [ ]; };
testLongestValidPathPrefix_zero_b = { expr = attrsets.longestValidPathPrefix [ "z" "z" ] "remarkably harmonious"; expected = [ ]; };
testLongestValidPathPrefix_one = { expr = attrsets.longestValidPathPrefix [ "a" "b" "c" ] { a = null; }; expected = [ "a" ]; };
testLongestValidPathPrefix_two = { expr = attrsets.longestValidPathPrefix [ "a" "b" "c" ] { a.b = null; }; expected = [ "a" "b" ]; };
testLongestValidPathPrefix_three = { expr = attrsets.longestValidPathPrefix [ "a" "b" "c" ] { a.b.c = null; }; expected = [ "a" "b" "c" ]; };
testLongestValidPathPrefix_three_extra = { expr = attrsets.longestValidPathPrefix [ "a" "b" "c" ] { a.b.c.d = throw "nope"; }; expected = [ "a" "b" "c" ]; };
testFindFirstIndexExample1 = { expr = lists.findFirstIndex (x: x > 3) (abort "index found, so a default must not be evaluated") [ 1 6 4 ]; expected = 1; };
testFindFirstIndexExample2 = { expr = lists.findFirstIndex (x: x > 9) "a very specific default" [ 1 6 4 ]; expected = "a very specific default"; };
testFindFirstIndexEmpty = { expr = lists.findFirstIndex (abort "when the list is empty, the predicate is not needed") null []; expected = null; };
testFindFirstIndexSingleMatch = { expr = lists.findFirstIndex (x: x == 5) null [ 5 ]; expected = 0; };
testFindFirstIndexSingleDefault = { expr = lists.findFirstIndex (x: false) null [ (abort "if the predicate doesn't access the value, it must not be evaluated") ]; expected = null; };
testFindFirstIndexNone = { expr = builtins.tryEval (lists.findFirstIndex (x: x == 2) null [ 1 (throw "the last element must be evaluated when there's no match") ]); expected = { success = false; value = false; }; };
# Makes sure that the implementation doesn't cause a stack overflow testFindFirstIndexBig = { expr = lists.findFirstIndex (x: x == 1000000) null (range 0 1000000); expected = 1000000; };
testFindFirstIndexLazy = { expr = lists.findFirstIndex (x: x == 1) null [ 1 (abort "list elements after the match must not be evaluated") ]; expected = 0; };
testFindFirstExample1 = { expr = lists.findFirst (x: x > 3) 7 [ 1 6 4 ]; expected = 6; };
testFindFirstExample2 = { expr = lists.findFirst (x: x > 9) 7 [ 1 6 4 ]; expected = 7; };
testAllUnique_true = { expr = allUnique [ 3 2 4 1 ]; expected = true; }; testAllUnique_false = { expr = allUnique [ 3 2 3 4 ]; expected = false; };
# ATTRSETS
testConcatMapAttrs = { expr = concatMapAttrs (name: value: { ${name} = value; ${name + value} = value; }) { foo = "bar"; foobar = "baz"; }; expected = { foo = "bar"; foobar = "baz"; foobarbaz = "baz"; }; };
# code from example testFoldlAttrs = { expr = { example = foldlAttrs (acc: name: value: { sum = acc.sum + value; names = acc.names ++ [ name ]; }) { sum = 0; names = [ ]; } { foo = 1; bar = 10; }; # should just return the initial value emptySet = foldlAttrs (throw "function not needed") 123 { }; # should just evaluate to the last value valuesNotNeeded = foldlAttrs (acc: _name: _v: acc) 3 { z = throw "value z not needed"; a = throw "value a not needed"; }; # the accumulator doesnt have to be an attrset it can be as trivial as being just a number or string trivialAcc = foldlAttrs (acc: _name: v: acc * 10 + v) 1 { z = 1; a = 2; }; }; expected = { example = { sum = 11; names = [ "bar" "foo" ]; }; emptySet = 123; valuesNotNeeded = 3; trivialAcc = 121; }; };
testMergeAttrsListExample1 = { expr = attrsets.mergeAttrsList [ { a = 0; b = 1; } { c = 2; d = 3; } ]; expected = { a = 0; b = 1; c = 2; d = 3; }; }; testMergeAttrsListExample2 = { expr = attrsets.mergeAttrsList [ { a = 0; } { a = 1; } ]; expected = { a = 1; }; }; testMergeAttrsListExampleMany = let list = genList (n: listToAttrs (genList (m: let # Integer divide n by two to create duplicate attributes str = "halfn${toString (n / 2)}m${toString m}"; in nameValuePair str str ) 100) ) 100; in { expr = attrsets.mergeAttrsList list; expected = foldl' mergeAttrs { } list; };
# code from the example testRecursiveUpdateUntil = { expr = recursiveUpdateUntil (path: l: r: path == ["foo"]) { # first attribute set foo.bar = 1; foo.baz = 2; bar = 3; } { #second attribute set foo.bar = 1; foo.quz = 2; baz = 4; }; expected = { foo.bar = 1; # 'foo.*' from the second set foo.quz = 2; # bar = 3; # 'bar' from the first set baz = 4; # 'baz' from the second set }; };
testMatchAttrsMatchingExact = { expr = matchAttrs { cpu = { bits = 64; }; } { cpu = { bits = 64; }; }; expected = true; };
testMatchAttrsMismatch = { expr = matchAttrs { cpu = { bits = 128; }; } { cpu = { bits = 64; }; }; expected = false; };
testMatchAttrsMatchingImplicit = { expr = matchAttrs { cpu = { }; } { cpu = { bits = 64; }; }; expected = true; };
testMatchAttrsMissingAttrs = { expr = matchAttrs { cpu = {}; } { }; expected = false; };
testOverrideExistingEmpty = { expr = overrideExisting {} { a = 1; }; expected = {}; };
testOverrideExistingDisjoint = { expr = overrideExisting { b = 2; } { a = 1; }; expected = { b = 2; }; };
testOverrideExistingOverride = { expr = overrideExisting { a = 3; b = 2; } { a = 1; }; expected = { a = 1; b = 2; }; };
testListAttrsReverse = let exampleAttrs = {foo=1; bar="asdf"; baz = [1 3 3 7]; fnord=null;}; exampleSingletonList = [{name="foo"; value=1;}]; in { expr = { isReverseToListToAttrs = builtins.listToAttrs (attrsToList exampleAttrs) == exampleAttrs; isReverseToAttrsToList = attrsToList (builtins.listToAttrs exampleSingletonList) == exampleSingletonList; testDuplicatePruningBehaviour = attrsToList (builtins.listToAttrs [{name="a"; value=2;} {name="a"; value=1;}]); }; expected = { isReverseToAttrsToList = true; isReverseToListToAttrs = true; testDuplicatePruningBehaviour = [{name="a"; value=2;}]; }; };
testAttrsToListsCanDealWithFunctions = testingEval ( attrsToList { someFunc= a: a + 1;} );
# GENERATORS# these tests assume attributes are converted to lists# in alphabetical order
testMkKeyValueDefault = { expr = generators.mkKeyValueDefault {} ":" "f:oo" "bar"; expected = ''f\:oo:bar''; };
testMkValueString = { expr = let vals = { int = 42; string = ''fo"o''; bool = true; bool2 = false; null = null; # float = 42.23; # floats are strange }; in mapAttrs (const (generators.mkValueStringDefault {})) vals; expected = { int = "42"; string = ''fo"o''; bool = "true"; bool2 = "false"; null = "null"; # float = "42.23" true false [ "bar" ] ]''; }; };
testToKeyValue = { expr = generators.toKeyValue {} { key = "value"; "other=key" = "baz"; }; expected = '' key=value other\=key=baz ''; };
testToINIEmpty = { expr = generators.toINI {} {}; expected = ""; };
testToINIEmptySection = { expr = generators.toINI {} { foo = {}; bar = {}; }; expected = '' [bar]
[foo] ''; };
testToINIDuplicateKeys = { expr = generators.toINI { listsAsDuplicateKeys = true; } { foo.bar = true; baz.qux = [ 1 false ]; }; expected = '' [baz] qux=1 qux=false
[foo] bar=true ''; };
testToINIDefaultEscapes = { expr = generators.toINI {} { "no [ and ] allowed unescaped" = { "and also no = in keys" = 42; }; }; expected = '' [no \[ and \] allowed unescaped] and also no \= in keys=42 ''; };
testToINIDefaultFull = { expr = generators.toINI {} { "section 1" = { attribute1 = 5; x = "Me-se JarJar Binx"; # booleans are converted verbatim by default boolean = false; }; "foo[]" = { "he\\h=he" = "this is okay"; }; }; expected = '' [foo\[\]] he\h\=he=this is okay
[section 1] attribute1=5 boolean=false x=Me-se JarJar Binx ''; };
testToINIWithGlobalSectionEmpty = { expr = generators.toINIWithGlobalSection {} { globalSection = { }; sections = { }; }; expected = '' ''; };
testToINIWithGlobalSectionGlobalEmptyIsTheSameAsToINI = let sections = { "section 1" = { attribute1 = 5; x = "Me-se JarJar Binx"; }; "foo" = { "he\\h=he" = "this is okay"; }; }; in { expr = generators.toINIWithGlobalSection {} { globalSection = {}; sections = sections; }; expected = generators.toINI {} sections; };
testToINIWithGlobalSectionFull = { expr = generators.toINIWithGlobalSection {} { globalSection = { foo = "bar"; test = false; }; sections = { "section 1" = { attribute1 = 5; x = "Me-se JarJar Binx"; }; "foo" = { "he\\h=he" = "this is okay"; }; }; }; expected = '' foo=bar test=false
[foo] he\h\=he=this is okay
[section 1] attribute1=5 x=Me-se JarJar Binx ''; };
testToGitINI = { expr = generators.toGitINI { user = { email = "user@example.org"; name = "John Doe"; signingKey = "00112233445566778899AABBCCDDEEFF"; }; gpg.program = "path-to-gpg"; tag.gpgSign = true; include.path = "~/path/to/config.inc"; includeIf."gitdif:~/src/dir".path = "~/path/to/conditional.inc"; extra = { boolean = true; integer = 38; name = "value"; subsection.value = "test"; };}; expected = '' [extra] ${"\t"}boolean = true ${"\t"}integer = 38 ${"\t"}name = "value"
[extra "subsection"] ${"\t"}value = "test"
[gpg] ${"\t"}program = "path-to-gpg"
[include] ${"\t"}path = "~/path/to/config.inc"
[includeIf "gitdif:~/src/dir"] ${"\t"}path = "~/path/to/conditional.inc"
[tag] ${"\t"}gpgSign = true
[user] ${"\t"}email = "user@example.org" ${"\t"}name = "John Doe" ${"\t"}signingKey = "00112233445566778899AABBCCDDEEFF" ''; };
# right now only invocation check testToJSONSimple = let val = { foobar = [ "baz" 1 2 3 ]; }; in { expr = generators.toJSON {} val; # trivial implementation expected = builtins.toJSON val; };
# right now only invocation check testToYAMLSimple = let val = { list = [ { one = 1; } { two = 2; } ]; all = 42; }; in { expr = generators.toYAML {} val; # trivial implementation expected = builtins.toJSON val; };
testToPretty = let deriv = derivation { name = "test"; builder = "/bin/sh"; system = "aarch64-linux"; }; in { expr = mapAttrs (const (generators.toPretty { multiline = false; })) rec { int = 42; float = 0.1337; bool = true; emptystring = ""; string = "fn\${o}\"r\\d"; newlinestring = "\n"; path = /. + "/foo"; null_ = null; function = x: x; functionArgs = { arg ? 4, foo }: arg; list = [ 3 4 function [ false ] ]; emptylist = []; attrs = { foo = null; "foo b/ar" = "baz"; }; emptyattrs = {}; drv = deriv; }; expected = rec { int = "42"; float = "0.1337"; bool = "true"; emptystring = ''""''; string = ''"fn\''${o}\"r\\d"''; newlinestring = "\"\\n\""; path = "/foo"; null_ = "null"; function = "<function>"; functionArgs = "<function, args: {arg?, foo}>"; list = "[ 3 4 ${function} [ false ] ]"; emptylist = "[ ]"; attrs = "{ foo = null; \"foo b/ar\" = \"baz\"; }"; emptyattrs = "{ }"; drv = "<derivation ${deriv.name}>"; }; };
testToPrettyLimit = let a.b = 1; a.c = a; in { expr = generators.toPretty { } (generators.withRecursion { throwOnDepthLimit = false; depthLimit = 2; } a); expected = "{\n b = 1;\n c = {\n b = \"<unevaluated>\";\n c = {\n b = \"<unevaluated>\";\n c = \"<unevaluated>\";\n };\n };\n}"; };
testToPrettyLimitThrow = let a.b = 1; a.c = a; in { expr = (builtins.tryEval (generators.toPretty { } (generators.withRecursion { depthLimit = 2; } a))).success; expected = false; };
testWithRecursionDealsWithFunctors = let functor = { __functor = self: { a, b, }: null; }; a = { value = "1234"; b = functor; c.d = functor; }; in { expr = generators.toPretty { } (generators.withRecursion { depthLimit = 1; throwOnDepthLimit = false; } a); expected = "{\n b = <function, args: {a, b}>;\n c = {\n d = \"<unevaluated>\";\n };\n value = \"<unevaluated>\";\n}"; };
testToPrettyMultiline = { expr = mapAttrs (const (generators.toPretty { })) { list = [ 3 4 [ false ] ]; attrs = { foo = null; bar.foo = "baz"; }; newlinestring = "\n"; multilinestring = '' hello ''${there} te'''st ''; multilinestring' = '' hello there test''; }; expected = { list = '' [ 3 4 [ false ] ]''; attrs = '' { bar = { foo = "baz"; }; foo = null; }''; newlinestring = "''\n \n''"; multilinestring = '' ''' hello '''''${there} te''''st '''''; multilinestring' = '' ''' hello there test''''';
}; };
testToPrettyAllowPrettyValues = { expr = generators.toPretty { allowPrettyValues = true; } { __pretty = v: "«" + v + "»"; val = "foo"; }; expected = "«foo»"; };
testToPlist = { expr = mapAttrs (const (generators.toPlist { })) { value = { nested.values = { int = 42; float = 0.1337; bool = true; emptystring = ""; string = "fn\${o}\"r\\d"; newlinestring = "\n"; path = /. + "/foo"; null_ = null; list = [ 3 4 "test" ]; emptylist = []; attrs = { foo = null; "foo b/ar" = "baz"; }; emptyattrs = {}; }; }; }; expected = { value = builtins.readFile ./test-to-plist-expected.plist; }; };
testToLuaEmptyAttrSet = { expr = generators.toLua {} {}; expected = ''{}''; };
testToLuaEmptyList = { expr = generators.toLua {} []; expected = ''{}''; };
testToLuaListOfVariousTypes = { expr = generators.toLua {} [ null 43 3.14159 true ]; expected = '' { nil, 43, 3.14159, true }''; };
testToLuaString = { expr = generators.toLua {} ''double-quote (") and single quotes (')''; expected = ''"double-quote (\") and single quotes (')"''; };
testToLuaAttrsetWithLuaInline = { expr = generators.toLua {} { x = generators.mkLuaInline ''"abc" .. "def"''; }; expected = '' { ["x"] = ("abc" .. "def") }''; };
testToLuaAttrsetWithSpaceInKey = { expr = generators.toLua {} { "some space and double-quote (\")" = 42; }; expected = '' { ["some space and double-quote (\")"] = 42 }''; };
testToLuaWithoutMultiline = { expr = generators.toLua { multiline = false; } [ 41 43 ]; expected = ''{ 41, 43 }''; };
testToLuaEmptyBindings = { expr = generators.toLua { asBindings = true; } {}; expected = ""; };
testToLuaBindings = { expr = generators.toLua { asBindings = true; } { x1 = 41; _y = { a = 43; }; }; expected = '' _y = { ["a"] = 43 } x1 = 41 ''; };
testToLuaPartialTableBindings = { expr = generators.toLua { asBindings = true; } { "x.y" = 42; }; expected = '' x.y = 42 ''; };
testToLuaIndentedBindings = { expr = generators.toLua { asBindings = true; indent = " "; } { x = { y = 42; }; }; expected = " x = {\n [\"y\"] = 42\n }\n"; };
testToLuaBindingsWithSpace = testingThrow ( generators.toLua { asBindings = true; } { "with space" = 42; } );
testToLuaBindingsWithLeadingDigit = testingThrow ( generators.toLua { asBindings = true; } { "11eleven" = 42; } );
testToLuaBasicExample = { expr = generators.toLua {} { cmd = [ "typescript-language-server" "--stdio" ]; settings.workspace.library = generators.mkLuaInline ''vim.api.nvim_get_runtime_file("", true)''; }; expected = '' { ["cmd"] = { "typescript-language-server", "--stdio" }, ["settings"] = { ["workspace"] = { ["library"] = (vim.api.nvim_get_runtime_file("", true)) } } }''; };
# CLI
testToGNUCommandLine = { expr = cli.toGNUCommandLine {} { data = builtins.toJSON { id = 0; }; X = "PUT"; retry = 3; retry-delay = null; url = [ "https://example.com/foo" "https://example.com/bar" ]; silent = false; verbose = true; };
expected = [ "-X" "PUT" "--data" "{\"id\":0}" "--retry" "3" "--url" "https://example.com/foo" "--url" "https://example.com/bar" "--verbose" ]; };
testToGNUCommandLineSeparator = { expr = cli.toGNUCommandLine { optionValueSeparator = "="; } { data = builtins.toJSON { id = 0; }; X = "PUT"; retry = 3; retry-delay = null; url = [ "https://example.com/foo" "https://example.com/bar" ]; silent = false; verbose = true; };
expected = [ "-X=PUT" "--data={\"id\":0}" "--retry=3" "--url=https://example.com/foo" "--url=https://example.com/bar" "--verbose" ]; };
testToGNUCommandLineShell = { expr = cli.toGNUCommandLineShell {} { data = builtins.toJSON { id = 0; }; X = "PUT"; retry = 3; retry-delay = null; url = [ "https://example.com/foo" "https://example.com/bar" ]; silent = false; verbose = true; };
expected = "'-X' 'PUT' '--data' '{\"id\":0}' '--retry' '3' '--url' 'https://example.com/foo' '--url' 'https://example.com/bar' '--verbose'"; };
testSanitizeDerivationNameLeadingDots = testSanitizeDerivationName { name = "..foo"; expected = "foo"; };
testSanitizeDerivationNameUnicode = testSanitizeDerivationName { name = "fö"; expected = "f-"; };
testSanitizeDerivationNameAscii = testSanitizeDerivationName { name = " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"; expected = "-+--.-0123456789-=-?-ABCDEFGHIJKLMNOPQRSTUVWXYZ-_-abcdefghijklmnopqrstuvwxyz-"; };
testSanitizeDerivationNameTooLong = testSanitizeDerivationName { name = "This string is loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"; expected = "loooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong"; };
testSanitizeDerivationNameTooLongWithInvalid = testSanitizeDerivationName { name = "Hello there aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&&&&&&&"; expected = "there-aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa-"; };
testSanitizeDerivationNameEmpty = testSanitizeDerivationName { name = ""; expected = "unknown"; };
testFreeformOptions = { expr = let submodule = { lib, ... }: { freeformType = lib.types.attrsOf (lib.types.submodule { options.bar = lib.mkOption {}; }); options.bar = lib.mkOption {}; };
module = { lib, ... }: { options.foo = lib.mkOption { type = lib.types.submodule submodule; }; };
options = (evalModules { modules = [ module ]; }).options;
locs = filter (o: ! o.internal) (optionAttrSetToDocList options); in map (o: o.loc) locs; expected = [ [ "_module" "args" ] [ "foo" ] [ "foo" "<name>" "bar" ] [ "foo" "bar" ] ]; };
testCartesianProductOfEmptySet = { expr = cartesianProduct {}; expected = [ {} ]; };
testCartesianProductOfOneSet = { expr = cartesianProduct { a = [ 1 2 3 ]; }; expected = [ { a = 1; } { a = 2; } { a = 3; } ]; };
testCartesianProductOfTwoSets = { expr = cartesianProduct { a = [ 1 ]; b = [ 10 20 ]; }; expected = [ { a = 1; b = 10; } { a = 1; b = 20; } ]; };
testCartesianProductOfTwoSetsWithOneEmpty = { expr = cartesianProduct { a = [ ]; b = [ 10 20 ]; }; expected = [ ]; };
testCartesianProductOfThreeSets = { expr = cartesianProduct { a = [ 1 2 3 ]; b = [ 10 20 30 ]; c = [ 100 200 300 ]; }; expected = [ { a = 1; b = 10; c = 100; } { a = 1; b = 10; c = 200; } { a = 1; b = 10; c = 300; }
{ a = 1; b = 20; c = 100; } { a = 1; b = 20; c = 200; } { a = 1; b = 20; c = 300; }
{ a = 1; b = 30; c = 100; } { a = 1; b = 30; c = 200; } { a = 1; b = 30; c = 300; }
{ a = 2; b = 10; c = 100; } { a = 2; b = 10; c = 200; } { a = 2; b = 10; c = 300; }
{ a = 2; b = 20; c = 100; } { a = 2; b = 20; c = 200; } { a = 2; b = 20; c = 300; }
{ a = 2; b = 30; c = 100; } { a = 2; b = 30; c = 200; } { a = 2; b = 30; c = 300; }
{ a = 3; b = 10; c = 100; } { a = 3; b = 10; c = 200; } { a = 3; b = 10; c = 300; }
{ a = 3; b = 20; c = 100; } { a = 3; b = 20; c = 200; } { a = 3; b = 20; c = 300; }
{ a = 3; b = 30; c = 100; } { a = 3; b = 30; c = 200; } { a = 3; b = 30; c = 300; } ]; };
testMapCartesianProductOfOneSet = { expr = mapCartesianProduct ({a}: a * 2) { a = [ 1 2 3 ]; }; expected = [ 2 4 6 ]; };
testMapCartesianProductOfTwoSets = { expr = mapCartesianProduct ({a,b}: a + b) { a = [ 1 ]; b = [ 10 20 ]; }; expected = [ 11 21 ]; };
testMapCartesianProcutOfTwoSetsWithOneEmpty = { expr = mapCartesianProduct (x: x.a + x.b) { a = [ ]; b = [ 10 20 ]; }; expected = [ ]; };
testMapCartesianProductOfThreeSets = { expr = mapCartesianProduct ({a,b,c}: a + b + c) { a = [ 1 2 3 ]; b = [ 10 20 30 ]; c = [ 100 200 300 ]; }; expected = [ 111 211 311 121 221 321 131 231 331 112 212 312 122 222 322 132 232 332 113 213 313 123 223 323 133 233 333 ]; };
# The example from the showAttrPath documentation testShowAttrPathExample = { expr = showAttrPath [ "foo" "10" "bar" ]; expected = "foo.\"10\".bar"; };
testShowAttrPathEmpty = { expr = showAttrPath []; expected = "<root attribute path>"; };
testShowAttrPathVarious = { expr = showAttrPath [ "." "foo" "2" "a2-b" "_bc'de" ]; expected = ''".".foo."2".a2-b._bc'de''; };
testGroupBy = { expr = groupBy (n: toString (mod n 5)) (range 0 16); expected = { "0" = [ 0 5 10 15 ]; "1" = [ 1 6 11 16 ]; "2" = [ 2 7 12 ]; "3" = [ 3 8 13 ]; "4" = [ 4 9 14 ]; }; };
testGroupBy' = { expr = groupBy' builtins.add 0 (x: boolToString (x > 2)) [ 5 1 2 3 4 ]; expected = { false = 3; true = 12; }; };
# The example from the updateManyAttrsByPath documentation testUpdateManyAttrsByPathExample = { expr = updateManyAttrsByPath [ { path = [ "a" "b" ]; update = old: { d = old.c; }; } { path = [ "a" "b" "c" ]; update = old: old + 1; } { path = [ "x" "y" ]; update = old: "xy"; } ] { a.b.c = 0; }; expected = { a = { b = { d = 1; }; }; x = { y = "xy"; }; }; };
# If there are no updates, the value is passed through testUpdateManyAttrsByPathNone = { expr = updateManyAttrsByPath [] "something"; expected = "something"; };
# A single update to the root path is just like applying the function directly testUpdateManyAttrsByPathSingleIncrement = { expr = updateManyAttrsByPath [ { path = [ ]; update = old: old + 1; } ] 0; expected = 1; };
# Multiple updates can be applied are done in order testUpdateManyAttrsByPathMultipleIncrements = { expr = updateManyAttrsByPath [ { path = [ ]; update = old: old + "a"; } { path = [ ]; update = old: old + "b"; } { path = [ ]; update = old: old + "c"; } ] ""; expected = "abc"; };
# If an update doesn't use the value, all previous updates are not evaluated testUpdateManyAttrsByPathLazy = { expr = updateManyAttrsByPath [ { path = [ ]; update = old: old + throw "nope"; } { path = [ ]; update = old: "untainted"; } ] (throw "start"); expected = "untainted"; };
# Deeply nested attributes can be updated without affecting others testUpdateManyAttrsByPathDeep = { expr = updateManyAttrsByPath [ { path = [ "a" "b" "c" ]; update = old: old + 1; } ] { a.b.c = 0;
a.b.z = 0; a.y.z = 0; x.y.z = 0; }; expected = { a.b.c = 1;
a.b.z = 0; a.y.z = 0; x.y.z = 0; }; };
# Nested attributes are updated first testUpdateManyAttrsByPathNestedBeforehand = { expr = updateManyAttrsByPath [ { path = [ "a" ]; update = old: old // { x = old.b; }; } { path = [ "a" "b" ]; update = old: old + 1; } ] { a.b = 0; }; expected = { a.b = 1; a.x = 1; }; };
## Levenshtein distance functions and co. testCommonPrefixLengthEmpty = { expr = strings.commonPrefixLength "" "hello"; expected = 0; };
testCommonPrefixLengthSame = { expr = strings.commonPrefixLength "hello" "hello"; expected = 5; };
testCommonPrefixLengthDiffering = { expr = strings.commonPrefixLength "hello" "hey"; expected = 2; };
testCommonSuffixLengthEmpty = { expr = strings.commonSuffixLength "" "hello"; expected = 0; };
testCommonSuffixLengthSame = { expr = strings.commonSuffixLength "hello" "hello"; expected = 5; };
testCommonSuffixLengthDiffering = { expr = strings.commonSuffixLength "test" "rest"; expected = 3; };
testLevenshteinEmpty = { expr = strings.levenshtein "" ""; expected = 0; };
testLevenshteinOnlyAdd = { expr = strings.levenshtein "" "hello there"; expected = 11; };
testLevenshteinOnlyRemove = { expr = strings.levenshtein "hello there" ""; expected = 11; };
testLevenshteinOnlyTransform = { expr = strings.levenshtein "abcdef" "ghijkl"; expected = 6; };
testLevenshteinMixed = { expr = strings.levenshtein "kitchen" "sitting"; expected = 5; };
testLevenshteinAtMostZeroFalse = { expr = strings.levenshteinAtMost 0 "foo" "boo"; expected = false; };
testLevenshteinAtMostZeroTrue = { expr = strings.levenshteinAtMost 0 "foo" "foo"; expected = true; };
testLevenshteinAtMostOneFalse = { expr = strings.levenshteinAtMost 1 "car" "ct"; expected = false; };
testLevenshteinAtMostOneTrue = { expr = strings.levenshteinAtMost 1 "car" "cr"; expected = true; };
# We test levenshteinAtMost 2 particularly well because it uses a complicated # implementation testLevenshteinAtMostTwoIsEmpty = { expr = strings.levenshteinAtMost 2 "" ""; expected = true; };
testLevenshteinAtMostTwoIsZero = { expr = strings.levenshteinAtMost 2 "abcdef" "abcdef"; expected = true; };
testLevenshteinAtMostTwoIsOne = { expr = strings.levenshteinAtMost 2 "abcdef" "abddef"; expected = true; };
testLevenshteinAtMostTwoDiff0False = { expr = strings.levenshteinAtMost 2 "abcdef" "aczyef"; expected = false; };
testLevenshteinAtMostTwoDiff0Outer = { expr = strings.levenshteinAtMost 2 "abcdef" "zbcdez"; expected = true; };
testLevenshteinAtMostTwoDiff0DelLeft = { expr = strings.levenshteinAtMost 2 "abcdef" "bcdefz"; expected = true; };
testLevenshteinAtMostTwoDiff0DelRight = { expr = strings.levenshteinAtMost 2 "abcdef" "zabcde"; expected = true; };
testLevenshteinAtMostTwoDiff1False = { expr = strings.levenshteinAtMost 2 "abcdef" "bddez"; expected = false; };
testLevenshteinAtMostTwoDiff1DelLeft = { expr = strings.levenshteinAtMost 2 "abcdef" "bcdez"; expected = true; };
testLevenshteinAtMostTwoDiff1DelRight = { expr = strings.levenshteinAtMost 2 "abcdef" "zbcde"; expected = true; };
testLevenshteinAtMostTwoDiff2False = { expr = strings.levenshteinAtMost 2 "hello" "hxo"; expected = false; };
testLevenshteinAtMostTwoDiff2True = { expr = strings.levenshteinAtMost 2 "hello" "heo"; expected = true; };
testLevenshteinAtMostTwoDiff3 = { expr = strings.levenshteinAtMost 2 "hello" "ho"; expected = false; };
testLevenshteinAtMostThreeFalse = { expr = strings.levenshteinAtMost 3 "hello" "Holla!"; expected = false; };
testLevenshteinAtMostThreeTrue = { expr = strings.levenshteinAtMost 3 "hello" "Holla"; expected = true; };
# DERIVATIONS
testLazyDerivationIsLazyInDerivationForAttrNames = { expr = attrNames (lazyDerivation { derivation = throw "not lazy enough"; }); # It's ok to add attribute names here when lazyDerivation is improved # in accordance with its inline comments. expected = [ "drvPath" "meta" "name" "out" "outPath" "outputName" "outputs" "system" "type" ]; };
testLazyDerivationIsLazyInDerivationForPassthruAttr = { expr = (lazyDerivation { derivation = throw "not lazy enough"; passthru.tests = "whatever is in tests"; }).tests; expected = "whatever is in tests"; };
testLazyDerivationIsLazyInDerivationForPassthruAttr2 = { # passthru.tests is not a special case. It works for any attr. expr = (lazyDerivation { derivation = throw "not lazy enough"; passthru.foo = "whatever is in foo"; }).foo; expected = "whatever is in foo"; };
testLazyDerivationIsLazyInDerivationForMeta = { expr = (lazyDerivation { derivation = throw "not lazy enough"; meta = "whatever is in meta"; }).meta; expected = "whatever is in meta"; };
testLazyDerivationReturnsDerivationAttrs = let derivation = { type = "derivation"; outputs = ["out"]; out = "test out"; outPath = "test outPath"; outputName = "out"; drvPath = "test drvPath"; name = "test name"; system = "test system"; meta = "test meta"; }; in { expr = lazyDerivation { inherit derivation; }; expected = derivation; };
testOptionalDrvAttr = let mkDerivation = args: derivation (args // { builder = "builder"; system = "system"; __ignoreNulls = true; }); in { expr = (mkDerivation { name = "foo"; x = optionalDrvAttr true 1; y = optionalDrvAttr false 1; }).drvPath; expected = (mkDerivation { name = "foo"; x = 1; }).drvPath; };
testLazyDerivationMultiOutputReturnsDerivationAttrs = let derivation = { type = "derivation"; outputs = ["out" "dev"]; dev = "test dev"; out = "test out"; outPath = "test outPath"; outputName = "out"; drvPath = "test drvPath"; name = "test name"; system = "test system"; meta.position = "/hi:23"; }; in { expr = lazyDerivation { inherit derivation; outputs = ["out" "dev"]; passthru.meta.position = "/hi:23"; }; expected = derivation; };
testTypeDescriptionInt = { expr = (with types; int).description; expected = "signed integer"; }; testTypeDescriptionIntsPositive = { expr = (with types; ints.positive).description; expected = "positive integer, meaning >0"; }; testTypeDescriptionIntsPositiveOrEnumAuto = { expr = (with types; either ints.positive (enum ["auto"])).description; expected = ''positive integer, meaning >0, or value "auto" (singular enum)''; }; testTypeDescriptionListOfPositive = { expr = (with types; listOf ints.positive).description; expected = "list of (positive integer, meaning >0)"; }; testTypeDescriptionListOfInt = { expr = (with types; listOf int).description; expected = "list of signed integer"; }; testTypeDescriptionListOfListOfInt = { expr = (with types; listOf (listOf int)).description; expected = "list of list of signed integer"; }; testTypeDescriptionListOfEitherStrOrBool = { expr = (with types; listOf (either str bool)).description; expected = "list of (string or boolean)"; }; testTypeDescriptionEitherListOfStrOrBool = { expr = (with types; either (listOf bool) str).description; expected = "(list of boolean) or string"; }; testTypeDescriptionEitherStrOrListOfBool = { expr = (with types; either str (listOf bool)).description; expected = "string or list of boolean"; }; testTypeDescriptionOneOfListOfStrOrBool = { expr = (with types; oneOf [ (listOf bool) str ]).description; expected = "(list of boolean) or string"; }; testTypeDescriptionOneOfListOfStrOrBoolOrNumber = { expr = (with types; oneOf [ (listOf bool) str number ]).description; expected = "(list of boolean) or string or signed integer or floating point number"; }; testTypeDescriptionEitherListOfBoolOrEitherStringOrNumber = { expr = (with types; either (listOf bool) (either str number)).description; expected = "(list of boolean) or string or signed integer or floating point number"; }; testTypeDescriptionEitherEitherListOfBoolOrStringOrNumber = { expr = (with types; either (either (listOf bool) str) number).description; expected = "(list of boolean) or string or signed integer or floating point number"; }; testTypeDescriptionEitherNullOrBoolOrString = { expr = (with types; either (nullOr bool) str).description; expected = "null or boolean or string"; }; testTypeDescriptionEitherListOfEitherBoolOrStrOrInt = { expr = (with types; either (listOf (either bool str)) int).description; expected = "(list of (boolean or string)) or signed integer"; }; testTypeDescriptionEitherIntOrListOrEitherBoolOrStr = { expr = (with types; either int (listOf (either bool str))).description; expected = "signed integer or list of (boolean or string)"; };
# Meta testGetExe'Output = { expr = getExe' { type = "derivation"; out = "somelonghash"; bin = "somelonghash"; } "executable"; expected = "somelonghash/bin/executable"; };
testGetExeOutput = { expr = getExe { type = "derivation"; out = "somelonghash"; bin = "somelonghash"; meta.mainProgram = "mainProgram"; }; expected = "somelonghash/bin/mainProgram"; };
testGetExe'FailureFirstArg = testingThrow ( getExe' "not a derivation" "executable" );
testGetExe'FailureSecondArg = testingThrow ( getExe' { type = "derivation"; } "dir/executable" );
testGetLicenseFromSpdxIdOrExamples = { expr = [ (getLicenseFromSpdxIdOr "MIT" null) (getLicenseFromSpdxIdOr "mIt" null) (getLicenseFromSpdxIdOr "MY LICENSE" lib.licenses.free) (getLicenseFromSpdxIdOr "MY LICENSE" null) ]; expected = [ lib.licenses.mit lib.licenses.mit lib.licenses.free null ]; };
testGetLicenseFromSpdxIdOrThrow = testingThrow ( getLicenseFromSpdxIdOr "MY LICENSE" (throw "No SPDX ID matches MY LICENSE") );
testPlatformMatch = { expr = meta.platformMatch { system = "x86_64-linux"; } "x86_64-linux"; expected = true; };
testPlatformMatchAttrs = { expr = meta.platformMatch (systems.elaborate "x86_64-linux") (systems.elaborate "x86_64-linux").parsed; expected = true; };
testPlatformMatchNoMatch = { expr = meta.platformMatch { system = "x86_64-darwin"; } "x86_64-linux"; expected = false; };
testPlatformMatchMissingSystem = { expr = meta.platformMatch { } "x86_64-linux"; expected = false; };
testPackagesFromDirectoryRecursive = { expr = packagesFromDirectoryRecursive { callPackage = path: overrides: import path overrides; directory = ./packages-from-directory; }; expected = { a = "a"; b = "b"; # Note: Other files/directories in `./test-data/c/` are ignored and can be # used by `package.nix`. c = "c"; my-namespace = { d = "d"; e = "e"; f = "f"; my-sub-namespace = { g = "g"; h = "h"; }; }; }; };
# Check that `packagesFromDirectoryRecursive` can process a directory with a # top-level `package.nix` file into a single package. testPackagesFromDirectoryRecursiveTopLevelPackageNix = { expr = packagesFromDirectoryRecursive { callPackage = path: overrides: import path overrides; directory = ./packages-from-directory/c; }; expected = "c"; };}