tests: move fixtures to dedicated dir

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

tests/block_comments.nix

@@ -1,12 +0,0 @@
-# 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/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/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/import_simple.nix

@@ -1,11 +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/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/lookup_path.nix

@@ -1,9 +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/or_simple.nix

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

tests/fixtures/select_or_default.nix

@@ -1,6 +1,9 @@
 # Test selection with 'or' default
 let
-  attrs = { a = 1; b = 2; };
+  attrs = {
+    a = 1;
+    b = 2;
+  };
 in {
   # Attribute exists - should use value from attrs
   has_attr = attrs.a or 999;

tests/or_simple.nix

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

tests/regression_test.cpp

@@ -1,3 +1,4 @@
+#include "irc/parser.h"
 #include "irc/serializer.h"
 #include "irc/types.h"
 #include <cassert>
@@ -30,33 +31,28 @@ void test_enum_compatibility() {
   if (static_cast<uint8_t>(NodeType::WITH) == 0x32) {
     std::cout << "  PASS: WITH has correct value 0x32" << std::endl;
   } else {
-    std::cerr << "  FAIL: WITH should be 0x32, got "
-              << static_cast<uint8_t>(NodeType::WITH) << std::endl;
+    std::cerr << "  FAIL: WITH should be 0x32, got " << static_cast<uint8_t>(NodeType::WITH)
+              << std::endl;
   }
 
   if (static_cast<uint8_t>(NodeType::HAS_ATTR) == 0x34) {
-    std::cout << "  PASS: HAS_ATTR has value 0x34 (new slot after WITH bump)"
-              << std::endl;
+    std::cout << "  PASS: HAS_ATTR has value 0x34 (new slot after WITH bump)" << std::endl;
   } else if (static_cast<uint8_t>(NodeType::HAS_ATTR) == 0x33 &&
              static_cast<uint8_t>(NodeType::WITH) == 0x32) {
     std::cout << "  PASS: HAS_ATTR has value 0x33 (restored original with WITH "
                  "at 0x32)"
               << std::endl;
   } else {
-    std::cerr << "  FAIL: HAS_ATTR value is "
-              << static_cast<uint8_t>(NodeType::HAS_ATTR)
+    std::cerr << "  FAIL: HAS_ATTR value is " << static_cast<uint8_t>(NodeType::HAS_ATTR)
               << " (expected 0x34 or 0x33 with WITH=0x32)" << std::endl;
   }
 
   if (IR_VERSION == 2) {
-    std::cout << "  PASS: IR_VERSION bumped to 2 for breaking change"
-              << std::endl;
+    std::cout << "  PASS: IR_VERSION bumped to 2 for breaking change" << std::endl;
   } else if (static_cast<uint8_t>(NodeType::WITH) == 0x32) {
-    std::cout << "  PASS: IR_VERSION unchanged but WITH restored to 0x32"
-              << std::endl;
+    std::cout << "  PASS: IR_VERSION unchanged but WITH restored to 0x32" << std::endl;
   } else {
-    std::cerr << "  FAIL: Either bump IR_VERSION or fix enum values"
-              << std::endl;
+    std::cerr << "  FAIL: Either bump IR_VERSION or fix enum values" << std::endl;
   }
 }
 
@@ -81,18 +77,15 @@ void test_serializer_select_with_default() {
   auto loaded = deser.deserialize(bytes);
 
   auto* loaded_select = loaded.entry->get_if<SelectNode>();
-  if (loaded_select && loaded_select->default_expr &&
-      *loaded_select->default_expr) {
+  if (loaded_select && loaded_select->default_expr && *loaded_select->default_expr) {
     auto* def_val = (*loaded_select->default_expr)->get_if<ConstIntNode>();
     if (def_val && def_val->value == 100) {
-      std::cout << "  PASS: SELECT with default_expr round-trips correctly"
-                << std::endl;
+      std::cout << "  PASS: SELECT with default_expr round-trips correctly" << std::endl;
     } else {
       std::cerr << "  FAIL: default_expr value incorrect" << std::endl;
     }
   } else {
-    std::cerr << "  FAIL: default_expr not deserialized (missing u8 flag read)"
-              << std::endl;
+    std::cerr << "  FAIL: default_expr not deserialized (missing u8 flag read)" << std::endl;
   }
 }
 
@@ -115,10 +108,8 @@ void test_serializer_select_without_default() {
   auto loaded = deser.deserialize(bytes);
 
   auto* loaded_select = loaded.entry->get_if<SelectNode>();
-  if (loaded_select &&
-      (!loaded_select->default_expr || !*loaded_select->default_expr)) {
-    std::cout << "  PASS: SELECT without default_expr round-trips correctly"
-              << std::endl;
+  if (loaded_select && (!loaded_select->default_expr || !*loaded_select->default_expr)) {
+    std::cout << "  PASS: SELECT without default_expr round-trips correctly" << std::endl;
   } else {
     std::cerr << "  FAIL: default_expr should be null/absent" << std::endl;
   }
@@ -127,34 +118,53 @@ void test_serializer_select_without_default() {
 void test_parser_brace_depth_in_strings() {
   std::cout << "> Parser brace depth handling in strings..." << std::endl;
 
-  std::string test_input = R"(
-        let s = "test}"; in ${s}
-    )";
+  std::string test_input = R"(let s = "test}"; in s)";
 
-  std::cout << "  Test input contains '}' inside string - should not end "
-               "interpolation"
-            << std::endl;
-  std::cout << "  NOTE: This test requires running through actual parser"
-            << std::endl;
+  try {
+    Parser parser;
+    auto ast = parser.parse(test_input);
+    TEST_PASS("Brace inside string does not confuse parser");
+  } catch (const std::exception& e) {
+    TEST_FAIL("Parser should handle '}' inside strings");
+  }
 }
 
 void test_parser_has_ellipsis_usage() {
   std::cout << "> Parser has_ellipsis usage..." << std::endl;
 
-  std::cout << "  NOTE: LambdaNode should have strict_pattern field when "
-               "has_ellipsis is false"
-            << std::endl;
-  std::cout << "  This requires checking the parser output for strict patterns"
-            << std::endl;
+  std::string with_ellipsis = "{ a, ... }: a";
+  std::string without_ellipsis = "{ a, b }: a + b";
+
+  try {
+    Parser parser1;
+    auto ast1 = parser1.parse(with_ellipsis);
+    TEST_PASS("Pattern with ellipsis parses correctly");
+
+    Parser parser2;
+    auto ast2 = parser2.parse(without_ellipsis);
+    TEST_PASS("Pattern without ellipsis parses correctly");
+  } catch (const std::exception& e) {
+    TEST_FAIL("Pattern parsing failed");
+  }
 }
 
 void test_parser_expect_in_speculative_parsing() {
   std::cout << "> Parser expect() in speculative parsing..." << std::endl;
 
-  std::cout << "  NOTE: try_parse_lambda should not throw on non-lambda input"
-            << std::endl;
-  std::cout << "  This requires testing parser with invalid lambda patterns"
-            << std::endl;
+  std::string not_a_lambda = "1 + 2";
+  std::string actual_lambda = "x: x + 1";
+
+  try {
+    Parser parser1;
+    auto ast1 = parser1.parse(not_a_lambda);
+    TEST_PASS("Non-lambda input does not cause parser to throw");
+
+    Parser parser2;
+    auto ast2 = parser2.parse(actual_lambda);
+    TEST_PASS("Actual lambda parses correctly");
+  } catch (const std::exception& e) {
+    TEST_FAIL("Parser should handle both lambda and non-lambda input");
+  }
 }
 
 void test_lookup_path_node() {
@@ -172,8 +182,7 @@ void test_lookup_path_node() {
 
   auto* loaded_lookup = loaded.entry->get_if<ConstLookupPathNode>();
   TEST_CHECK(loaded_lookup != nullptr, "Deserialized node is ConstLookupPathNode");
-  TEST_CHECK(loaded_lookup && loaded_lookup->value == "nixpkgs",
-             "Lookup path value is 'nixpkgs'");
+  TEST_CHECK(loaded_lookup && loaded_lookup->value == "nixpkgs", "Lookup path value is 'nixpkgs'");
 }
 
 void test_import_node() {
@@ -192,14 +201,12 @@ void test_import_node() {
 
   auto* loaded_import = loaded.entry->get_if<ImportNode>();
   TEST_CHECK(loaded_import != nullptr, "Deserialized node is ImportNode");
-  TEST_CHECK(loaded_import && loaded_import->path != nullptr,
-             "Import node has path");
+  TEST_CHECK(loaded_import && loaded_import->path != nullptr, "Import node has path");
 
   if (loaded_import && loaded_import->path) {
     auto* path_node = loaded_import->path->get_if<ConstPathNode>();
     TEST_CHECK(path_node != nullptr, "Import path is ConstPathNode");
-    TEST_CHECK(path_node && path_node->value == "./test.nix",
-               "Import path value is './test.nix'");
+    TEST_CHECK(path_node && path_node->value == "./test.nix", "Import path value is './test.nix'");
   }
 }
 
@@ -223,8 +230,7 @@ void test_import_with_lookup_path() {
   if (loaded_import && loaded_import->path) {
     auto* lookup_node = loaded_import->path->get_if<ConstLookupPathNode>();
     TEST_CHECK(lookup_node != nullptr, "Import path is ConstLookupPathNode");
-    TEST_CHECK(lookup_node && lookup_node->value == "nixpkgs",
-               "Lookup path value is 'nixpkgs'");
+    TEST_CHECK(lookup_node && lookup_node->value == "nixpkgs", "Lookup path value is 'nixpkgs'");
   }
 }
 
@@ -262,8 +268,7 @@ void test_float_node() {
 
   auto* loaded_float = loaded.entry->get_if<ConstFloatNode>();
   TEST_CHECK(loaded_float != nullptr, "Deserialized node is ConstFloatNode");
-  TEST_CHECK(loaded_float && loaded_float->value > 3.14 &&
-                 loaded_float->value < 3.15,
+  TEST_CHECK(loaded_float && loaded_float->value > 3.14 && loaded_float->value < 3.15,
              "Float value is approximately 3.14159");
 }