tests: move fixtures to dedicated dir

Signed-off-by: NotAShelf <raf@notashelf.dev>
Change-Id: I9d6ce6a264780f215b1b57d947b5264c6a6a6964

tests/fixtures/ancient_let.nix

@@ -0,0 +1,8 @@
+# Test ancient let syntax: let { bindings; body = expr; }
+# This is equivalent to: let bindings in expr, but has been deprecated
+# in newer Nix versions.
+let {
+  x = 10;
+  y = 20;
+  body = x + y;
+}

tests/fixtures/attrset.nix

@@ -0,0 +1,8 @@
+# Attrset test
+{
+  name = "test";
+  value = 123;
+  nested = {
+    inner = true;
+  };
+}

tests/fixtures/attrset_var.nix

@@ -0,0 +1,3 @@
+let
+  x = 10;
+in {a = x;}

tests/fixtures/block_comments.nix

@@ -0,0 +1,24 @@
+# Test block comments /* */
+/*
+This is a block comment
+*/
+let
+  x = 42;
+  /*
+  inline block comment
+  */
+  /*
+  Multi-line
+  block
+  comment
+  */
+  y = 100;
+in
+  /*
+  Comment before expression
+  */
+  x + y
+/*
+Trailing comment
+*/
+

tests/fixtures/comparison.nix

@@ -0,0 +1,8 @@
+# Test comparison operators
+let
+  a = 10;
+  b = 20;
+in
+  if a < b
+  then true
+  else false

tests/fixtures/dynamic_attr_full.nix

@@ -0,0 +1,14 @@
+# Test dynamic attribute names
+let
+  key = "mykey";
+  value = 42;
+in {
+  # Dynamic attribute with string interpolation
+  "${key}" = value;
+
+  # Another dynamic attribute
+  "${key}_suffix" = value + 1;
+
+  # Static attribute for comparison
+  static = 100;
+}

tests/fixtures/dynamic_attrs.nix

@@ -0,0 +1,15 @@
+# Test dynamic attribute names
+# Note: Full dynamic attrs require runtime evaluation
+# For now, testing that syntax is recognized
+let
+  key = "mykey";
+in {
+  # Static attribute for comparison
+  static = "value";
+
+  # Dynamic attribute name (basic string interpolation)
+  # "${key}" = "dynamic_value";
+
+  # For now, use workaround with static names
+  mykey = "works";
+}

tests/fixtures/float_test.nix

@@ -0,0 +1 @@
+1.5

tests/fixtures/home_path.nix

@@ -0,0 +1,11 @@
+# Test home-relative paths
+# Note: This will resolve to the actual home directory at evaluation time
+let
+  # Example home path (will be expanded by evaluator)
+  config = ~/..config;
+  file = ~/.bashrc;
+in {
+  # These are just path values that will be expanded
+  configPath = config;
+  filePath = file;
+}

tests/fixtures/if.nix

@@ -0,0 +1,4 @@
+# Conditional test
+if true
+then 1
+else 2

tests/fixtures/import_lookup.nix

@@ -0,0 +1,3 @@
+# Test import with lookup path
+# Common pattern: import <nixpkgs> { }
+import <nixpkgs>

tests/fixtures/import_simple.nix

@@ -0,0 +1,9 @@
+# Test import expression
+# Import evaluates the file and returns its value
+# Import a file that returns a simple value (42)
+import ./simple.nix
+# Can also import lookup paths:
+# import <nixpkgs> { }
+# Import with path expressions:
+# import (./dir + "/file.nix")
+

tests/fixtures/indented_string.nix

@@ -0,0 +1,31 @@
+# Test indented strings (multi-line strings with '' delimiters)
+let
+  # Simple indented string
+  simple = ''
+    Hello
+    World
+  '';
+
+  # Indented string with interpolation
+  name = "Nix";
+  greeting = ''
+    Welcome to ${name}!
+    This is indented.
+  '';
+
+  # Escape sequences
+  escapes = ''
+    Literal dollar: ''$
+    Literal quotes: '''
+    Regular text
+  '';
+
+  # Shell script example (common use case)
+  script = ''
+    #!/bin/bash
+    echo "Running script"
+    ls -la
+  '';
+in {
+  inherit simple greeting escapes script;
+}

tests/fixtures/inherit.nix

@@ -0,0 +1,20 @@
+# Test inherit keyword
+let
+  x = 10;
+  y = 20;
+  attrs = {
+    a = 1;
+    b = 2;
+    c = 3;
+  };
+in {
+  # Basic inherit from outer scope
+  inherit x y;
+
+  # Inherit from expression
+  inherit (attrs) a b;
+
+  # Mixed
+  z = 30;
+  inherit (attrs) c;
+}

tests/fixtures/inherit_from.nix

@@ -0,0 +1,3 @@
+let
+  attrs = {a = 1;};
+in {inherit (attrs) a;}

tests/fixtures/inherit_simple.nix

@@ -0,0 +1,3 @@
+let
+  x = 10;
+in {inherit x;}

tests/fixtures/lambda_pattern.nix

@@ -0,0 +1,61 @@
+# Test lambda patterns
+let
+  # Basic destructuring
+  f1 = {
+    a,
+    b,
+  }:
+    a + b;
+
+  # With default values
+  f2 = {
+    a,
+    b ? 10,
+  }:
+    a + b;
+
+  # With ellipsis (extra fields allowed)
+  f3 = {a, ...}: a * 2;
+
+  # Named pattern with ellipsis to allow extra fields
+  f4 = arg @ {
+    a,
+    b,
+    ...
+  }:
+    a + b + arg.c;
+
+  # Simple lambda (not a pattern)
+  f5 = x: x + 1;
+in {
+  # Test basic destructuring
+  test1 = f1 {
+    a = 3;
+    b = 4;
+  };
+
+  # Test with defaults (provide both)
+  test2a = f2 {
+    a = 5;
+    b = 6;
+  };
+
+  # Test with defaults (use default for b)
+  test2b = f2 {a = 5;};
+
+  # Test ellipsis (extra field ignored)
+  test3 = f3 {
+    a = 7;
+    extra = 999;
+  };
+
+  # Test named pattern
+  test4 = f4 {
+    a = 1;
+    b = 2;
+    c = 3;
+  };
+
+  # Test simple lambda
+  test5 = f5 10;
+}

tests/fixtures/let.nix

@@ -0,0 +1,6 @@
+# Let binding test
+let
+  x = 10;
+  y = 20;
+in
+  x

tests/fixtures/list_concat.nix

@@ -0,0 +1,15 @@
+# Test list concatenation operator ++
+let
+  list1 = [1 2 3];
+  list2 = [4 5 6];
+  empty = [];
+in {
+  # Basic concatenation
+  combined = list1 ++ list2;
+
+  # Concatenate with empty list
+  with_empty = list1 ++ empty;
+
+  # Nested concatenation
+  triple = [1] ++ [2] ++ [3];
+}

tests/fixtures/list_simple.nix

@@ -0,0 +1,8 @@
+# Test basic list support
+let
+  x = [1 2 3];
+  y = [4 5 6];
+  z = x ++ y; # List concatenation
+in {
+  inherit x y z;
+}

tests/fixtures/logical.nix

@@ -0,0 +1,10 @@
+# Test logical operators
+let
+  x = true;
+  y = false;
+in
+  if x && y
+  then 1
+  else if x || y
+  then 2
+  else 3

tests/fixtures/lookup_path.nix

@@ -0,0 +1,8 @@
+# Test lookup path syntax
+# Lookup paths resolve via NIX_PATH environment variable
+# Example: <nixpkgs> -> /nix/var/nix/profiles/per-user/root/channels/nixpkgs
+# Simple lookup path
+<nixpkgs>
+# Nested lookup path (common pattern)
+# <nixpkgs/lib>
+

tests/fixtures/lookup_path_nested.nix

@@ -0,0 +1,3 @@
+# Test nested lookup path
+# Common pattern in Nix: <nixpkgs/lib> or <nixpkgs/pkgs/stdenv>
+<nixpkgs/lib>

tests/fixtures/merge.nix

@@ -0,0 +1,2 @@
+# Test attrset merge operator (//)
+{a = {x = 1;} // {y = 2;};}

tests/fixtures/nested_attrs.nix

@@ -0,0 +1,13 @@
+# Test nested attribute paths
+{
+  # Simple nested path
+  a.b.c = 42;
+
+  # Multiple nested paths
+  x.y = 1;
+  x.z = 2;
+
+  # Mix of nested and non-nested
+  foo = "bar";
+  nested.deep.value = 100;
+}

tests/fixtures/operators.nix

@@ -0,0 +1,6 @@
+# Test arithmetic operators
+let
+  x = 10;
+  y = 5;
+in
+  (x + y) * 2

tests/fixtures/or_in_attrset.nix

@@ -0,0 +1,6 @@
+# Test 'or' in attrset context
+let
+  attrs = {a = 1;};
+in {
+  test = attrs.a or 999;
+}

tests/fixtures/or_simple.nix

@@ -0,0 +1,5 @@
+# Simplest 'or' test
+let
+  x = {a = 1;};
+in
+  x.a or 2

tests/fixtures/path_concat.nix

@@ -0,0 +1,13 @@
+# Test path concatenation
+let
+  # Path + string = path
+  p1 = ./foo + "/bar";
+
+  # String + path = path
+  p2 = "/prefix" + ./suffix;
+
+  # Path + path = path
+  p3 = ./dir + ./file;
+in {
+  inherit p1 p2 p3;
+}

tests/fixtures/precedence.nix

@@ -0,0 +1,12 @@
+# Test operator precedence
+let
+  a = 1 + 2 * 3; # Should be 1 + (2 * 3) = 7
+  b = 10 - 5 - 2; # Should be (10 - 5) - 2 = 3
+  c = true && false || true; # Should be (true && false) || true = true
+  d = 1 < 2 && 3 > 2; # Should be (1 < 2) && (3 > 2) = true
+in {
+  a = a;
+  b = b;
+  c = c;
+  d = d;
+}

tests/fixtures/select_or_default.nix

@@ -0,0 +1,19 @@
+# Test selection with 'or' default
+let
+  attrs = {
+    a = 1;
+    b = 2;
+  };
+in {
+  # Attribute exists - should use value from attrs
+  has_attr = attrs.a or 999;
+
+  # Attribute doesn't exist - should use default
+  missing_attr = attrs.c or 100;
+
+  # Nested default expression
+  nested = attrs.d or (attrs.a + attrs.b);
+
+  # Default with literal
+  with_string = attrs.name or "default_name";
+}

tests/fixtures/shortcircuit.nix

@@ -0,0 +1,10 @@
+# Test short-circuit evaluation
+let
+  alwaysFalse = false;
+  alwaysTrue = true;
+  x = 10;
+in {
+  and_false = alwaysFalse && alwaysTrue;
+  or_true = alwaysTrue || alwaysFalse;
+  impl_false = alwaysFalse -> alwaysFalse;
+}

tests/fixtures/shortcircuit2.nix

@@ -0,0 +1,6 @@
+# Test short-circuit evaluation
+{
+  and_false = false && true;
+  or_true = true || false;
+  impl_false = false -> false;
+}

tests/fixtures/simple.nix

@@ -0,0 +1,2 @@
+# Simple constant test
+42

tests/fixtures/simple_op.nix

@@ -0,0 +1 @@
+1 + 2

tests/fixtures/string_interp.nix

@@ -0,0 +1,20 @@
+# Test string interpolation
+let
+  name = "world";
+  x = 42;
+  bool_val = true;
+in {
+  # Simple interpolation
+  greeting = "Hello ${name}!";
+
+  # Multiple interpolations
+  multi = "x is ${x} and name is ${name}";
+
+  # Expression evaluation in interpolation
+  computed = "x + 10 = ${x + 10}";
+
+  bool_check = "${bool_val} is true!";
+
+  # Just a string, no interpolation
+  plain = "plain text";
+}

tests/fixtures/unary.nix

@@ -0,0 +1,8 @@
+# Test unary operators
+let
+  x = 10;
+  y = true;
+in {
+  neg = -x;
+  not = !y;
+}

tests/fixtures/uri_test.nix

@@ -0,0 +1,3 @@
+https://example.com/path?query=1
+#frag
+