ggen 5.0.0

    Checking num-traits v0.2.19
    Checking rand_chacha v0.9.0
    Checking hyper v1.7.0
    Checking tower v0.5.2
    Checking rustls v0.23.32
    Checking tokio-stream v0.1.17
    Checking rand_chacha v0.3.1
    Checking prost v0.14.1
    Checking h2 v0.3.27
    Checking oxrocksdb-sys v0.5.1
    Checking core-foundation v0.10.1
    Checking serde_with v3.15.0
    Checking prost v0.11.9
    Checking half v2.7.0
    Checking plotters-backend v0.3.7
    Checking ciborium-io v0.2.2
    Checking rusty-fork v0.3.1
    Checking rand v0.8.5
    Checking rand v0.9.2
    Checking plotters-svg v0.3.7
    Checking rayon v1.11.0
    Checking prost-types v0.14.1
    Checking ciborium-ll v0.2.2
    Checking security-framework v3.5.1
    Checking parse-display v0.9.1
    Checking astral-tokio-tar v0.5.6
    Checking chrono v0.4.42
    Checking num-integer v0.1.46
    Checking tower-http v0.6.6
    Checking axum v0.8.6
    Checking hyper-util v0.1.17
    Checking rust_decimal v1.38.0
    Checking ordered-float v4.6.0
    Checking oxrdf v0.3.1
    Checking tower v0.4.13
    Checking num-bigint v0.4.6
    Checking num-iter v0.1.45
    Checking opentelemetry_sdk v0.21.2
    Checking num-complex v0.4.6
    Checking ulid v1.2.1
    Checking docker_credential v1.3.2
    Checking itertools v0.13.0
    Checking rustls-native-certs v0.8.2
    Checking console v0.15.11
    Checking chrono-tz v0.9.0
    Checking spargebra v0.4.1
    Checking sparesults v0.3.1
    Checking oxrdfxml v0.2.1
    Checking oxttl v0.2.1
    Checking oxjsonld v0.2.1
    Checking hyper v0.14.32
    Checking slog-term v2.9.2
    Checking similar v2.7.0
    Checking num-rational v0.4.2
    Checking hyper-tls v0.6.0
    Checking hyper-timeout v0.5.2
    Checking tokio-rustls v0.26.4
    Checking ureq v3.1.2
    Checking hyperlocal v0.9.1
    Checking cast v0.3.0
    Checking termtree v0.5.1
    Checking proptest v1.8.0
    Checking tracing-opentelemetry v0.22.0
    Checking num v0.4.3
    Checking oxrdfio v0.2.1
    Checking fake v3.1.0
    Checking insta v1.43.2
    Checking hyper-rustls v0.27.7
    Checking ciborium v0.2.2
    Checking criterion-plot v0.6.0
    Checking plotters v0.3.7
    Checking sparopt v0.3.1
    Checking ahash v0.8.12
    Checking predicates-tree v1.0.12
    Checking predicates v3.1.3
    Checking tonic v0.14.2
    Checking tinytemplate v1.2.1
    Checking downcast v0.11.0
    Checking reqwest v0.12.23
    Checking anes v0.1.6
    Checking oorandom v11.1.5
    Checking fragile v2.0.1
    Checking tera v1.20.0
    Checking spareval v0.2.1
    Checking hyper-timeout v0.4.1
    Checking axum v0.6.20
    Checking criterion v0.7.0
    Checking mockall v0.13.1
    Checking tonic-prost v0.14.2
    Checking iri_s v0.1.117
    Checking bollard-buildkit-proto v0.7.0
    Checking prefixmap v0.1.118
    Checking mie v0.1.118
    Checking srdf v0.1.118
    Checking oxigraph v0.5.1
    Checking ggen-utils v3.2.0 (/Users/sac/ggen/crates/ggen-utils)
    Checking tonic v0.9.2
    Checking bollard-stubs v1.49.1-rc.28.4.0
    Checking shacl_ast v0.1.118
    Checking sparql_service v0.1.118
    Checking shacl_rdf v0.1.116
    Checking opentelemetry-proto v0.4.0
    Checking opentelemetry-otlp v0.14.0
    Checking shacl_ir v0.1.118
    Checking shacl_validation v0.1.118
    Checking ggen-core v3.2.0 (/Users/sac/ggen/crates/ggen-core)
    Checking bollard v0.19.3
    Checking testcontainers v0.25.2
    Checking chicago-tdd-tools v1.4.0
warning: unexpected `cfg` condition value: `testcontainers`
 --> crates/ggen-core/tests/production_validation.rs:1:8
  |
1 | #![cfg(feature = "testcontainers")]
  |        ^^^^^^^^^^^^^^^^^^^^^^^^^^
  |
  = note: expected values for `feature` are: `default`, `docker`, `dx`, `live-llm-tests`, and `proptest`
  = help: consider adding `testcontainers` as a feature in `Cargo.toml`
  = note: see <https://doc.rust-lang.org/nightly/rustc/check-cfg/cargo-specifics.html> for more information about checking conditional configuration
  = note: `#[warn(unexpected_cfgs)]` on by default

warning: unused imports: `RegistryClient` and `SearchParams`
 --> crates/ggen-core/benches/marketplace_benchmarks.rs:5:19
  |
5 |     PackMetadata, RegistryClient, RegistryIndex, SearchParams, VersionMetadata,
  |                   ^^^^^^^^^^^^^^                 ^^^^^^^^^^^^
  |
  = note: `#[warn(unused_imports)]` on by default

warning: unused import: `tempfile::TempDir`
 --> crates/ggen-core/benches/marketplace_benchmarks.rs:8:5
  |
8 | use tempfile::TempDir;
  |     ^^^^^^^^^^^^^^^^^

warning: unused import: `url::Url`
 --> crates/ggen-core/benches/marketplace_benchmarks.rs:9:5
  |
9 | use url::Url;
  |     ^^^^^^^^

warning: unused import: `Path`
  --> crates/ggen-core/tests/london_tdd_examples.rs:10:17
   |
10 | use std::path::{Path, PathBuf};
   |                 ^^^^
   |
   = note: `#[warn(unused_imports)]` on by default

warning: `ggen-core` (test "production_validation") generated 1 warning
warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
 --> crates/ggen-core/benches/marketplace_benchmarks.rs:3:17
  |
3 | use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion};
  |                 ^^^^^^^^^
  |
  = note: `#[warn(deprecated)]` on by default

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
  --> crates/ggen-core/benches/marketplace_benchmarks.rs:67:45
   |
67 |             b.iter(|| serde_json::to_string(black_box(&index)).unwrap());
   |                                             ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
  --> crates/ggen-core/benches/marketplace_benchmarks.rs:82:61
   |
82 |             b.iter(|| serde_json::from_str::<RegistryIndex>(black_box(&json)).unwrap());
   |                                                             ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
  --> crates/ggen-core/benches/marketplace_benchmarks.rs:97:29
   |
97 |                 let query = black_box("rust");
   |                             ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/marketplace_benchmarks.rs:119:29
    |
119 |                 let query = black_box("rust");
    |                             ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/marketplace_benchmarks.rs:120:32
    |
120 |                 let category = black_box("development");
    |                                ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/marketplace_benchmarks.rs:158:42
    |
158 |         b.iter(|| semver::Version::parse(black_box("1.2.3")).unwrap());
    |                                          ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/marketplace_benchmarks.rs:162:19
    |
162 |         b.iter(|| black_box(&v1) < black_box(&v2));
    |                   ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/marketplace_benchmarks.rs:162:36
    |
162 |         b.iter(|| black_box(&v1) < black_box(&v2));
    |                                    ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/marketplace_benchmarks.rs:166:19
    |
166 |         b.iter(|| black_box(&v1) < black_box(&v3));
    |                   ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/marketplace_benchmarks.rs:166:36
    |
166 |         b.iter(|| black_box(&v1) < black_box(&v3));
    |                                    ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/marketplace_benchmarks.rs:170:19
    |
170 |         b.iter(|| black_box(&v1).to_string());
    |                   ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/marketplace_benchmarks.rs:185:33
    |
185 |                 index.packs.get(black_box(&id))
    |                                 ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/marketplace_benchmarks.rs:268:40
    |
268 |         b.iter(|| create_mock_registry(black_box(1000)));
    |                                        ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/marketplace_benchmarks.rs:272:40
    |
272 |         b.iter(|| create_mock_registry(black_box(10000)));
    |                                        ^^^^^^^^^

warning: unused import: `std::collections::BTreeMap`
 --> crates/ggen-core/benches/template_benchmarks.rs:5:5
  |
5 | use std::collections::BTreeMap;
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
  |
  = note: `#[warn(unused_imports)]` on by default

warning: unused import: `std::fs`
 --> crates/ggen-core/benches/template_benchmarks.rs:6:5
  |
6 | use std::fs;
  |     ^^^^^^^

warning: unused import: `std::io::Write`
 --> crates/ggen-core/benches/template_benchmarks.rs:7:5
  |
7 | use std::io::Write;
  |     ^^^^^^^^^^^^^^

warning: unused import: `NamedTempFile`
 --> crates/ggen-core/benches/template_benchmarks.rs:8:16
  |
8 | use tempfile::{NamedTempFile, TempDir};
  |                ^^^^^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
 --> crates/ggen-core/benches/template_benchmarks.rs:1:17
  |
1 | use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
  |                 ^^^^^^^^^
  |
  = note: `#[warn(deprecated)]` on by default

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
  --> crates/ggen-core/benches/template_benchmarks.rs:85:46
   |
85 |                 let result = Template::parse(black_box(&template_str));
   |                                              ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
  --> crates/ggen-core/benches/template_benchmarks.rs:86:17
   |
86 |                 black_box(result)
   |                 ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_benchmarks.rs:101:50
    |
101 |                     let result = Template::parse(black_box(tmpl_str));
    |                                                  ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_benchmarks.rs:102:21
    |
102 |                     black_box(result)
    |                     ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_benchmarks.rs:131:17
    |
131 |                 black_box(result)
    |                 ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_benchmarks.rs:166:21
    |
166 |                     black_box(result)
    |                     ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_benchmarks.rs:198:21
    |
198 |                     black_box(result)
    |                     ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_benchmarks.rs:257:21
    |
257 |                     black_box(result)
    |                     ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_benchmarks.rs:313:25
    |
313 |                         black_box(_rendered);
    |                         ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_benchmarks.rs:339:21
    |
339 |                     black_box(results);
    |                     ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_benchmarks.rs:360:44
    |
360 |             let template = Template::parse(black_box(&template_str));
    |                                            ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_benchmarks.rs:361:13
    |
361 |             black_box(template)
    |             ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_benchmarks.rs:371:13
    |
371 |             black_box(cloned)
    |             ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_benchmarks.rs:394:13
    |
394 |             black_box(templates);
    |             ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_benchmarks.rs:411:17
    |
411 |                 black_box(rendered);
    |                 ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_benchmarks.rs:442:13
    |
442 |             black_box(rendered);
    |             ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_benchmarks.rs:461:13
    |
461 |             black_box(rendered);
    |             ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_benchmarks.rs:495:44
    |
495 |             let template = Template::parse(black_box(&template_with_freeze));
    |                                            ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_benchmarks.rs:496:13
    |
496 |             black_box(template)
    |             ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_benchmarks.rs:504:17
    |
504 |                 black_box(&template_with_freeze),
    |                 ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_benchmarks.rs:508:13
    |
508 |             black_box(template)
    |             ^^^^^^^^^

error[E0432]: unresolved import `anyhow`
  --> crates/ggen-core/tests/rdf_rendering_e2e.rs:29:5
   |
29 | use anyhow::Result;
   |     ^^^^^^ use of unresolved module or unlinked crate `anyhow`
   |
   = help: if you wanted to use a crate named `anyhow`, use `cargo add anyhow` to add it to your `Cargo.toml`

warning: fields `stdout`, `stderr`, and `success` are never read
   --> crates/ggen-core/tests/lifecycle_bdd.rs:159:5
    |
158 | struct CommandOutput {
    |        ------------- fields in this struct
159 |     stdout: String,
    |     ^^^^^^
160 |     stderr: String,
    |     ^^^^^^
161 |     success: bool,
    |     ^^^^^^^
    |
    = note: `CommandOutput` has a derived impl for the trait `Clone`, but this is intentionally ignored during dead code analysis
    = note: `#[warn(dead_code)]` on by default

warning: unused import: `std::path::PathBuf`
 --> crates/ggen-core/benches/lifecycle_benchmarks.rs:6:5
  |
6 | use std::path::PathBuf;
  |     ^^^^^^^^^^^^^^^^^^
  |
  = note: `#[warn(unused_imports)]` on by default

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
 --> crates/ggen-core/benches/lifecycle_benchmarks.rs:1:17
  |
1 | use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
  |                 ^^^^^^^^^
  |
  = note: `#[warn(deprecated)]` on by default

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/lifecycle_benchmarks.rs:156:25
    |
156 |                         black_box(cache_key(phase, &cmds, &env_vars, &[]));
    |                         ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/lifecycle_benchmarks.rs:183:13
    |
183 |             black_box(ggen_core::lifecycle::cache::is_cache_valid(
    |             ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/lifecycle_benchmarks.rs:191:13
    |
191 |             black_box(ggen_core::lifecycle::cache::is_cache_valid(
    |             ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/lifecycle_benchmarks.rs:214:13
    |
214 |             black_box(keys);
    |             ^^^^^^^^^

error[E0616]: field `tera` of struct `Pipeline` is private
   --> crates/ggen-core/benches/template_benchmarks.rs:129:41
    |
129 |                 let mut tera = pipeline.tera.clone();
    |                                         ^^^^ private field

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/lifecycle_benchmarks.rs:442:21
    |
442 |                     black_box(load_state(&state_path).unwrap());
    |                     ^^^^^^^^^

error[E0616]: field `tera` of struct `Pipeline` is private
   --> crates/ggen-core/benches/template_benchmarks.rs:163:45
    |
163 |                     let mut tera = pipeline.tera.clone();
    |                                             ^^^^ private field

error[E0616]: field `tera` of struct `Pipeline` is private
   --> crates/ggen-core/benches/template_benchmarks.rs:195:45
    |
195 |                     let mut tera = pipeline.tera.clone();
    |                                             ^^^^ private field

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/lifecycle_benchmarks.rs:474:13
    |
474 |             black_box(metadata.len());
    |             ^^^^^^^^^

error[E0616]: field `tera` of struct `Pipeline` is private
   --> crates/ggen-core/benches/template_benchmarks.rs:254:45
    |
254 |                     let mut tera = pipeline.tera.clone();
    |                                             ^^^^ private field

error[E0616]: field `tera` of struct `Pipeline` is private
   --> crates/ggen-core/benches/template_benchmarks.rs:310:49
    |
310 |                         let mut tera = pipeline.tera.clone();
    |                                                 ^^^^ private field

warning: unused import: `Throughput`
  --> crates/ggen-core/benches/template_generation.rs:23:85
   |
23 | use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
   |                                                                                     ^^^^^^^^^^
   |
   = note: `#[warn(unused_imports)]` on by default

warning: unused import: `std::collections::HashMap`
  --> crates/ggen-core/benches/template_generation.rs:25:5
   |
25 | use std::collections::HashMap;
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^

error[E0432]: unresolved import `anyhow`
  --> crates/ggen-core/tests/template_rdf_api_tests.rs:14:5
   |
14 | use anyhow::Result;
   |     ^^^^^^ use of unresolved module or unlinked crate `anyhow`
   |
   = help: if you wanted to use a crate named `anyhow`, use `cargo add anyhow` to add it to your `Cargo.toml`

error[E0616]: field `tera` of struct `Pipeline` is private
   --> crates/ggen-core/benches/template_benchmarks.rs:333:53
    |
333 | ...                   let mut tera = pipeline.tera.clone();
    |                                               ^^^^ private field

error[E0616]: field `tera` of struct `Pipeline` is private
   --> crates/ggen-core/benches/template_benchmarks.rs:408:41
    |
408 |                 let mut tera = pipeline.tera.clone();
    |                                         ^^^^ private field

warning: unused import: `std::fs`
  --> crates/ggen-core/tests/template_rdf_api_tests.rs:16:5
   |
16 | use std::fs;
   |     ^^^^^^^
   |
   = note: `#[warn(unused_imports)]` on by default

warning: unused import: `TempDir`
  --> crates/ggen-core/tests/template_rdf_api_tests.rs:19:31
   |
19 | use tempfile::{NamedTempFile, TempDir};
   |                               ^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
  --> crates/ggen-core/benches/template_generation.rs:23:17
   |
23 | use criterion::{black_box, criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
   |                 ^^^^^^^^^
   |
   = note: `#[warn(deprecated)]` on by default

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_generation.rs:224:60
    |
224 |                         let mut template = Template::parse(black_box(&template_str)).unwrap();
    |                                                            ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_generation.rs:244:25
    |
244 |                         black_box(_output);
    |                         ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_generation.rs:263:56
    |
263 |                     let mut template = Template::parse(black_box(&template_str)).unwrap();
    |                                                        ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_generation.rs:275:21
    |
275 |                     black_box(output)
    |                     ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_generation.rs:306:52
    |
306 |                 let mut template = Template::parse(black_box(&template_str)).unwrap();
    |                                                    ^^^^^^^^^

error[E0063]: missing field `phase_hooks` in initializer of `Hooks`
   --> crates/ggen-core/benches/clnrm_benchmarks.rs:259:14
    |
259 |         Some(ggen_core::lifecycle::Hooks {
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^ missing `phase_hooks`

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_generation.rs:327:17
    |
327 |                 black_box(_output);
    |                 ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_generation.rs:344:48
    |
344 |             let mut template = Template::parse(black_box(&template_str)).unwrap();
    |                                                ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_generation.rs:356:13
    |
356 |             black_box(output)
    |             ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_generation.rs:369:52
    |
369 |                 let mut template = Template::parse(black_box(&template_str)).unwrap();
    |                                                    ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_generation.rs:401:17
    |
401 |                 black_box(_output);
    |                 ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_generation.rs:462:56
    |
462 |                     let mut template = Template::parse(black_box(template_str)).unwrap();
    |                                                        ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_generation.rs:477:17
    |
477 |                 black_box(outputs);
    |                 ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_generation.rs:494:52
    |
494 |                 let mut template = Template::parse(black_box(template_str)).unwrap();
    |                                                    ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_generation.rs:509:13
    |
509 |             black_box(outputs)
    |             ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_generation.rs:540:13
    |
540 |             black_box(outputs)
    |             ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_generation.rs:567:39
    |
567 |             let results = graph.query(black_box(query)).unwrap();
    |                                       ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_generation.rs:568:13
    |
568 |             black_box(results)
    |             ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_generation.rs:585:39
    |
585 |             let results = graph.query(black_box(query)).unwrap();
    |                                       ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_generation.rs:586:13
    |
586 |             black_box(results)
    |             ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_generation.rs:594:39
    |
594 |             let results = graph.query(black_box(query)).unwrap();
    |                                       ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_generation.rs:595:13
    |
595 |             black_box(results)
    |             ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_generation.rs:608:17
    |
608 |                 black_box(results);
    |                 ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_generation.rs:622:39
    |
622 |             let results = graph.query(black_box(query)).unwrap();
    |                                       ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_generation.rs:623:13
    |
623 |             black_box(results)
    |             ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_generation.rs:776:17
    |
776 |                 black_box(generated_files);
    |                 ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_generation.rs:815:13
    |
815 |             black_box(outputs)
    |             ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_generation.rs:836:48
    |
836 |             let mut template = Template::parse(black_box(&template_str)).unwrap();
    |                                                ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_generation.rs:852:13
    |
852 |             black_box(output)
    |             ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_generation.rs:863:48
    |
863 |             let mut template = Template::parse(black_box(&template_str)).unwrap();
    |                                                ^^^^^^^^^

warning: use of deprecated function `criterion::black_box`: use `std::hint::black_box()` instead
   --> crates/ggen-core/benches/template_generation.rs:875:13
    |
875 |             black_box(output)
    |             ^^^^^^^^^

error[E0432]: unresolved import `anyhow`
  --> crates/ggen-core/tests/integration/clnrm_harness.rs:30:5
   |
30 | use anyhow::{Context, Result};
   |     ^^^^^^ use of unresolved module or unlinked crate `anyhow`
   |
   = help: if you wanted to use a crate named `anyhow`, use `cargo add anyhow` to add it to your `Cargo.toml`

error[E0432]: unresolved import `anyhow`
 --> crates/ggen-core/tests/integration/clnrm_harness_examples.rs:6:5
  |
6 | use anyhow::Result;
  |     ^^^^^^ use of unresolved module or unlinked crate `anyhow`
  |
  = help: if you wanted to use a crate named `anyhow`, use `cargo add anyhow` to add it to your `Cargo.toml`

error[E0432]: unresolved import `anyhow`
 --> crates/ggen-core/tests/integration/multi_node_scenario.rs:5:5
  |
5 | use anyhow::Result;
  |     ^^^^^^ use of unresolved module or unlinked crate `anyhow`
  |
  = help: if you wanted to use a crate named `anyhow`, use `cargo add anyhow` to add it to your `Cargo.toml`

error[E0432]: unresolved import `anyhow`
 --> crates/ggen-core/tests/integration/lifecycle_clnrm_tests.rs:9:5
  |
9 | use anyhow::{Context, Result};
  |     ^^^^^^ use of unresolved module or unlinked crate `anyhow`
  |
  = help: if you wanted to use a crate named `anyhow`, use `cargo add anyhow` to add it to your `Cargo.toml`

error[E0432]: unresolved import `anyhow`
 --> crates/ggen-core/tests/security/signature_verification.rs:3:5
  |
3 | use anyhow::Result;
  |     ^^^^^^ use of unresolved module or unlinked crate `anyhow`
  |
  = help: if you wanted to use a crate named `anyhow`, use `cargo add anyhow` to add it to your `Cargo.toml`

error[E0432]: unresolved import `anyhow`
  --> crates/ggen-core/tests/integration/marketplace_validation.rs:18:5
   |
18 | use anyhow::Result;
   |     ^^^^^^ use of unresolved module or unlinked crate `anyhow`
   |
   = help: if you wanted to use a crate named `anyhow`, use `cargo add anyhow` to add it to your `Cargo.toml`

error[E0432]: unresolved import `anyhow`
  --> crates/ggen-core/tests/integration/lifecycle_tests.rs:12:5
   |
12 | use anyhow::{Context as AnyhowContext, Result};
   |     ^^^^^^ use of unresolved module or unlinked crate `anyhow`
   |
   = help: if you wanted to use a crate named `anyhow`, use `cargo add anyhow` to add it to your `Cargo.toml`

error[E0433]: failed to resolve: use of unresolved module or unlinked crate `anyhow`
   --> crates/ggen-core/tests/integration/multi_node_scenario.rs:333:22
    |
333 |         .map_err(|_| anyhow::anyhow!("Failed to create file URL"))?;
    |                      ^^^^^^ use of unresolved module or unlinked crate `anyhow`

error[E0433]: failed to resolve: use of unresolved module or unlinked crate `anyhow`
   --> crates/ggen-core/tests/integration/multi_node_scenario.rs:325:22
    |
325 |         .map_err(|_| anyhow::anyhow!("Failed to create file URL"))?;
    |                      ^^^^^^ use of unresolved module or unlinked crate `anyhow`

error[E0433]: failed to resolve: use of unresolved module or unlinked crate `anyhow`
   --> crates/ggen-core/tests/integration/multi_node_scenario.rs:186:22
    |
186 |         .map_err(|_| anyhow::anyhow!("Failed to create file URL"))?;
    |                      ^^^^^^ use of unresolved module or unlinked crate `anyhow`

error[E0433]: failed to resolve: use of unresolved module or unlinked crate `anyhow`
   --> crates/ggen-core/tests/integration/multi_node_scenario.rs:110:22
    |
110 |         .map_err(|_| anyhow::anyhow!("Failed to create file URL"))?;
    |                      ^^^^^^ use of unresolved module or unlinked crate `anyhow`

error[E0433]: failed to resolve: use of unresolved module or unlinked crate `anyhow`
   --> crates/ggen-core/tests/integration/multi_node_scenario.rs:106:22
    |
106 |         .map_err(|_| anyhow::anyhow!("Failed to create file URL"))?;
    |                      ^^^^^^ use of unresolved module or unlinked crate `anyhow`

error[E0433]: failed to resolve: use of unresolved module or unlinked crate `anyhow`
   --> crates/ggen-core/tests/integration/clnrm_harness.rs:364:22
    |
364 |             _ => Err(anyhow::anyhow!("Unknown lifecycle phase: {}", phase)),
    |                      ^^^^^^ use of unresolved module or unlinked crate `anyhow`

error[E0433]: failed to resolve: use of unresolved module or unlinked crate `anyhow`
   --> crates/ggen-core/tests/integration/clnrm_harness.rs:291:28
    |
291 |             .ok_or_else(|| anyhow::anyhow!("Package not found: {}", id))
    |                            ^^^^^^ use of unresolved module or unlinked crate `anyhow`

error[E0433]: failed to resolve: use of unresolved module or unlinked crate `anyhow`
   --> crates/ggen-core/tests/integration/clnrm_harness.rs:170:26
    |
170 |             .map_err(|_| anyhow::anyhow!("Failed to create file URL from path"))?;
    |                          ^^^^^^ use of unresolved module or unlinked crate `anyhow`

error[E0433]: failed to resolve: use of unresolved module or unlinked crate `anyhow`
  --> crates/ggen-core/tests/integration/lifecycle_clnrm_tests.rs:86:13
   |
86 |             anyhow::bail!("Phase '{}' failed: {}", phase, stderr);
   |             ^^^^^^ use of unresolved module or unlinked crate `anyhow`

error[E0433]: failed to resolve: use of unresolved module or unlinked crate `anyhow`
  --> crates/ggen-core/tests/integration/marketplace_validation.rs:85:22
   |
85 |         .map_err(|_| anyhow::anyhow!("Failed to create file URL"))?;
   |                      ^^^^^^ use of unresolved module or unlinked crate `anyhow`

error[E0616]: field `tera` of struct `Pipeline` is private
   --> crates/ggen-core/benches/template_benchmarks.rs:439:37
    |
439 |             let mut tera = pipeline.tera.clone();
    |                                     ^^^^ private field

error[E0616]: field `tera` of struct `Pipeline` is private
   --> crates/ggen-core/benches/template_benchmarks.rs:455:37
    |
455 |             let mut tera = pipeline.tera.clone();
    |                                     ^^^^ private field

error[E0432]: unresolved import `anyhow`
 --> crates/ggen-core/tests/template_comprehensive_test.rs:6:5
  |
6 | use anyhow::Result;
  |     ^^^^^^ use of unresolved module or unlinked crate `anyhow`
  |
  = help: if you wanted to use a crate named `anyhow`, use `cargo add anyhow` to add it to your `Cargo.toml`

error[E0433]: failed to resolve: use of unresolved module or unlinked crate `anyhow`
   --> crates/ggen-core/tests/template_comprehensive_test.rs:462:32
    |
462 |                 .ok_or_else(|| anyhow::anyhow!("Output path has no parent"))?,
    |                                ^^^^^^ use of unresolved module or unlinked crate `anyhow`

error[E0433]: failed to resolve: use of unresolved module or unlinked crate `anyhow`
   --> crates/ggen-core/tests/template_comprehensive_test.rs:457:32
    |
457 |                 .ok_or_else(|| anyhow::anyhow!("Template must have 'to' field"))?,
    |                                ^^^^^^ use of unresolved module or unlinked crate `anyhow`

error[E0433]: failed to resolve: use of unresolved module or unlinked crate `anyhow`
   --> crates/ggen-core/tests/template_comprehensive_test.rs:416:28
    |
416 |             .ok_or_else(|| anyhow::anyhow!("Output path has no parent"))?,
    |                            ^^^^^^ use of unresolved module or unlinked crate `anyhow`

error[E0433]: failed to resolve: use of unresolved module or unlinked crate `anyhow`
   --> crates/ggen-core/tests/template_comprehensive_test.rs:411:28
    |
411 |             .ok_or_else(|| anyhow::anyhow!("Template must have 'to' field"))?,
    |                            ^^^^^^ use of unresolved module or unlinked crate `anyhow`

error[E0433]: failed to resolve: use of unresolved module or unlinked crate `anyhow`
   --> crates/ggen-core/tests/template_comprehensive_test.rs:383:28
    |
383 |             .ok_or_else(|| anyhow::anyhow!("Output path has no parent"))?,
    |                            ^^^^^^ use of unresolved module or unlinked crate `anyhow`

error[E0433]: failed to resolve: use of unresolved module or unlinked crate `anyhow`
   --> crates/ggen-core/tests/template_comprehensive_test.rs:378:28
    |
378 |             .ok_or_else(|| anyhow::anyhow!("Template must have 'to' field"))?,
    |                            ^^^^^^ use of unresolved module or unlinked crate `anyhow`

error[E0433]: failed to resolve: use of unresolved module or unlinked crate `anyhow`
   --> crates/ggen-core/tests/template_comprehensive_test.rs:348:28
    |
348 |             .ok_or_else(|| anyhow::anyhow!("Output path has no parent"))?,
    |                            ^^^^^^ use of unresolved module or unlinked crate `anyhow`

error[E0433]: failed to resolve: use of unresolved module or unlinked crate `anyhow`
   --> crates/ggen-core/tests/template_comprehensive_test.rs:343:28
    |
343 |             .ok_or_else(|| anyhow::anyhow!("Template must have 'to' field"))?,
    |                            ^^^^^^ use of unresolved module or unlinked crate `anyhow`

error[E0433]: failed to resolve: use of unresolved module or unlinked crate `anyhow`
  --> crates/ggen-core/tests/template_comprehensive_test.rs:33:22
   |
33 |         .map_err(|e| anyhow::anyhow!("Failed to load fixture '{}': {}", fixture_path.display(), e))
   |                      ^^^^^^ use of unresolved module or unlinked crate `anyhow`

warning: unused import: `std::collections::BTreeMap`
 --> crates/ggen-core/tests/template_comprehensive_test.rs:8:5
  |
8 | use std::collections::BTreeMap;
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
  |
  = note: `#[warn(unused_imports)]` on by default

error: cannot find macro `test` in this scope
   --> crates/ggen-core/tests/unit/version_resolution.rs:148:1
    |
148 | test!(test_version_prerelease_ordering, {
    | ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
  3 + use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/tests/unit/version_resolution.rs:129:1
    |
129 | test!(test_version_sorting, {
    | ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
  3 + use chicago_tdd_tools::test;
    |

error: cannot find macro `async_test_with_timeout` in this scope
  --> crates/ggen-core/tests/test_marketplace_local.rs:68:1
   |
68 | async_test_with_timeout!(test_advanced_search_from_local_registry, 30, async {
   | ^^^^^^^^^^^^^^^^^^^^^^^
   |
help: consider importing this macro
   |
 1 + use chicago_tdd_tools::async_test_with_timeout;
   |

warning: unused variable: `vars`
  --> crates/ggen-core/benches/template_generation.rs:39:9
   |
39 |     let vars: Vec<String> = (0..var_count)
   |         ^^^^ help: if this is intentional, prefix it with an underscore: `_vars`
   |
   = note: `#[warn(unused_variables)]` on by default

error: cannot find macro `test` in this scope
   --> crates/ggen-core/tests/unit/version_resolution.rs:116:1
    |
116 | test!(test_version_zero_versions, {
    | ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
  3 + use chicago_tdd_tools::test;
    |

error: cannot find macro `async_test_with_timeout` in this scope
  --> crates/ggen-core/tests/test_marketplace_local.rs:47:1
   |
47 | async_test_with_timeout!(test_search_from_local_registry, 30, async {
   | ^^^^^^^^^^^^^^^^^^^^^^^
   |
help: consider importing this macro
   |
 1 + use chicago_tdd_tools::async_test_with_timeout;
   |

error[E0063]: missing field `phase_hooks` in initializer of `Hooks`
   --> crates/ggen-core/benches/lifecycle_benchmarks.rs:274:21
    |
274 |         hooks: Some(ggen_core::lifecycle::Hooks {
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ missing `phase_hooks`

error: cannot find macro `async_test_with_timeout` in this scope
  --> crates/ggen-core/tests/test_marketplace_local.rs:25:1
   |
25 | async_test_with_timeout!(test_resolve_from_local_registry, 30, async {
   | ^^^^^^^^^^^^^^^^^^^^^^^
   |
help: consider importing this macro
   |
 1 + use chicago_tdd_tools::async_test_with_timeout;
   |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/tests/unit/version_resolution.rs:106:1
    |
106 | test!(test_version_patch_bumps, {
    | ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
  3 + use chicago_tdd_tools::test;
    |

warning: `ggen-core` (test "lifecycle_bdd") generated 1 warning
error: cannot find macro `async_test_with_timeout` in this scope
 --> crates/ggen-core/tests/test_marketplace_local.rs:6:1
  |
6 | async_test_with_timeout!(test_local_registry_index, 30, async {
  | ^^^^^^^^^^^^^^^^^^^^^^^
  |
help: consider importing this macro
  |
1 + use chicago_tdd_tools::async_test_with_timeout;
  |

error: cannot find macro `test` in this scope
  --> crates/ggen-core/tests/unit/version_resolution.rs:96:1
   |
96 | test!(test_version_minor_bumps, {
   | ^^^^
   |
   = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
   |
 3 + use chicago_tdd_tools::test;
   |

warning: unused import: `chicago_tdd_tools::prelude::*`
 --> crates/ggen-core/tests/test_marketplace_local.rs:1:5
  |
1 | use chicago_tdd_tools::prelude::*;
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  |
  = note: `#[warn(unused_imports)]` on by default

warning: unused import: `ggen_core::RegistryClient`
 --> crates/ggen-core/tests/test_marketplace_local.rs:2:5
  |
2 | use ggen_core::RegistryClient;
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^

warning: unused import: `std::env`
 --> crates/ggen-core/tests/test_marketplace_local.rs:3:5
  |
3 | use std::env;
  |     ^^^^^^^^

warning: unused import: `std::path::PathBuf`
 --> crates/ggen-core/tests/test_marketplace_local.rs:4:5
  |
4 | use std::path::PathBuf;
  |     ^^^^^^^^^^^^^^^^^^

error: cannot find macro `test` in this scope
  --> crates/ggen-core/tests/unit/version_resolution.rs:84:1
   |
84 | test!(test_version_major_bumps, {
   | ^^^^
   |
   = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
   |
 3 + use chicago_tdd_tools::test;
   |

For more information about this error, try `rustc --explain E0432`.
error: cannot find macro `test` in this scope
  --> crates/ggen-core/tests/unit/version_resolution.rs:77:1
   |
77 | test!(test_version_leading_zeros, {
   | ^^^^
   |
   = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
   |
 3 + use chicago_tdd_tools::test;
   |

error: cannot find macro `test` in this scope
  --> crates/ggen-core/tests/unit/version_resolution.rs:68:1
   |
68 | test!(test_version_invalid, {
   | ^^^^
   |
   = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
   |
 3 + use chicago_tdd_tools::test;
   |

error: cannot find macro `test` in this scope
  --> crates/ggen-core/tests/unit/version_resolution.rs:58:1
   |
58 | test!(test_version_build_metadata, {
   | ^^^^
   |
   = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
   |
 3 + use chicago_tdd_tools::test;
   |

error: cannot find macro `test` in this scope
  --> crates/ggen-core/tests/unit/version_resolution.rs:39:1
   |
39 | test!(test_version_prerelease, {
   | ^^^^
   |
   = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
   |
 3 + use chicago_tdd_tools::test;
   |

error: cannot find macro `test` in this scope
  --> crates/ggen-core/tests/chicago_tdd_smoke_test.rs:87:1
   |
87 | test!(test_boolean_logic, {
   | ^^^^
   |
   = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
   |
 8 + use chicago_tdd_tools::test;
   |

For more information about this error, try `rustc --explain E0616`.
warning: unused variable: `pipeline`
   --> crates/ggen-core/benches/template_generation.rs:260:21
    |
260 |                 let pipeline = Pipeline::new().unwrap();
    |                     ^^^^^^^^ help: if this is intentional, prefix it with an underscore: `_pipeline`

error: cannot find macro `test` in this scope
  --> crates/ggen-core/tests/chicago_tdd_smoke_test.rs:68:1
   |
68 | test!(test_numeric_operations, {
   | ^^^^
   |
   = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
   |
 8 + use chicago_tdd_tools::test;
   |

error: cannot find macro `test` in this scope
  --> crates/ggen-core/tests/chicago_tdd_smoke_test.rs:54:1
   |
54 | test!(test_string_operations, {
   | ^^^^
   |
   = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
   |
 8 + use chicago_tdd_tools::test;
   |

error: cannot find macro `test` in this scope
  --> crates/ggen-core/tests/chicago_tdd_smoke_test.rs:42:1
   |
42 | test!(test_core_integration, {
   | ^^^^
   |
   = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
   |
 8 + use chicago_tdd_tools::test;
   |

error: cannot find macro `test` in this scope
  --> crates/ggen-core/tests/unit/version_resolution.rs:30:1
   |
30 | test!(test_version_equality, {
   | ^^^^
   |
   = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
   |
 3 + use chicago_tdd_tools::test;
   |

error: cannot find macro `async_test` in this scope
  --> crates/ggen-core/tests/chicago_tdd_smoke_test.rs:33:1
   |
33 | async_test!(test_async_works, {
   | ^^^^^^^^^^
   |
help: consider importing this macro
   |
 8 + use chicago_tdd_tools::async_test;
   |

error: cannot find macro `test` in this scope
  --> crates/ggen-core/tests/chicago_tdd_smoke_test.rs:20:1
   |
20 | test!(test_with_local_vars, {
   | ^^^^
   |
   = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
   |
 8 + use chicago_tdd_tools::test;
   |

error: cannot find macro `test` in this scope
  --> crates/ggen-core/tests/chicago_tdd_smoke_test.rs:11:1
   |
11 | test!(test_chicago_tdd_works, {
   | ^^^^
   |
   = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
   |
 8 + use chicago_tdd_tools::test;
   |

warning: unused import: `chicago_tdd_tools::prelude::*`
 --> crates/ggen-core/tests/chicago_tdd_smoke_test.rs:8:5
  |
8 | use chicago_tdd_tools::prelude::*;
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  |
  = note: `#[warn(unused_imports)]` on by default

warning: unused variable: `pipeline`
   --> crates/ggen-core/benches/template_generation.rs:341:13
    |
341 |         let pipeline = Pipeline::new().unwrap();
    |             ^^^^^^^^ help: if this is intentional, prefix it with an underscore: `_pipeline`

warning: `ggen-core` (bench "marketplace_benchmarks") generated 18 warnings (run `cargo fix --bench "marketplace_benchmarks"` to apply 3 suggestions)
warning: `ggen-core` (test "test_marketplace_local") generated 4 warnings
error: could not compile `ggen-core` (test "test_marketplace_local") due to 4 previous errors; 4 warnings emitted
warning: build failed, waiting for other jobs to finish...
error: cannot find macro `test` in this scope
  --> crates/ggen-core/tests/unit/version_resolution.rs:16:1
   |
16 | test!(test_version_comparison, {
   | ^^^^
   |
   = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
   |
 3 + use chicago_tdd_tools::test;
   |

warning: `ggen-core` (bench "template_benchmarks") generated 26 warnings
error: could not compile `ggen-core` (bench "template_benchmarks") due to 9 previous errors; 26 warnings emitted
error: cannot find macro `test` in this scope
 --> crates/ggen-core/tests/unit/version_resolution.rs:6:1
  |
6 | test!(test_version_parsing, {
  | ^^^^
  |
  = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
  |
3 + use chicago_tdd_tools::test;
  |

error: could not compile `ggen-core` (test "rdf_rendering_e2e") due to 1 previous error
error: cannot find macro `test` in this scope
   --> crates/ggen-core/tests/unit/search_params.rs:145:1
    |
145 | test!(test_search_params_whitespace, {
    | ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
  3 + use chicago_tdd_tools::test;
    |

warning: variable does not need to be mutable
   --> crates/ggen-core/benches/template_generation.rs:559:9
    |
559 |     let mut graph = Graph::new().unwrap();
    |         ----^^^^^
    |         |
    |         help: remove this `mut`
    |
    = note: `#[warn(unused_mut)]` on by default

For more information about this error, try `rustc --explain E0063`.
error: cannot find macro `test` in this scope
   --> crates/ggen-core/tests/unit/search_params.rs:120:1
    |
120 | test!(test_search_params_limit_boundaries, {
    | ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
  3 + use chicago_tdd_tools::test;
    |

error[E0609]: no field `vars` on type `Frontmatter`
   --> crates/ggen-core/tests/template_comprehensive_test.rs:106:24
    |
106 |         template.front.vars.get("greeting").and_then(|v| v.as_str()),
    |                        ^^^^ unknown field
    |
    = note: available fields are: `to`, `from`, `force`, `unless_exists`, `inject` ... and 21 others

error: cannot find macro `test` in this scope
   --> crates/ggen-core/tests/unit/search_params.rs:103:1
    |
103 | test!(test_search_params_unicode, {
    | ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
  3 + use chicago_tdd_tools::test;
    |

error[E0609]: no field `vars` on type `Frontmatter`
   --> crates/ggen-core/tests/template_comprehensive_test.rs:128:24
    |
128 |         template.front.vars.get("service").and_then(|v| v.as_str()),
    |                        ^^^^ unknown field
    |
    = note: available fields are: `to`, `from`, `force`, `unless_exists`, `inject` ... and 21 others

error[E0609]: no field `vars` on type `Frontmatter`
   --> crates/ggen-core/tests/template_comprehensive_test.rs:132:24
    |
132 |         template.front.vars.get("port").and_then(|v| v.as_str()),
    |                        ^^^^ unknown field
    |
    = note: available fields are: `to`, `from`, `force`, `unless_exists`, `inject` ... and 21 others

error[E0609]: no field `vars` on type `Frontmatter`
   --> crates/ggen-core/tests/template_comprehensive_test.rs:153:20
    |
153 |         tmpl.front.vars.get("name").and_then(|v| v.as_str()),
    |                    ^^^^ unknown field
    |
    = note: available fields are: `to`, `from`, `force`, `unless_exists`, `inject` ... and 21 others

error: cannot find macro `test` in this scope
  --> crates/ggen-core/tests/unit/search_params.rs:78:1
   |
78 | test!(test_search_params_case_sensitivity, {
   | ^^^^
   |
   = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
   |
 3 + use chicago_tdd_tools::test;
   |

error[E0609]: no field `vars` on type `Frontmatter`
   --> crates/ggen-core/tests/template_comprehensive_test.rs:157:20
    |
157 |         tmpl.front.vars.get("age").and_then(|v| v.as_i64()),
    |                    ^^^^ unknown field
    |
    = note: available fields are: `to`, `from`, `force`, `unless_exists`, `inject` ... and 21 others

error[E0609]: no field `vars` on type `Frontmatter`
   --> crates/ggen-core/tests/template_comprehensive_test.rs:175:20
    |
175 |         tmpl.front.vars.get("var0").and_then(|v| v.as_str()),
    |                    ^^^^ unknown field
    |
    = note: available fields are: `to`, `from`, `force`, `unless_exists`, `inject` ... and 21 others

error[E0609]: no field `vars` on type `Frontmatter`
   --> crates/ggen-core/tests/template_comprehensive_test.rs:179:20
    |
179 |         tmpl.front.vars.get("var1").and_then(|v| v.as_str()),
    |                    ^^^^ unknown field
    |
    = note: available fields are: `to`, `from`, `force`, `unless_exists`, `inject` ... and 21 others

error: cannot find macro `test` in this scope
  --> crates/ggen-core/tests/unit/search_params.rs:61:1
   |
61 | test!(test_search_params_special_characters, {
   | ^^^^
   |
   = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
   |
 3 + use chicago_tdd_tools::test;
   |

error[E0609]: no field `vars` on type `Frontmatter`
   --> crates/ggen-core/tests/template_comprehensive_test.rs:183:20
    |
183 |         tmpl.front.vars.get("var2").and_then(|v| v.as_str()),
    |                    ^^^^ unknown field
    |
    = note: available fields are: `to`, `from`, `force`, `unless_exists`, `inject` ... and 21 others

error[E0609]: no field `vars` on type `Frontmatter`
   --> crates/ggen-core/tests/template_comprehensive_test.rs:205:24
    |
205 |         template.front.vars.get("var0").and_then(|v| v.as_str()),
    |                        ^^^^ unknown field
    |
    = note: available fields are: `to`, `from`, `force`, `unless_exists`, `inject` ... and 21 others

error: cannot find macro `test` in this scope
  --> crates/ggen-core/tests/unit/search_params.rs:46:1
   |
46 | test!(test_search_params_empty_query, {
   | ^^^^
   |
   = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
   |
 3 + use chicago_tdd_tools::test;
   |

error[E0609]: no field `vars` on type `Frontmatter`
   --> crates/ggen-core/tests/template_comprehensive_test.rs:225:28
    |
225 |     assert!(template.front.vars.is_empty());
    |                            ^^^^ unknown field
    |
    = note: available fields are: `to`, `from`, `force`, `unless_exists`, `inject` ... and 21 others

warning: `ggen-core` (test "chicago_tdd_smoke_test") generated 1 warning
error: could not compile `ggen-core` (test "chicago_tdd_smoke_test") due to 7 previous errors; 1 warning emitted
error: cannot find macro `test` in this scope
  --> crates/ggen-core/tests/unit/search_params.rs:26:1
   |
26 | test!(test_search_params_minimal, {
   | ^^^^
   |
   = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
   |
 3 + use chicago_tdd_tools::test;
   |

warning: function `create_simple_template` is never used
  --> crates/ggen-core/benches/template_generation.rs:38:4
   |
38 | fn create_simple_template(var_count: usize) -> String {
   |    ^^^^^^^^^^^^^^^^^^^^^^
   |
   = note: `#[warn(dead_code)]` on by default

error: cannot find macro `test` in this scope
 --> crates/ggen-core/tests/unit/search_params.rs:6:1
  |
6 | test!(test_search_params_creation, {
  | ^^^^
  |
  = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
  |
3 + use chicago_tdd_tools::test;
  |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/tests/unit/registry_index.rs:116:1
    |
116 | test!(test_registry_index_all_packs_valid, {
    | ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
  3 + use chicago_tdd_tools::test;
    |

error: could not compile `ggen-core` (bench "clnrm_benchmarks") due to 1 previous error
error: cannot find macro `test` in this scope
   --> crates/ggen-core/tests/unit/registry_index.rs:101:1
    |
101 | test!(test_registry_index_pack_names_unique, {
    | ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
  3 + use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
  --> crates/ggen-core/tests/unit/registry_index.rs:89:1
   |
89 | test!(test_registry_index_large_scale, {
   | ^^^^
   |
   = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
   |
 3 + use chicago_tdd_tools::test;
   |

error: cannot find macro `test` in this scope
  --> crates/ggen-core/tests/unit/registry_index.rs:76:1
   |
76 | test!(test_registry_index_pretty_print, {
   | ^^^^
   |
   = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
   |
 3 + use chicago_tdd_tools::test;
   |

error: cannot find macro `test` in this scope
  --> crates/ggen-core/tests/unit/registry_index.rs:58:1
   |
58 | test!(test_registry_index_serialization_roundtrip, {
   | ^^^^
   |
   = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
   |
 3 + use chicago_tdd_tools::test;
   |

error: cannot find macro `test` in this scope
  --> crates/ggen-core/tests/unit/registry_index.rs:43:1
   |
43 | test!(test_registry_index_iteration, {
   | ^^^^
   |
   = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
   |
 3 + use chicago_tdd_tools::test;
   |

error: cannot find macro `test` in this scope
  --> crates/ggen-core/tests/unit/registry_index.rs:29:1
   |
29 | test!(test_registry_index_lookup, {
   | ^^^^
   |
   = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
   |
 3 + use chicago_tdd_tools::test;
   |

error: cannot find macro `test` in this scope
  --> crates/ggen-core/tests/unit/registry_index.rs:18:1
   |
18 | test!(test_registry_index_empty, {
   | ^^^^
   |
   = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
   |
 3 + use chicago_tdd_tools::test;
   |

warning: `ggen-core` (bench "lifecycle_benchmarks") generated 8 warnings
error: could not compile `ggen-core` (bench "lifecycle_benchmarks") due to 1 previous error; 8 warnings emitted
error: cannot find macro `test` in this scope
 --> crates/ggen-core/tests/unit/registry_index.rs:9:1
  |
9 | test!(test_registry_index_creation, {
  | ^^^^
  |
  = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
  |
3 + use chicago_tdd_tools::test;
  |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/tests/unit/registry_client.rs:238:1
    |
238 | test!(test_boundary_values, {
    | ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
  3 + use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/tests/unit/registry_client.rs:201:1
    |
201 | test!(test_empty_collections, {
    | ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
  3 + use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/tests/unit/registry_client.rs:162:1
    |
162 | test!(test_pack_metadata_optional_fields, {
    | ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
  3 + use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/tests/unit/registry_client.rs:145:1
    |
145 | test!(test_version_metadata_validation, {
    | ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
  3 + use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/tests/unit/registry_client.rs:103:1
    |
103 | test!(test_pack_metadata_validation, {
    | ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
  3 + use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
  --> crates/ggen-core/tests/unit/registry_client.rs:50:1
   |
50 | test!(test_registry_index_serialization, {
   | ^^^^
   |
   = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
   |
 3 + use chicago_tdd_tools::test;
   |

error: cannot find macro `test` in this scope
  --> crates/ggen-core/tests/unit/registry_client.rs:36:1
   |
36 | test!(test_registry_client_file_url, {
   | ^^^^
   |
   = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
   |
 3 + use chicago_tdd_tools::test;
   |

error: cannot find macro `test` in this scope
  --> crates/ggen-core/tests/unit/registry_client.rs:28:1
   |
28 | test!(test_registry_client_invalid_url, {
   | ^^^^
   |
   = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
   |
 3 + use chicago_tdd_tools::test;
   |

error: cannot find macro `test` in this scope
  --> crates/ggen-core/tests/unit/registry_client.rs:17:1
   |
17 | test!(test_registry_client_custom_url, {
   | ^^^^
   |
   = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
   |
 3 + use chicago_tdd_tools::test;
   |

error: cannot find macro `test` in this scope
 --> crates/ggen-core/tests/unit/registry_client.rs:9:1
  |
9 | test!(test_registry_client_creation, {
  | ^^^^
  |
  = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
  |
3 + use chicago_tdd_tools::test;
  |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/tests/unit/mock_impls.rs:165:5
    |
165 |     test!(test_create_multiver_mock_pack, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
118 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/tests/unit/mock_impls.rs:154:5
    |
154 |     test!(test_create_minimal_mock_pack, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
118 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/tests/unit/mock_impls.rs:142:5
    |
142 |     test!(test_create_mock_registry_index, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
118 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/tests/unit/mock_impls.rs:131:5
    |
131 |     test!(test_create_mock_pack, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
118 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/tests/unit/mock_impls.rs:121:5
    |
121 |     test!(test_create_mock_version, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
118 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/tests/unit/error_handling.rs:208:1
    |
208 | test!(test_empty_version_map_error, {
    | ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
  3 + use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/tests/unit/error_handling.rs:197:1
    |
197 | test!(test_error_context_preservation, {
    | ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
  3 + use chicago_tdd_tools::test;
    |

error: cannot find macro `async_test` in this scope
   --> crates/ggen-core/tests/unit/error_handling.rs:155:1
    |
155 | async_test!(test_invalid_version_comparison_error, async {
    | ^^^^^^^^^^
    |
help: consider importing this macro
    |
  3 + use chicago_tdd_tools::async_test;
    |

error: cannot find macro `async_test` in this scope
   --> crates/ggen-core/tests/unit/error_handling.rs:139:1
    |
139 | async_test!(test_missing_index_file_error, async {
    | ^^^^^^^^^^
    |
help: consider importing this macro
    |
  3 + use chicago_tdd_tools::async_test;
    |

error: cannot find macro `async_test` in this scope
   --> crates/ggen-core/tests/unit/error_handling.rs:120:1
    |
120 | async_test!(test_malformed_index_error, async {
    | ^^^^^^^^^^
    |
help: consider importing this macro
    |
  3 + use chicago_tdd_tools::async_test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/tests/unit/error_handling.rs:107:1
    |
107 | test!(test_missing_required_fields_error, {
    | ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
  3 + use chicago_tdd_tools::test;
    |

warning: `ggen-core` (bench "template_generation") generated 38 warnings (run `cargo fix --bench "template_generation"` to apply 3 suggestions)
error: cannot find macro `test` in this scope
  --> crates/ggen-core/tests/unit/error_handling.rs:96:1
   |
96 | test!(test_json_parsing_error, {
   | ^^^^
   |
   = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
   |
 3 + use chicago_tdd_tools::test;
   |

error: cannot find macro `test` in this scope
  --> crates/ggen-core/tests/unit/error_handling.rs:88:1
   |
88 | test!(test_invalid_semver_error, {
   | ^^^^
   |
   = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
   |
 3 + use chicago_tdd_tools::test;
   |

Some errors have detailed explanations: E0432, E0433, E0609.
For more information about an error, try `rustc --explain E0432`.
error: cannot find macro `async_test` in this scope
  --> crates/ggen-core/tests/unit/error_handling.rs:35:1
   |
35 | async_test!(test_missing_version_error, async {
   | ^^^^^^^^^^
   |
help: consider importing this macro
   |
 3 + use chicago_tdd_tools::async_test;
   |

error: cannot find macro `async_test` in this scope
 --> crates/ggen-core/tests/unit/error_handling.rs:9:1
  |
9 | async_test!(test_missing_pack_error, async {
  | ^^^^^^^^^^
  |
help: consider importing this macro
  |
3 + use chicago_tdd_tools::async_test;
  |

error: cannot find macro `test` in this scope
    --> crates/ggen-core/tests/integration/lifecycle_tests.rs:1047:5
     |
1047 |     test!(test_phase_execution_performance, {
     |     ^^^^
     |
     = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
     |
1044 +     use chicago_tdd_tools::test;
     |

error: cannot find macro `test` in this scope
    --> crates/ggen-core/tests/integration/lifecycle_tests.rs:1004:1
     |
1004 | test!(test_state_preservation_on_error, {
     | ^^^^
     |
     = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
     |
  12 + use chicago_tdd_tools::test;
     |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/tests/integration/lifecycle_tests.rs:977:1
    |
977 | test!(test_detailed_error_messages, {
    | ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
 12 + use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/tests/integration/lifecycle_tests.rs:916:1
    |
916 | test!(test_cache_invalidation_on_command_change, {
    | ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
 12 + use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/tests/integration/lifecycle_tests.rs:885:1
    |
885 | test!(test_phase_caching_basic, {
    | ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
 12 + use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/tests/integration/lifecycle_tests.rs:845:1
    |
845 | test!(test_circular_hook_detection, {
    | ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
 12 + use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/tests/integration/lifecycle_tests.rs:796:1
    |
796 | test!(test_before_and_after_hooks, {
    | ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
 12 + use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/tests/integration/lifecycle_tests.rs:734:1
    |
734 | test!(test_end_to_end_marketplace_lifecycle_flow, {
    | ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
 12 + use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/tests/integration/lifecycle_tests.rs:706:1
    |
706 | test!(test_template_generation_in_init_phase, {
    | ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
 12 + use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/tests/integration/lifecycle_tests.rs:674:1
    |
674 | test!(test_marketplace_package_installation_in_setup, {
    | ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
 12 + use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/tests/integration/lifecycle_tests.rs:629:1
    |
629 | test!(test_cache_invalidation_on_failure, {
    | ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
 12 + use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/tests/integration/lifecycle_tests.rs:595:1
    |
595 | test!(test_state_recovery_after_interruption, {
    | ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
 12 + use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/tests/integration/lifecycle_tests.rs:562:1
    |
562 | test!(test_rollback_after_failed_deployment, {
    | ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
 12 + use chicago_tdd_tools::test;
    |

warning: `ggen-core` (test "template_comprehensive_test") generated 1 warning
error: could not compile `ggen-core` (test "template_comprehensive_test") due to 20 previous errors; 1 warning emitted
error: cannot find macro `test` in this scope
   --> crates/ggen-core/tests/integration/lifecycle_tests.rs:522:1
    |
522 | test!(test_deployment_validation_failure_prevents_deploy, {
    | ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
 12 + use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/tests/integration/lifecycle_tests.rs:475:1
    |
475 | test!(test_deployment_to_production, {
    | ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
 12 + use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/tests/integration/lifecycle_tests.rs:440:1
    |
440 | test!(test_deployment_to_staging, {
    | ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
 12 + use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/tests/integration/lifecycle_tests.rs:409:1
    |
409 | test!(test_readiness_validation_with_validator, {
    | ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
 12 + use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/tests/integration/lifecycle_tests.rs:349:1
    |
349 | test!(test_readiness_report_generation, {
    | ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
 12 + use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/tests/integration/lifecycle_tests.rs:309:1
    |
309 | test!(test_readiness_requirement_lifecycle, {
    | ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
 12 + use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/tests/integration/lifecycle_tests.rs:297:1
    |
297 | test!(test_readiness_tracker_initialization, {
    | ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
 12 + use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/tests/integration/lifecycle_tests.rs:253:1
    |
253 | test!(test_phase_failure_stops_pipeline, {
    | ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
 12 + use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/tests/integration/lifecycle_tests.rs:225:1
    |
225 | test!(test_phase_with_multiple_commands, {
    | ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
 12 + use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/tests/integration/lifecycle_tests.rs:173:1
    |
173 | test!(test_full_lifecycle_pipeline, {
    | ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
 12 + use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/tests/integration/lifecycle_tests.rs:137:1
    |
137 | test!(test_basic_phase_execution, {
    | ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
 12 + use chicago_tdd_tools::test;
    |

warning: `ggen-core` (test "template_rdf_api_tests") generated 2 warnings
error: could not compile `ggen-core` (test "template_rdf_api_tests") due to 1 previous error; 2 warnings emitted
error: cannot find macro `async_test_with_timeout` in this scope
   --> crates/ggen-core/tests/integration/search_integration.rs:273:1
    |
273 | async_test_with_timeout!(test_empty_search_results, 30, async {
    | ^^^^^^^^^^^^^^^^^^^^^^^
    |
help: consider importing this macro
    |
  3 + use chicago_tdd_tools::async_test_with_timeout;
    |

error: cannot find macro `async_test_with_timeout` in this scope
   --> crates/ggen-core/tests/integration/search_integration.rs:204:1
    |
204 | async_test_with_timeout!(test_search_relevance_ranking, 30, async {
    | ^^^^^^^^^^^^^^^^^^^^^^^
    |
help: consider importing this macro
    |
  3 + use chicago_tdd_tools::async_test_with_timeout;
    |

error: cannot find macro `async_test_with_timeout` in this scope
  --> crates/ggen-core/tests/integration/search_integration.rs:99:1
   |
99 | async_test_with_timeout!(test_advanced_search_with_filters, 30, async {
   | ^^^^^^^^^^^^^^^^^^^^^^^
   |
help: consider importing this macro
   |
 3 + use chicago_tdd_tools::async_test_with_timeout;
   |

error: cannot find macro `async_test_with_timeout` in this scope
  --> crates/ggen-core/tests/integration/search_integration.rs:10:1
   |
10 | async_test_with_timeout!(test_basic_search_integration, 30, async {
   | ^^^^^^^^^^^^^^^^^^^^^^^
   |
help: consider importing this macro
   |
 3 + use chicago_tdd_tools::async_test_with_timeout;
   |

error: cannot find macro `async_test_with_timeout` in this scope
   --> crates/ggen-core/tests/integration/registry_api_integration.rs:159:1
    |
159 | async_test_with_timeout!(test_list_all_packages, 30, async {
    | ^^^^^^^^^^^^^^^^^^^^^^^
    |
help: consider importing this macro
    |
  3 + use chicago_tdd_tools::async_test_with_timeout;
    |

error: cannot find macro `async_test_with_timeout` in this scope
  --> crates/ggen-core/tests/integration/registry_api_integration.rs:87:1
   |
87 | async_test_with_timeout!(test_get_popular_keywords, 30, async {
   | ^^^^^^^^^^^^^^^^^^^^^^^
   |
help: consider importing this macro
   |
 3 + use chicago_tdd_tools::async_test_with_timeout;
   |

error: cannot find macro `async_test_with_timeout` in this scope
  --> crates/ggen-core/tests/integration/registry_api_integration.rs:10:1
   |
10 | async_test_with_timeout!(test_get_popular_categories, 30, async {
   | ^^^^^^^^^^^^^^^^^^^^^^^
   |
help: consider importing this macro
   |
 3 + use chicago_tdd_tools::async_test_with_timeout;
   |

error: cannot find macro `async_test_with_timeout` in this scope
   --> crates/ggen-core/tests/integration/marketplace_validation.rs:675:1
    |
675 | async_test_with_timeout!(test_marketplace_package_statistics, 30, async {
    | ^^^^^^^^^^^^^^^^^^^^^^^
    |
help: consider importing this macro
    |
 18 + use chicago_tdd_tools::async_test_with_timeout;
    |

error: cannot find macro `async_test_with_timeout` in this scope
   --> crates/ggen-core/tests/integration/marketplace_validation.rs:609:1
    |
609 | async_test_with_timeout!(test_marketplace_registry_categories, 30, async {
    | ^^^^^^^^^^^^^^^^^^^^^^^
    |
help: consider importing this macro
    |
 18 + use chicago_tdd_tools::async_test_with_timeout;
    |

error: cannot find macro `async_test_with_timeout` in this scope
   --> crates/ggen-core/tests/integration/marketplace_validation.rs:520:1
    |
520 | async_test_with_timeout!(test_marketplace_check_updates, 30, async {
    | ^^^^^^^^^^^^^^^^^^^^^^^
    |
help: consider importing this macro
    |
 18 + use chicago_tdd_tools::async_test_with_timeout;
    |

error: cannot find macro `async_test_with_timeout` in this scope
   --> crates/ggen-core/tests/integration/marketplace_validation.rs:478:1
    |
478 | async_test_with_timeout!(test_marketplace_package_list_performance, 30, async {
    | ^^^^^^^^^^^^^^^^^^^^^^^
    |
help: consider importing this macro
    |
 18 + use chicago_tdd_tools::async_test_with_timeout;
    |

error: cannot find macro `async_test_with_timeout` in this scope
   --> crates/ggen-core/tests/integration/marketplace_validation.rs:457:1
    |
457 | async_test_with_timeout!(test_marketplace_rapid_successive_searches, 30, async {
    | ^^^^^^^^^^^^^^^^^^^^^^^
    |
help: consider importing this macro
    |
 18 + use chicago_tdd_tools::async_test_with_timeout;
    |

error: cannot find macro `async_test_with_timeout` in this scope
   --> crates/ggen-core/tests/integration/marketplace_validation.rs:419:1
    |
419 | async_test_with_timeout!(test_marketplace_large_registry_search, 30, async {
    | ^^^^^^^^^^^^^^^^^^^^^^^
    |
help: consider importing this macro
    |
 18 + use chicago_tdd_tools::async_test_with_timeout;
    |

error: cannot find macro `async_test_with_timeout` in this scope
   --> crates/ggen-core/tests/integration/marketplace_validation.rs:391:1
    |
391 | async_test_with_timeout!(test_marketplace_concurrent_searches, 30, async {
    | ^^^^^^^^^^^^^^^^^^^^^^^
    |
help: consider importing this macro
    |
 18 + use chicago_tdd_tools::async_test_with_timeout;
    |

error: cannot find macro `async_test_with_timeout` in this scope
   --> crates/ggen-core/tests/integration/marketplace_validation.rs:374:1
    |
374 | async_test_with_timeout!(test_marketplace_malformed_index_handling, 30, async {
    | ^^^^^^^^^^^^^^^^^^^^^^^
    |
help: consider importing this macro
    |
 18 + use chicago_tdd_tools::async_test_with_timeout;
    |

error: cannot find macro `async_test_with_timeout` in this scope
   --> crates/ggen-core/tests/integration/marketplace_validation.rs:349:1
    |
349 | async_test_with_timeout!(test_marketplace_empty_registry, 30, async {
    | ^^^^^^^^^^^^^^^^^^^^^^^
    |
help: consider importing this macro
    |
 18 + use chicago_tdd_tools::async_test_with_timeout;
    |

error: cannot find macro `async_test_with_timeout` in this scope
   --> crates/ggen-core/tests/integration/marketplace_validation.rs:338:1
    |
338 | async_test_with_timeout!(test_marketplace_invalid_version, 30, async {
    | ^^^^^^^^^^^^^^^^^^^^^^^
    |
help: consider importing this macro
    |
 18 + use chicago_tdd_tools::async_test_with_timeout;
    |

error: cannot find macro `async_test_with_timeout` in this scope
   --> crates/ggen-core/tests/integration/marketplace_validation.rs:327:1
    |
327 | async_test_with_timeout!(test_marketplace_nonexistent_package, 30, async {
    | ^^^^^^^^^^^^^^^^^^^^^^^
    |
help: consider importing this macro
    |
 18 + use chicago_tdd_tools::async_test_with_timeout;
    |

error: cannot find macro `async_test_with_timeout` in this scope
   --> crates/ggen-core/tests/integration/marketplace_validation.rs:302:1
    |
302 | async_test_with_timeout!(test_marketplace_package_metadata_validation, 30, async {
    | ^^^^^^^^^^^^^^^^^^^^^^^
    |
help: consider importing this macro
    |
 18 + use chicago_tdd_tools::async_test_with_timeout;
    |

error: cannot find macro `async_test_with_timeout` in this scope
   --> crates/ggen-core/tests/integration/marketplace_validation.rs:217:1
    |
217 | async_test_with_timeout!(
    | ^^^^^^^^^^^^^^^^^^^^^^^
    |
help: consider importing this macro
    |
 18 + use chicago_tdd_tools::async_test_with_timeout;
    |

error: cannot find macro `async_test_with_timeout` in this scope
   --> crates/ggen-core/tests/integration/marketplace_validation.rs:200:1
    |
200 | async_test_with_timeout!(test_marketplace_package_resolve, 30, async {
    | ^^^^^^^^^^^^^^^^^^^^^^^
    |
help: consider importing this macro
    |
 18 + use chicago_tdd_tools::async_test_with_timeout;
    |

error: cannot find macro `async_test_with_timeout` in this scope
   --> crates/ggen-core/tests/integration/marketplace_validation.rs:180:1
    |
180 | async_test_with_timeout!(test_marketplace_search_with_special_characters, 30, async {
    | ^^^^^^^^^^^^^^^^^^^^^^^
    |
help: consider importing this macro
    |
 18 + use chicago_tdd_tools::async_test_with_timeout;
    |

error: cannot find macro `async_test_with_timeout` in this scope
   --> crates/ggen-core/tests/integration/marketplace_validation.rs:166:1
    |
166 | async_test_with_timeout!(test_marketplace_search_empty_results, 30, async {
    | ^^^^^^^^^^^^^^^^^^^^^^^
    |
help: consider importing this macro
    |
 18 + use chicago_tdd_tools::async_test_with_timeout;
    |

error: cannot find macro `async_test_with_timeout` in this scope
   --> crates/ggen-core/tests/integration/marketplace_validation.rs:147:1
    |
147 | async_test_with_timeout!(test_marketplace_search_case_insensitive, 30, async {
    | ^^^^^^^^^^^^^^^^^^^^^^^
    |
help: consider importing this macro
    |
 18 + use chicago_tdd_tools::async_test_with_timeout;
    |

error: cannot find macro `async_test_with_timeout` in this scope
   --> crates/ggen-core/tests/integration/marketplace_validation.rs:121:1
    |
121 | async_test_with_timeout!(test_marketplace_search_by_tag, 30, async {
    | ^^^^^^^^^^^^^^^^^^^^^^^
    |
help: consider importing this macro
    |
 18 + use chicago_tdd_tools::async_test_with_timeout;
    |

error: cannot find macro `async_test_with_timeout` in this scope
  --> crates/ggen-core/tests/integration/marketplace_validation.rs:95:1
   |
95 | async_test_with_timeout!(test_marketplace_basic_search, 30, async {
   | ^^^^^^^^^^^^^^^^^^^^^^^
   |
help: consider importing this macro
   |
18 + use chicago_tdd_tools::async_test_with_timeout;
   |

error: cannot find macro `async_test_with_timeout` in this scope
   --> crates/ggen-core/tests/integration/end_to_end_flow.rs:221:1
    |
221 | async_test_with_timeout!(test_error_handling_flow, 30, async {
    | ^^^^^^^^^^^^^^^^^^^^^^^
    |
help: consider importing this macro
    |
  3 + use chicago_tdd_tools::async_test_with_timeout;
    |

error: cannot find macro `async_test_with_timeout` in this scope
   --> crates/ggen-core/tests/integration/end_to_end_flow.rs:147:1
    |
147 | async_test_with_timeout!(test_multi_package_search, 30, async {
    | ^^^^^^^^^^^^^^^^^^^^^^^
    |
help: consider importing this macro
    |
  3 + use chicago_tdd_tools::async_test_with_timeout;
    |

error: cannot find macro `async_test_with_timeout` in this scope
  --> crates/ggen-core/tests/integration/end_to_end_flow.rs:77:1
   |
77 | async_test_with_timeout!(test_package_update_flow, 30, async {
   | ^^^^^^^^^^^^^^^^^^^^^^^
   |
help: consider importing this macro
   |
 3 + use chicago_tdd_tools::async_test_with_timeout;
   |

error: cannot find macro `async_test_with_timeout` in this scope
  --> crates/ggen-core/tests/integration/end_to_end_flow.rs:10:1
   |
10 | async_test_with_timeout!(test_complete_package_lifecycle, 30, async {
   | ^^^^^^^^^^^^^^^^^^^^^^^
   |
help: consider importing this macro
   |
 3 + use chicago_tdd_tools::async_test_with_timeout;
   |

warning: unused import: `chicago_tdd_tools::prelude::*`
 --> crates/ggen-core/tests/integration/end_to_end_flow.rs:3:5
  |
3 | use chicago_tdd_tools::prelude::*;
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  |
  = note: `#[warn(unused_imports)]` on by default

warning: unused imports: `PackMetadata`, `RegistryClient`, and `VersionMetadata`
 --> crates/ggen-core/tests/integration/end_to_end_flow.rs:4:27
  |
4 | use ggen_core::registry::{PackMetadata, RegistryClient, VersionMetadata};
  |                           ^^^^^^^^^^^^  ^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^

warning: unused import: `std::collections::HashMap`
 --> crates/ggen-core/tests/integration/end_to_end_flow.rs:5:5
  |
5 | use std::collections::HashMap;
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^

warning: unused import: `std::fs`
 --> crates/ggen-core/tests/integration/end_to_end_flow.rs:6:5
  |
6 | use std::fs;
  |     ^^^^^^^

warning: unused import: `tempfile::TempDir`
 --> crates/ggen-core/tests/integration/end_to_end_flow.rs:7:5
  |
7 | use tempfile::TempDir;
  |     ^^^^^^^^^^^^^^^^^

warning: unused import: `url::Url`
 --> crates/ggen-core/tests/integration/end_to_end_flow.rs:8:5
  |
8 | use url::Url;
  |     ^^^^^^^^

warning: unused import: `chicago_tdd_tools::prelude::*`
  --> crates/ggen-core/tests/integration/marketplace_validation.rs:19:5
   |
19 | use chicago_tdd_tools::prelude::*;
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

warning: unused import: `chicago_tdd_tools::prelude::*`
 --> crates/ggen-core/tests/integration/registry_api_integration.rs:3:5
  |
3 | use chicago_tdd_tools::prelude::*;
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

warning: unused imports: `PackMetadata`, `RegistryClient`, and `VersionMetadata`
 --> crates/ggen-core/tests/integration/registry_api_integration.rs:4:27
  |
4 | use ggen_core::registry::{PackMetadata, RegistryClient, VersionMetadata};
  |                           ^^^^^^^^^^^^  ^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^

warning: unused import: `std::collections::HashMap`
 --> crates/ggen-core/tests/integration/registry_api_integration.rs:5:5
  |
5 | use std::collections::HashMap;
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^

warning: unused import: `std::fs`
 --> crates/ggen-core/tests/integration/registry_api_integration.rs:6:5
  |
6 | use std::fs;
  |     ^^^^^^^

warning: unused import: `tempfile::TempDir`
 --> crates/ggen-core/tests/integration/registry_api_integration.rs:7:5
  |
7 | use tempfile::TempDir;
  |     ^^^^^^^^^^^^^^^^^

warning: unused import: `url::Url`
 --> crates/ggen-core/tests/integration/registry_api_integration.rs:8:5
  |
8 | use url::Url;
  |     ^^^^^^^^

warning: unused import: `chicago_tdd_tools::prelude::*`
 --> crates/ggen-core/tests/integration/search_integration.rs:3:5
  |
3 | use chicago_tdd_tools::prelude::*;
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

warning: unused imports: `PackMetadata`, `RegistryClient`, `SearchParams`, and `VersionMetadata`
 --> crates/ggen-core/tests/integration/search_integration.rs:4:27
  |
4 | use ggen_core::registry::{PackMetadata, RegistryClient, SearchParams, VersionMetadata};
  |                           ^^^^^^^^^^^^  ^^^^^^^^^^^^^^  ^^^^^^^^^^^^  ^^^^^^^^^^^^^^^

warning: unused import: `std::collections::HashMap`
 --> crates/ggen-core/tests/integration/search_integration.rs:5:5
  |
5 | use std::collections::HashMap;
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^

warning: unused import: `std::fs`
 --> crates/ggen-core/tests/integration/search_integration.rs:6:5
  |
6 | use std::fs;
  |     ^^^^^^^

warning: unused import: `tempfile::TempDir`
 --> crates/ggen-core/tests/integration/search_integration.rs:7:5
  |
7 | use tempfile::TempDir;
  |     ^^^^^^^^^^^^^^^^^

warning: unused import: `url::Url`
 --> crates/ggen-core/tests/integration/search_integration.rs:8:5
  |
8 | use url::Url;
  |     ^^^^^^^^

warning: unused import: `Path`
  --> crates/ggen-core/tests/integration/lifecycle_clnrm_tests.rs:12:17
   |
12 | use std::path::{Path, PathBuf};
   |                 ^^^^

warning: unused import: `std::sync::Arc`
  --> crates/ggen-core/tests/integration/lifecycle_clnrm_tests.rs:14:5
   |
14 | use std::sync::Arc;
   |     ^^^^^^^^^^^^^^

warning: unused import: `chicago_tdd_tools::prelude::*`
  --> crates/ggen-core/tests/integration/lifecycle_tests.rs:13:5
   |
13 | use chicago_tdd_tools::prelude::*;
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

warning: unused import: `Path`
  --> crates/ggen-core/tests/integration/lifecycle_tests.rs:16:17
   |
16 | use std::path::{Path, PathBuf};
   |                 ^^^^

warning: unused import: `super::*`
    --> crates/ggen-core/tests/integration/lifecycle_tests.rs:1044:9
     |
1044 |     use super::*;
     |         ^^^^^^^^

warning: unused import: `std::time::Instant`
    --> crates/ggen-core/tests/integration/lifecycle_tests.rs:1045:9
     |
1045 |     use std::time::Instant;
     |         ^^^^^^^^^^^^^^^^^^

warning: unused import: `chicago_tdd_tools::prelude::*`
 --> crates/ggen-core/tests/unit/error_handling.rs:3:5
  |
3 | use chicago_tdd_tools::prelude::*;
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

warning: unused imports: `PackMetadata`, `RegistryClient`, and `VersionMetadata`
 --> crates/ggen-core/tests/unit/error_handling.rs:4:27
  |
4 | use ggen_core::registry::{PackMetadata, RegistryClient, VersionMetadata};
  |                           ^^^^^^^^^^^^  ^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^

warning: unused import: `std::collections::HashMap`
 --> crates/ggen-core/tests/unit/error_handling.rs:5:5
  |
5 | use std::collections::HashMap;
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^

warning: unused import: `tempfile::TempDir`
 --> crates/ggen-core/tests/unit/error_handling.rs:6:5
  |
6 | use tempfile::TempDir;
  |     ^^^^^^^^^^^^^^^^^

warning: unused import: `url::Url`
 --> crates/ggen-core/tests/unit/error_handling.rs:7:5
  |
7 | use url::Url;
  |     ^^^^^^^^

warning: unused import: `super::*`
   --> crates/ggen-core/tests/unit/mock_impls.rs:118:9
    |
118 |     use super::*;
    |         ^^^^^^^^

warning: unused import: `chicago_tdd_tools::prelude::*`
   --> crates/ggen-core/tests/unit/mock_impls.rs:119:9
    |
119 |     use chicago_tdd_tools::prelude::*;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

warning: unused import: `chicago_tdd_tools::prelude::*`
 --> crates/ggen-core/tests/unit/registry_client.rs:3:5
  |
3 | use chicago_tdd_tools::prelude::*;
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

warning: unused imports: `PackMetadata`, `RegistryClient`, `RegistryIndex`, and `VersionMetadata`
 --> crates/ggen-core/tests/unit/registry_client.rs:4:27
  |
4 | use ggen_core::registry::{PackMetadata, RegistryClient, RegistryIndex, VersionMetadata};
  |                           ^^^^^^^^^^^^  ^^^^^^^^^^^^^^  ^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^

warning: unused import: `std::collections::HashMap`
 --> crates/ggen-core/tests/unit/registry_client.rs:5:5
  |
5 | use std::collections::HashMap;
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^

warning: unused import: `tempfile::TempDir`
 --> crates/ggen-core/tests/unit/registry_client.rs:6:5
  |
6 | use tempfile::TempDir;
  |     ^^^^^^^^^^^^^^^^^

warning: unused import: `url::Url`
 --> crates/ggen-core/tests/unit/registry_client.rs:7:5
  |
7 | use url::Url;
  |     ^^^^^^^^

warning: unused imports: `create_mock_pack` and `create_mock_registry_index`
 --> crates/ggen-core/tests/unit/registry_index.rs:3:25
  |
3 | use super::mock_impls::{create_mock_pack, create_mock_registry_index};
  |                         ^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^^^^^^^^^

warning: unused import: `chicago_tdd_tools::prelude::*`
 --> crates/ggen-core/tests/unit/registry_index.rs:4:5
  |
4 | use chicago_tdd_tools::prelude::*;
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

warning: unused import: `chrono::Utc`
 --> crates/ggen-core/tests/unit/registry_index.rs:5:5
  |
5 | use chrono::Utc;
  |     ^^^^^^^^^^^

warning: unused import: `ggen_core::registry::RegistryIndex`
 --> crates/ggen-core/tests/unit/registry_index.rs:6:5
  |
6 | use ggen_core::registry::RegistryIndex;
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

warning: unused import: `std::collections::HashMap`
 --> crates/ggen-core/tests/unit/registry_index.rs:7:5
  |
7 | use std::collections::HashMap;
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^

warning: unused import: `chicago_tdd_tools::prelude::*`
 --> crates/ggen-core/tests/unit/search_params.rs:3:5
  |
3 | use chicago_tdd_tools::prelude::*;
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

warning: unused import: `ggen_core::registry::SearchParams`
 --> crates/ggen-core/tests/unit/search_params.rs:4:5
  |
4 | use ggen_core::registry::SearchParams;
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

warning: unused import: `chicago_tdd_tools::prelude::*`
 --> crates/ggen-core/tests/unit/version_resolution.rs:3:5
  |
3 | use chicago_tdd_tools::prelude::*;
  |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

warning: unused import: `semver::Version`
 --> crates/ggen-core/tests/unit/version_resolution.rs:4:5
  |
4 | use semver::Version;
  |     ^^^^^^^^^^^^^^^

warning: unused import: `super::*`
  --> crates/ggen-core/tests/marketplace_tests_main.rs:24:9
   |
24 |     use super::*;
   |         ^^^^^^^^

warning: `ggen-core` (test "london_tdd_examples") generated 1 warning (run `cargo fix --test "london_tdd_examples"` to apply 1 suggestion)
error[E0277]: `QueryResults<'_>` is not an iterator
  --> crates/ggen-core/tests/marketplace_graph_integration.rs:81:19
   |
81 |     for result in results {
   |                   ^^^^^^^ `QueryResults<'_>` is not an iterator
   |
   = help: the trait `Iterator` is not implemented for `QueryResults<'_>`
   = note: required for `QueryResults<'_>` to implement `IntoIterator`

error[E0277]: `QueryResults<'_>` is not an iterator
   --> crates/ggen-core/tests/marketplace_graph_integration.rs:100:19
    |
100 |     for result in ask_results {
    |                   ^^^^^^^^^^^ `QueryResults<'_>` is not an iterator
    |
    = help: the trait `Iterator` is not implemented for `QueryResults<'_>`
    = note: required for `QueryResults<'_>` to implement `IntoIterator`

error[E0277]: `QueryResults<'_>` is not an iterator
   --> crates/ggen-core/tests/marketplace_graph_integration.rs:175:19
    |
175 |     for result in results {
    |                   ^^^^^^^ `QueryResults<'_>` is not an iterator
    |
    = help: the trait `Iterator` is not implemented for `QueryResults<'_>`
    = note: required for `QueryResults<'_>` to implement `IntoIterator`

error[E0277]: `QueryResults<'_>` is not an iterator
   --> crates/ggen-core/tests/marketplace_graph_integration.rs:225:19
    |
225 |     for result in results {
    |                   ^^^^^^^ `QueryResults<'_>` is not an iterator
    |
    = help: the trait `Iterator` is not implemented for `QueryResults<'_>`
    = note: required for `QueryResults<'_>` to implement `IntoIterator`

error[E0061]: this function takes 4 arguments but 1 argument was supplied
   --> crates/ggen-core/tests/marketplace_graph_integration.rs:265:15
    |
265 |     let ctx = Context::new(fixture.project_path())?;
    |               ^^^^^^^^^^^^------------------------ three arguments of type `Arc<Make>`, `PathBuf`, and `Vec<(String, String)>` are missing
    |
note: associated function defined here
   --> /Users/sac/ggen/crates/ggen-core/src/lifecycle/exec.rs:82:12
    |
 82 |     pub fn new(
    |            ^^^
help: provide the arguments
    |
265 |     let ctx = Context::new(fixture.project_path(), /* Arc<Make> */, /* PathBuf */, /* Vec<(String, String)> */)?;
    |                                                  +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

error[E0277]: the `?` operator can only be applied to values that implement `Try`
   --> crates/ggen-core/tests/marketplace_graph_integration.rs:265:15
    |
265 |     let ctx = Context::new(fixture.project_path())?;
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the `?` operator cannot be applied to type `ggen_core::lifecycle::Context`
    |
    = help: the trait `Try` is not implemented for `ggen_core::lifecycle::Context`

error[E0277]: `?` couldn't convert the error to `ggen_utils::Error`
   --> crates/ggen-core/tests/marketplace_graph_integration.rs:266:29
    |
236 | fn test_marketplace_graph_with_lifecycle_context() -> Result<()> {
    |                                                       ---------- expected `ggen_utils::Error` because of this
...
266 |     run_phase(&ctx, "setup")?;
    |     ------------------------^ the trait `From<LifecycleError>` is not implemented for `ggen_utils::Error`
    |     |
    |     this can't be annotated with `?` because it has type `Result<_, LifecycleError>`
    |
    = note: the question mark operation (`?`) implicitly performs a conversion on the error value using the `From` trait
    = help: the following other types implement trait `From<T>`:
              `ggen_utils::Error` implements `From<&str>`
              `ggen_utils::Error` implements `From<PoisonError<T>>`
              `ggen_utils::Error` implements `From<QueryEvaluationError>`
              `ggen_utils::Error` implements `From<SerializerError>`
              `ggen_utils::Error` implements `From<StorageError>`
              `ggen_utils::Error` implements `From<String>`
              `ggen_utils::Error` implements `From<anyhow::Error>`
              `ggen_utils::Error` implements `From<config::error::ConfigError>`
            and 7 others

error[E0277]: `QueryResults<'_>` is not an iterator
   --> crates/ggen-core/tests/marketplace_graph_integration.rs:279:19
    |
279 |     for result in results {
    |                   ^^^^^^^ `QueryResults<'_>` is not an iterator
    |
    = help: the trait `Iterator` is not implemented for `QueryResults<'_>`
    = note: required for `QueryResults<'_>` to implement `IntoIterator`

Some errors have detailed explanations: E0061, E0277.
For more information about an error, try `rustc --explain E0061`.
error: could not compile `ggen-core` (test "marketplace_graph_integration") due to 8 previous errors
error[E0599]: no method named `context` found for enum `std::result::Result` in the current scope
   --> crates/ggen-core/tests/integration/clnrm_harness.rs:114:28
    |
114 |             TempDir::new().context("Failed to create temporary directory for test harness")?;
    |                            ^^^^^^^ method not found in `std::result::Result<tempfile::TempDir, std::io::Error>`
    |
    = help: items from traits can only be used if the trait is in scope
help: the following traits which provide `context` are implemented but not in scope; perhaps you want to import one of them
    |
 30 + use anyhow::Context;
    |
 30 + use quick_error::ResultExt;
    |

error[E0599]: no method named `context` found for enum `std::result::Result` in the current scope
   --> crates/ggen-core/tests/integration/clnrm_harness.rs:146:14
    |
145 | /         std::fs::create_dir_all(&data_dir)
146 | |             .context("Failed to create marketplace data directory")?;
    | |             -^^^^^^^ method not found in `std::result::Result<(), std::io::Error>`
    | |_____________|
    |
    |
    = help: items from traits can only be used if the trait is in scope
help: the following traits which provide `context` are implemented but not in scope; perhaps you want to import one of them
    |
 30 + use anyhow::Context;
    |
 30 + use quick_error::ResultExt;
    |

error[E0599]: no method named `context` found for enum `std::result::Result` in the current scope
   --> crates/ggen-core/tests/integration/clnrm_harness.rs:165:50
    |
165 |             serde_json::to_string_pretty(&index).context("Failed to serialize registry index")?;
    |                                                  ^^^^^^^ method not found in `std::result::Result<std::string::String, serde_json::Error>`
    |
    = help: items from traits can only be used if the trait is in scope
help: the following traits which provide `context` are implemented but not in scope; perhaps you want to import one of them
    |
 30 + use anyhow::Context;
    |
 30 + use quick_error::ResultExt;
    |

error[E0599]: no method named `context` found for enum `std::result::Result` in the current scope
   --> crates/ggen-core/tests/integration/clnrm_harness.rs:166:49
    |
166 |         std::fs::write(&index_path, index_json).context("Failed to write registry index")?;
    |                                                 ^^^^^^^ method not found in `std::result::Result<(), std::io::Error>`
    |
    = help: items from traits can only be used if the trait is in scope
help: the following traits which provide `context` are implemented but not in scope; perhaps you want to import one of them
    |
 30 + use anyhow::Context;
    |
 30 + use quick_error::ResultExt;
    |

error[E0599]: no method named `context` found for enum `std::result::Result` in the current scope
   --> crates/ggen-core/tests/integration/clnrm_harness.rs:172:53
    |
172 |             RegistryClient::with_base_url(base_url).context("Failed to create registry client")?;
    |                                                     ^^^^^^^ method not found in `std::result::Result<RegistryClient, ggen_utils::error::Error>`
    |
note: the method `context` exists on the type `ggen_utils::error::Error`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:136:5
    |
136 | /     pub fn context<C>(self, context: C) -> Self
137 | |     where
138 | |         C: fmt::Display + Send + Sync + 'static,
    | |________________________________________________^
    = help: items from traits can only be used if the trait is in scope
help: consider using `Result::expect` to unwrap the `ggen_utils::error::Error` value, panicking if the value is a `Result::Err`
    |
172 |             RegistryClient::with_base_url(base_url).expect("REASON").context("Failed to create registry client")?;
    |                                                    +++++++++++++++++
help: the following traits which provide `context` are implemented but not in scope; perhaps you want to import one of them
    |
 30 + use anyhow::Context;
    |
 30 + use ggen_utils::error::Context;
    |
 30 + use quick_error::ResultExt;
    |

error[E0599]: no method named `context` found for enum `std::result::Result` in the current scope
   --> crates/ggen-core/tests/integration/clnrm_harness.rs:187:47
    |
187 |         std::fs::create_dir_all(&project_dir).context("Failed to create project directory")?;
    |                                               ^^^^^^^ method not found in `std::result::Result<(), std::io::Error>`
    |
    = help: items from traits can only be used if the trait is in scope
help: the following traits which provide `context` are implemented but not in scope; perhaps you want to import one of them
    |
 30 + use anyhow::Context;
    |
 30 + use quick_error::ResultExt;
    |

error[E0599]: no method named `context` found for enum `std::result::Result` in the current scope
   --> crates/ggen-core/tests/integration/clnrm_harness.rs:191:14
    |
190 | /         std::fs::create_dir_all(project_dir.join("src"))
191 | |             .context("Failed to create src directory")?;
    | |             -^^^^^^^ method not found in `std::result::Result<(), std::io::Error>`
    | |_____________|
    |
    |
    = help: items from traits can only be used if the trait is in scope
help: the following traits which provide `context` are implemented but not in scope; perhaps you want to import one of them
    |
 30 + use anyhow::Context;
    |
 30 + use quick_error::ResultExt;
    |

error: cannot find macro `async_test` in this scope
   --> crates/ggen-core/src/github.rs:552:5
    |
552 |     async_test!(test_github_client_creation, {
    |     ^^^^^^^^^^
    |
help: consider importing this macro
    |
536 +     use chicago_tdd_tools::async_test;
    |

error[E0599]: no method named `context` found for enum `std::result::Result` in the current scope
   --> crates/ggen-core/tests/integration/clnrm_harness.rs:193:14
    |
192 | /         std::fs::create_dir_all(project_dir.join("tests"))
193 | |             .context("Failed to create tests directory")?;
    | |             -^^^^^^^ method not found in `std::result::Result<(), std::io::Error>`
    | |_____________|
    |
    |
    = help: items from traits can only be used if the trait is in scope
help: the following traits which provide `context` are implemented but not in scope; perhaps you want to import one of them
    |
 30 + use anyhow::Context;
    |
 30 + use quick_error::ResultExt;
    |

error: cannot find macro `async_test` in this scope
   --> crates/ggen-core/src/lifecycle/optimization.rs:457:5
    |
457 |     async_test!(test_pipeline_profiler, {
    |     ^^^^^^^^^^
    |
help: consider importing this macro
    |
432 +     use chicago_tdd_tools::async_test;
    |

error: cannot find macro `async_test` in this scope
   --> crates/ggen-core/src/lifecycle/optimization.rs:472:5
    |
472 |     async_test!(test_parallel_orchestrator, {
    |     ^^^^^^^^^^
    |
help: consider importing this macro
    |
432 +     use chicago_tdd_tools::async_test;
    |

error: cannot find macro `async_test` in this scope
   --> crates/ggen-core/src/lifecycle/optimization.rs:487:5
    |
487 |     async_test!(test_container_pool, {
    |     ^^^^^^^^^^
    |
help: consider importing this macro
    |
432 +     use chicago_tdd_tools::async_test;
    |

error[E0599]: no method named `context` found for enum `std::result::Result` in the current scope
   --> crates/ggen-core/tests/integration/clnrm_harness.rs:209:44
    |
209 |         std::fs::create_dir_all(&data_dir).context("Failed to create container data directory")?;
    |                                            ^^^^^^^ method not found in `std::result::Result<(), std::io::Error>`
    |
    = help: items from traits can only be used if the trait is in scope
help: the following traits which provide `context` are implemented but not in scope; perhaps you want to import one of them
    |
 30 + use anyhow::Context;
    |
 30 + use quick_error::ResultExt;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/lifecycle/integration_test.rs:146:5
    |
146 |     test!(test_load_make_toml, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
 12 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/lifecycle/integration_test.rs:176:5
    |
176 |     test!(test_run_single_phase, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
 12 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/lifecycle/integration_test.rs:198:5
    |
198 |     test!(test_state_persistence, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
 12 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/lifecycle/integration_test.rs:225:5
    |
225 |     test!(test_cache_key_generation, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
 12 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/lifecycle/integration_test.rs:273:5
    |
273 |     test!(test_cache_key_changes_with_inputs, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
 12 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/lifecycle/integration_test.rs:294:5
    |
294 |     test!(test_hooks_execution_order, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
 12 +     use chicago_tdd_tools::test;
    |

error[E0599]: no method named `context` found for enum `std::result::Result` in the current scope
   --> crates/ggen-core/tests/integration/clnrm_harness.rs:258:14
    |
255 | /         self.client
256 | |             .search(query)
257 | |             .await
258 | |             .context("Failed to search packages")
    | |             -^^^^^^^ method not found in `std::result::Result<Vec<SearchResult>, ggen_utils::error::Error>`
    | |_____________|
    |
    |
note: the method `context` exists on the type `ggen_utils::error::Error`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:136:5
    |
136 | /     pub fn context<C>(self, context: C) -> Self
137 | |     where
138 | |         C: fmt::Display + Send + Sync + 'static,
    | |________________________________________________^
    = help: items from traits can only be used if the trait is in scope
help: consider using `Result::expect` to unwrap the `ggen_utils::error::Error` value, panicking if the value is a `Result::Err`
    |
257 |             .await.expect("REASON")
    |                   +++++++++++++++++
help: the following traits which provide `context` are implemented but not in scope; perhaps you want to import one of them
    |
 30 + use anyhow::Context;
    |
 30 + use ggen_utils::error::Context;
    |
 30 + use quick_error::ResultExt;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/lifecycle/integration_test.rs:315:5
    |
315 |     test!(test_phase_not_found, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
 12 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/lifecycle/integration_test.rs:327:5
    |
327 |     test!(test_get_last_run, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
 12 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/lifecycle/integration_test.rs:353:5
    |
353 |     test!(test_get_cache_key, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
 12 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/lifecycle/integration_test.rs:370:5
    |
370 |     test!(test_pipeline_execution, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
 12 +     use chicago_tdd_tools::test;
    |

error[E0599]: no method named `context` found for enum `std::result::Result` in the current scope
   --> crates/ggen-core/tests/integration/clnrm_harness.rs:269:14
    |
266 | /         self.client
267 | |             .resolve(id, version)
268 | |             .await
269 | |             .context("Failed to resolve package")
    | |             -^^^^^^^ method not found in `std::result::Result<ResolvedPack, ggen_utils::error::Error>`
    | |_____________|
    |
    |
note: the method `context` exists on the type `ggen_utils::error::Error`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:136:5
    |
136 | /     pub fn context<C>(self, context: C) -> Self
137 | |     where
138 | |         C: fmt::Display + Send + Sync + 'static,
    | |________________________________________________^
    = help: items from traits can only be used if the trait is in scope
help: consider using `Result::expect` to unwrap the `ggen_utils::error::Error` value, panicking if the value is a `Result::Err`
    |
268 |             .await.expect("REASON")
    |                   +++++++++++++++++
help: the following traits which provide `context` are implemented but not in scope; perhaps you want to import one of them
    |
 30 + use anyhow::Context;
    |
 30 + use ggen_utils::error::Context;
    |
 30 + use quick_error::ResultExt;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/lifecycle/integration_test.rs:397:5
    |
397 |     test!(test_workspace_support, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
 12 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/lifecycle/integration_test.rs:416:5
    |
416 |     test!(test_phase_commands_extraction, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
 12 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/lifecycle/integration_test.rs:436:5
    |
436 |     test!(test_phase_names_listing, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
 12 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/lifecycle/integration_test.rs:454:5
    |
454 |     test!(test_multiple_phase_runs_state_history, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
 12 +     use chicago_tdd_tools::test;
    |

error[E0599]: no method named `context` found for enum `std::result::Result` in the current scope
   --> crates/ggen-core/tests/integration/clnrm_harness.rs:280:14
    |
277 | /         self.client
278 | |             .list_packages()
279 | |             .await
280 | |             .context("Failed to list packages")
    | |             -^^^^^^^ method not found in `std::result::Result<Vec<PackMetadata>, ggen_utils::error::Error>`
    | |_____________|
    |
    |
note: the method `context` exists on the type `ggen_utils::error::Error`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:136:5
    |
136 | /     pub fn context<C>(self, context: C) -> Self
137 | |     where
138 | |         C: fmt::Display + Send + Sync + 'static,
    | |________________________________________________^
    = help: items from traits can only be used if the trait is in scope
help: consider using `Result::expect` to unwrap the `ggen_utils::error::Error` value, panicking if the value is a `Result::Err`
    |
279 |             .await.expect("REASON")
    |                   +++++++++++++++++
help: the following traits which provide `context` are implemented but not in scope; perhaps you want to import one of them
    |
 30 + use anyhow::Context;
    |
 30 + use ggen_utils::error::Context;
    |
 30 + use quick_error::ResultExt;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/lifecycle/integration_test.rs:475:5
    |
475 |     test!(test_cache_storage_and_validation, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
 12 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/lifecycle/integration_test.rs:496:5
    |
496 |     test!(test_empty_phase_commands, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
 12 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/lifecycle/integration_test.rs:522:5
    |
522 |     test!(test_load_make_or_default, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
 12 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/lifecycle/integration_test.rs:540:5
    |
540 |     test!(test_concurrent_phase_execution_state, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
 12 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/lifecycle/integration_test.rs:568:5
    |
568 |     test!(test_parallel_workspace_execution, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
 12 +     use chicago_tdd_tools::test;
    |

error[E0599]: no method named `context` found for enum `std::result::Result` in the current scope
   --> crates/ggen-core/tests/integration/clnrm_harness.rs:314:14
    |
313 |           let index_json = serde_json::to_string_pretty(&index)
    |  __________________________-
314 | |             .context("Failed to serialize updated registry index")?;
    | |             -^^^^^^^ method not found in `std::result::Result<std::string::String, serde_json::Error>`
    | |_____________|
    |
    |
    = help: items from traits can only be used if the trait is in scope
help: the following traits which provide `context` are implemented but not in scope; perhaps you want to import one of them
    |
 30 + use anyhow::Context;
    |
 30 + use quick_error::ResultExt;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/lifecycle/integration_test.rs:665:5
    |
665 |     test!(test_parallel_workspace_error_handling, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
 12 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
  --> crates/ggen-core/src/lifecycle/behavior_tests.rs:88:5
   |
88 |     test!(test_hook_execution_order_contract, {
   |     ^^^^
   |
   = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
   |
 9 +     use chicago_tdd_tools::test;
   |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/lifecycle/behavior_tests.rs:119:5
    |
119 |     test!(test_hooks_called_even_when_phase_succeeds, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
  9 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/lifecycle/behavior_tests.rs:142:5
    |
142 |     test!(test_after_hooks_not_called_when_before_hooks_fail, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
  9 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/lifecycle/behavior_tests.rs:169:5
    |
169 |     test!(test_state_saved_after_successful_phase, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
  9 +     use chicago_tdd_tools::test;
    |

error[E0599]: no method named `context` found for enum `std::result::Result` in the current scope
   --> crates/ggen-core/tests/integration/clnrm_harness.rs:316:14
    |
315 | /         std::fs::write(&index_path, index_json)
316 | |             .context("Failed to write updated registry index")?;
    | |             -^^^^^^^ method not found in `std::result::Result<(), std::io::Error>`
    | |_____________|
    |
    |
    = help: items from traits can only be used if the trait is in scope
help: the following traits which provide `context` are implemented but not in scope; perhaps you want to import one of them
    |
 30 + use anyhow::Context;
    |
 30 + use quick_error::ResultExt;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/lifecycle/behavior_tests.rs:201:5
    |
201 |     test!(test_state_includes_duration_and_timestamp, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
  9 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/lifecycle/behavior_tests.rs:227:5
    |
227 |     test!(test_state_not_saved_when_phase_fails, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
  9 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/lifecycle/behavior_tests.rs:252:5
    |
252 |     test!(test_cache_key_regenerated_when_command_changes, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
  9 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/lifecycle/behavior_tests.rs:282:5
    |
282 |     test!(test_cache_key_regenerated_when_env_changes, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
  9 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/lifecycle/behavior_tests.rs:309:5
    |
309 |     test!(test_cache_invalidated_when_phase_fails, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
  9 +     use chicago_tdd_tools::test;
    |

error[E0599]: no method named `context` found for enum `std::result::Result` in the current scope
   --> crates/ggen-core/tests/integration/clnrm_harness.rs:341:50
    |
341 |         std::fs::write(&manifest_path, manifest).context("Failed to write Cargo.toml")?;
    |                                                  ^^^^^^^ method not found in `std::result::Result<(), std::io::Error>`
    |
    = help: items from traits can only be used if the trait is in scope
help: the following traits which provide `context` are implemented but not in scope; perhaps you want to import one of them
    |
 30 + use anyhow::Context;
    |
 30 + use quick_error::ResultExt;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/lifecycle/behavior_tests.rs:326:5
    |
326 |     test!(test_cache_valid_check_before_execution, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
  9 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/lifecycle/behavior_tests.rs:358:5
    |
358 |     test!(test_error_propagates_from_command_execution, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
  9 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/lifecycle/behavior_tests.rs:378:5
    |
378 |     test!(test_error_hooks_called_on_failure, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
  9 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/lifecycle/behavior_tests.rs:403:5
    |
403 |     test!(test_rollback_on_partial_failure, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
  9 +     use chicago_tdd_tools::test;
    |

error[E0599]: no method named `context` found for enum `std::result::Result` in the current scope
   --> crates/ggen-core/tests/integration/clnrm_harness.rs:349:44
    |
349 |         std::fs::write(&src_path, main_rs).context("Failed to write main.rs")?;
    |                                            ^^^^^^^ method not found in `std::result::Result<(), std::io::Error>`
    |
    = help: items from traits can only be used if the trait is in scope
help: the following traits which provide `context` are implemented but not in scope; perhaps you want to import one of them
    |
 30 + use anyhow::Context;
    |
 30 + use quick_error::ResultExt;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/lifecycle/behavior_tests.rs:442:5
    |
442 |     test!(test_error_includes_context, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
  9 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/lifecycle/behavior_tests.rs:469:5
    |
469 |     test!(test_sequential_workspace_execution, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
  9 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/lifecycle/behavior_tests.rs:499:5
    |
499 |     test!(test_workspace_failure_stops_pipeline, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
  9 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/lifecycle/behavior_tests.rs:520:5
    |
520 |     test!(test_workspace_isolation, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
  9 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/lifecycle/behavior_tests.rs:545:5
    |
545 |     test!(test_parallel_workspace_execution_contract, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
  9 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/lifecycle/behavior_tests.rs:570:5
    |
570 |     test!(test_full_phase_execution_contract, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
  9 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/lifecycle/behavior_tests.rs:631:5
    |
631 |     test!(test_cache_hit_skips_execution, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
  9 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/lifecycle/behavior_tests.rs:649:5
    |
649 |     test!(test_state_persistence_across_phases, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
  9 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
  --> crates/ggen-core/src/lifecycle/poka_yoke_runtime_tests.rs:19:5
   |
19 |     test!(test_complete_lifecycle_flow, {
   |     ^^^^
   |
   = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
   |
 9 +     use chicago_tdd_tools::test;
   |

error: cannot find macro `test` in this scope
  --> crates/ggen-core/src/lifecycle/poka_yoke_runtime_tests.rs:79:5
   |
79 |     test!(test_phase_builder_multiple_commands, {
   |     ^^^^
   |
   = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
   |
 9 +     use chicago_tdd_tools::test;
   |

error: cannot find macro `test` in this scope
  --> crates/ggen-core/src/lifecycle/poka_yoke_runtime_tests.rs:93:5
   |
93 |     test!(test_hook_validation_valid, {
   |     ^^^^
   |
   = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
   |
 9 +     use chicago_tdd_tools::test;
   |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/lifecycle/poka_yoke_runtime_tests.rs:144:5
    |
144 |     test!(test_hook_validation_invalid_phase, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
  9 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/lifecycle/poka_yoke_runtime_tests.rs:176:5
    |
176 |     test!(test_state_validation_inconsistent_history, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
  9 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/lifecycle/poka_yoke_runtime_tests.rs:187:5
    |
187 |     test!(test_state_validation_valid_history, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
  9 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/project_generator/common.rs:138:5
    |
138 |     test!(test_validate_project_name, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
135 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/project_generator/common.rs:149:5
    |
149 |     test!(test_generate_editorconfig, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
135 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/project_generator/nextjs.rs:368:5
    |
368 |     test!(test_generate_nextjs_project, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
364 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/project_generator/nextjs.rs:405:5
    |
405 |     test!(test_generate_nuxt_project, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
364 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/project_generator/rust.rs:325:5
    |
325 |     test!(test_generate_rust_web_project, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
322 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/project_generator/rust.rs:355:5
    |
355 |     test!(test_generate_rust_cli_project, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
322 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/project_generator/rust.rs:376:5
    |
376 |     test!(test_generate_rust_lib_project, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
322 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/project_generator/mod.rs:335:5
    |
335 |     test!(test_project_type_from_str, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
332 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/project_generator/mod.rs:346:5
    |
346 |     test!(test_project_type_display, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
332 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/rdf/schema.rs:688:5
    |
688 |     test!(test_ontology_uris, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
685 +     use chicago_tdd_tools::test;
    |

error[E0599]: no method named `context` found for enum `std::result::Result` in the current scope
  --> crates/ggen-core/tests/integration/lifecycle_clnrm_tests.rs:50:39
   |
50 |         let temp_dir = TempDir::new().context("Failed to create temporary directory")?;
   |                                       ^^^^^^^ method not found in `std::result::Result<tempfile::TempDir, std::io::Error>`
   |
   = help: items from traits can only be used if the trait is in scope
help: the following traits which provide `context` are implemented but not in scope; perhaps you want to import one of them
   |
 9 + use anyhow::Context;
   |
 9 + use quick_error::ResultExt;
   |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/rdf/schema.rs:707:5
    |
707 |     test!(test_load_schema, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
685 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/rdf/schema.rs:714:5
    |
714 |     test!(test_namespace_constants, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
685 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/rdf/template_metadata.rs:608:5
    |
608 |     test!(test_template_metadata_creation, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
605 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/rdf/template_metadata.rs:621:5
    |
621 |     test!(test_template_to_turtle, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
605 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/rdf/template_metadata.rs:638:5
    |
638 |     test!(test_metadata_store_operations, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
605 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/rdf/template_metadata.rs:659:5
    |
659 |     test!(test_find_by_category, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
605 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/rdf/template_metadata.rs:682:5
    |
682 |     test!(test_escape_literal, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
605 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/rdf/template_metadata.rs:689:5
    |
689 |     test!(test_template_variables, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
605 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/rdf/validation.rs:516:5
    |
516 |     test!(test_validate_valid_template, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
512 +     use chicago_tdd_tools::test;
    |

error[E0599]: no method named `with_context` found for enum `std::result::Result` in the current scope
   --> crates/ggen-core/tests/integration/lifecycle_clnrm_tests.rs:65:18
    |
 64 | /             fs::create_dir_all(parent)
 65 | |                 .with_context(|| format!("Failed to create directory {:?}", parent))?;
    | |_________________-^^^^^^^^^^^^
    |
    = help: items from traits can only be used if the trait is in scope
help: there is a method `with_current_context` with a similar name, but with different arguments
   --> /Users/sac/.asdf/installs/rust/1.86.0/registry/src/index.crates.io-1949cf8c6b5b557f/opentelemetry-0.21.0/src/trace/context.rs:459:5
    |
459 |     fn with_current_context(self) -> WithContext<Self> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
help: the following traits which provide `with_context` are implemented but not in scope; perhaps you want to import one of them
    |
  9 + use anyhow::Context;
    |
  9 + use opentelemetry::trace::context::FutureExt;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/rdf/validation.rs:533:5
    |
533 |     test!(test_validate_empty_name, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
512 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/rdf/validation.rs:544:5
    |
544 |     test!(test_validate_invalid_version, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
512 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/rdf/validation.rs:557:5
    |
557 |     test!(test_validate_invalid_stability, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
512 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/rdf/validation.rs:571:5
    |
571 |     test!(test_validate_variable_name, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
512 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/rdf/validation.rs:594:5
    |
594 |     test!(test_validate_variable_type, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
512 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/rdf/validation.rs:617:5
    |
617 |     test!(test_is_semantic_version, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
512 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/rdf/validation.rs:629:5
    |
629 |     test!(test_is_valid_identifier, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
512 +     use chicago_tdd_tools::test;
    |

error[E0599]: no method named `with_context` found for enum `std::result::Result` in the current scope
   --> crates/ggen-core/tests/integration/lifecycle_clnrm_tests.rs:68:14
    |
 67 | /         fs::write(&full_path, content)
 68 | |             .with_context(|| format!("Failed to write file {:?}", full_path))
    | |_____________-^^^^^^^^^^^^
    |
    = help: items from traits can only be used if the trait is in scope
help: there is a method `with_current_context` with a similar name, but with different arguments
   --> /Users/sac/.asdf/installs/rust/1.86.0/registry/src/index.crates.io-1949cf8c6b5b557f/opentelemetry-0.21.0/src/trace/context.rs:459:5
    |
459 |     fn with_current_context(self) -> WithContext<Self> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
help: the following traits which provide `with_context` are implemented but not in scope; perhaps you want to import one of them
    |
  9 + use anyhow::Context;
    |
  9 + use opentelemetry::trace::context::FutureExt;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/rdf/validation.rs:642:5
    |
642 |     test!(test_validation_report, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
512 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/templates/business_logic.rs:396:5
    |
396 |     test!(test_generate_cli_wrapper, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
393 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/templates/business_logic.rs:405:5
    |
405 |     test!(test_generate_domain_skeleton, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
393 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/templates/business_logic.rs:414:5
    |
414 |     test!(test_business_logic_exists, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
393 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/templates/business_logic.rs:429:5
    |
429 |     test!(test_generate_separated_files, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
393 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/templates/business_logic.rs:453:5
    |
453 |     test!(test_no_overwrite_existing_domain, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
393 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/templates/business_logic.rs:478:5
    |
478 |     test!(test_force_overwrite_domain, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
393 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/templates/business_logic.rs:503:5
    |
503 |     test!(test_to_pascal_case, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
393 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/templates/business_logic.rs:518:5
    |
518 |     test!(test_to_snake_case, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
393 +     use chicago_tdd_tools::test;
    |

error[E0599]: no method named `with_context` found for enum `std::result::Result` in the current scope
   --> crates/ggen-core/tests/integration/lifecycle_clnrm_tests.rs:77:14
    |
 73 | /         Command::new(cmd)
 74 | |             .args(args)
 75 | |             .current_dir(&self.project_path)
 76 | |             .output()
 77 | |             .with_context(|| format!("Failed to execute command: {} {:?}", cmd, args))
    | |_____________-^^^^^^^^^^^^
    |
    = help: items from traits can only be used if the trait is in scope
help: there is a method `with_current_context` with a similar name, but with different arguments
   --> /Users/sac/.asdf/installs/rust/1.86.0/registry/src/index.crates.io-1949cf8c6b5b557f/opentelemetry-0.21.0/src/trace/context.rs:459:5
    |
459 |     fn with_current_context(self) -> WithContext<Self> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
help: the following traits which provide `with_context` are implemented but not in scope; perhaps you want to import one of them
    |
  9 + use anyhow::Context;
    |
  9 + use opentelemetry::trace::context::FutureExt;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/simple_tracing.rs:349:5
    |
349 |     test!(test_trace_level_ordering, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
347 +     use chicago_tdd_tools::test;
    |

error: cannot find macro `test` in this scope
   --> crates/ggen-core/src/simple_tracing.rs:356:5
    |
356 |     test!(test_simple_timer, {
    |     ^^^^
    |
    = note: `test` is in scope, but it is an attribute: `#[test]`
help: consider importing this macro
    |
347 +     use chicago_tdd_tools::test;
    |

error[E0599]: no method named `with_context` found for enum `std::result::Result` in the current scope
   --> crates/ggen-core/tests/integration/lifecycle_tests.rs:33:39
    |
 33 |         let temp_dir = TempDir::new().with_context(|| "Failed to create temp directory")?;
    |                                       ^^^^^^^^^^^^
    |
    = help: items from traits can only be used if the trait is in scope
help: there is a method `with_current_context` with a similar name, but with different arguments
   --> /Users/sac/.asdf/installs/rust/1.86.0/registry/src/index.crates.io-1949cf8c6b5b557f/opentelemetry-0.21.0/src/trace/context.rs:459:5
    |
459 |     fn with_current_context(self) -> WithContext<Self> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
help: the following traits which provide `with_context` are implemented but not in scope; perhaps you want to import one of them
    |
 12 + use anyhow::Context;
    |
 12 + use opentelemetry::trace::context::FutureExt;
    |

error[E0599]: no method named `with_context` found for enum `std::result::Result` in the current scope
   --> crates/ggen-core/tests/integration/lifecycle_tests.rs:39:14
    |
 38 | /         fs::create_dir_all(state_path.parent().unwrap())
 39 | |             .with_context(|| "Failed to create .ggen directory")?;
    | |_____________-^^^^^^^^^^^^
    |
    = help: items from traits can only be used if the trait is in scope
help: there is a method `with_current_context` with a similar name, but with different arguments
   --> /Users/sac/.asdf/installs/rust/1.86.0/registry/src/index.crates.io-1949cf8c6b5b557f/opentelemetry-0.21.0/src/trace/context.rs:459:5
    |
459 |     fn with_current_context(self) -> WithContext<Self> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
help: the following traits which provide `with_context` are implemented but not in scope; perhaps you want to import one of them
    |
 12 + use anyhow::Context;
    |
 12 + use opentelemetry::trace::context::FutureExt;
    |

error[E0599]: no method named `with_context` found for enum `std::result::Result` in the current scope
   --> crates/ggen-core/tests/integration/lifecycle_tests.rs:52:14
    |
 51 | /         fs::write(&path, content)
 52 | |             .with_context(|| format!("Failed to write make.toml to {:?}", path))
    | |_____________-^^^^^^^^^^^^
    |
    = help: items from traits can only be used if the trait is in scope
help: there is a method `with_current_context` with a similar name, but with different arguments
   --> /Users/sac/.asdf/installs/rust/1.86.0/registry/src/index.crates.io-1949cf8c6b5b557f/opentelemetry-0.21.0/src/trace/context.rs:459:5
    |
459 |     fn with_current_context(self) -> WithContext<Self> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
help: the following traits which provide `with_context` are implemented but not in scope; perhaps you want to import one of them
    |
 12 + use anyhow::Context;
    |
 12 + use opentelemetry::trace::context::FutureExt;
    |

error[E0433]: failed to resolve: could not find `ValidationResult` in `ontology`
   --> crates/ggen-core/src/ontology/constitution.rs:371:53
    |
371 |         assert_eq!(receipt.result, crate::ontology::ValidationResult::Valid);
    |                                                     ^^^^^^^^^^^^^^^^ could not find `ValidationResult` in `ontology`
    |
help: a struct with a similar name exists
    |
371 -         assert_eq!(receipt.result, crate::ontology::ValidationResult::Valid);
371 +         assert_eq!(receipt.result, crate::ontology::ValidatorResult::Valid);
    |
help: consider importing one of these items
    |
294 +     use crate::ValidationResult;
    |
294 +     use crate::lifecycle::ValidationResult;
    |
294 +     use crate::ontology::sigma_runtime::ValidationResult;
    |
294 +     use crate::ontology::validators::ValidationResult;
    |
    = and 2 other candidates
help: if you import `ValidationResult`, refer to it directly
    |
371 -         assert_eq!(receipt.result, crate::ontology::ValidationResult::Valid);
371 +         assert_eq!(receipt.result, ValidationResult::Valid);
    |

error[E0433]: failed to resolve: use of undeclared type `ObservationSource`
   --> crates/ggen-core/src/ontology/control_loop.rs:378:21
    |
378 |             source: ObservationSource::Data,
    |                     ^^^^^^^^^^^^^^^^^ use of undeclared type `ObservationSource`
    |
help: consider importing this enum through its public re-export
    |
326 +     use crate::ObservationSource;
    |

error[E0433]: failed to resolve: use of undeclared type `ObservationSource`
   --> crates/ggen-core/src/ontology/control_loop.rs:400:25
    |
400 |                 source: ObservationSource::Data,
    |                         ^^^^^^^^^^^^^^^^^ use of undeclared type `ObservationSource`
    |
help: consider importing this enum through its public re-export
    |
326 +     use crate::ObservationSource;
    |

error[E0433]: failed to resolve: use of undeclared type `ObservationSource`
   --> crates/ggen-core/src/ontology/control_loop.rs:423:25
    |
423 |                 source: ObservationSource::Data,
    |                         ^^^^^^^^^^^^^^^^^ use of undeclared type `ObservationSource`
    |
help: consider importing this enum through its public re-export
    |
326 +     use crate::ObservationSource;
    |

error[E0433]: failed to resolve: use of undeclared type `ObservationSource`
   --> crates/ggen-core/src/ontology/control_loop.rs:449:25
    |
449 |                 source: ObservationSource::Data,
    |                         ^^^^^^^^^^^^^^^^^ use of undeclared type `ObservationSource`
    |
help: consider importing this enum through its public re-export
    |
326 +     use crate::ObservationSource;
    |

error[E0433]: failed to resolve: use of undeclared type `ValidationResult`
   --> crates/ggen-core/src/ontology/e2e_example.rs:329:36
    |
329 |         assert_eq!(receipt.result, ValidationResult::Valid);
    |                                    ^^^^^^^^^^^^^^^^ use of undeclared type `ValidationResult`
    |
help: a struct with a similar name exists
    |
329 -         assert_eq!(receipt.result, ValidationResult::Valid);
329 +         assert_eq!(receipt.result, ValidatorResult::Valid);
    |
help: consider importing one of these items
    |
 13 +     use crate::ValidationResult;
    |
 13 +     use crate::lifecycle::ValidationResult;
    |
 13 +     use crate::ontology::sigma_runtime::ValidationResult;
    |
 13 +     use crate::ontology::validators::ValidationResult;
    |
    = and 2 other candidates

error[E0433]: failed to resolve: use of undeclared type `TempDir`
   --> crates/ggen-core/src/simple_tracing.rs:363:24
    |
363 |         let temp_dir = TempDir::new().unwrap();
    |                        ^^^^^^^ use of undeclared type `TempDir`
    |
    = note: struct `crate::e2e_tests::tests::TempDir` exists but is inaccessible
help: consider importing one of these structs
    |
347 +     use chicago_tdd_tools::prelude::test_utils::TempDir;
    |
347 +     use tempfile::TempDir;
    |

error[E0433]: failed to resolve: use of unresolved module or unlinked crate `fs`
   --> crates/ggen-core/src/simple_tracing.rs:365:9
    |
365 |         fs::write(&test_path, "test content").unwrap();
    |         ^^ use of unresolved module or unlinked crate `fs`
    |
    = help: if you wanted to use a crate named `fs`, use `cargo add fs` to add it to your `Cargo.toml`
    = note: module `crate::templates::business_logic::tests::fs` exists but is inaccessible
help: consider importing one of these modules
    |
347 +     use std::fs;
    |
347 +     use tokio::fs;
    |

error[E0599]: no method named `with_context` found for enum `std::result::Result` in the current scope
   --> crates/ggen-core/tests/integration/lifecycle_tests.rs:60:18
    |
 59 | /             fs::create_dir_all(parent)
 60 | |                 .with_context(|| format!("Failed to create directory {:?}", parent))?;
    | |_________________-^^^^^^^^^^^^
    |
    = help: items from traits can only be used if the trait is in scope
help: there is a method `with_current_context` with a similar name, but with different arguments
   --> /Users/sac/.asdf/installs/rust/1.86.0/registry/src/index.crates.io-1949cf8c6b5b557f/opentelemetry-0.21.0/src/trace/context.rs:459:5
    |
459 |     fn with_current_context(self) -> WithContext<Self> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
help: the following traits which provide `with_context` are implemented but not in scope; perhaps you want to import one of them
    |
 12 + use anyhow::Context;
    |
 12 + use opentelemetry::trace::context::FutureExt;
    |

error: unused attribute `ignore`
   --> crates/ggen-core/src/github.rs:551:5
    |
551 |     #[ignore] // Requires network access
    |     ^^^^^^^^^
    |
note: the built-in attribute `ignore` will be ignored, since it's applied to the macro invocation `async_test`
   --> crates/ggen-core/src/github.rs:552:5
    |
552 |     async_test!(test_github_client_creation, {
    |     ^^^^^^^^^^
note: the lint level is defined here
   --> crates/ggen-core/src/lib.rs:114:9
    |
114 | #![deny(warnings)] // Poka-Yoke: Prevent warnings at compile time - compiler enforces correctness
    |         ^^^^^^^^
    = note: `#[deny(unused_attributes)]` implied by `#[deny(warnings)]`

error: unused doc comment
  --> crates/ggen-core/src/graph/core_fs_tests.rs:17:5
   |
17 |     /// Test loading RDF from file
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ rustdoc does not generate documentation for macro invocations
   |
   = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion
   = note: `#[deny(unused_doc_comments)]` implied by `#[deny(warnings)]`

error: unused doc comment
  --> crates/ggen-core/src/graph/core_fs_tests.rs:40:5
   |
40 |     /// Test loading from path with different formats
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ rustdoc does not generate documentation for macro invocations
   |
   = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion

error: unused doc comment
  --> crates/ggen-core/src/graph/core_fs_tests.rs:64:5
   |
64 |     /// Test loading from non-existent file returns error
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ rustdoc does not generate documentation for macro invocations
   |
   = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion

error: unused imports: `ContainerClient`, `GenericContainer`, and `exec::SUCCESS_EXIT_CODE`
  --> crates/ggen-core/src/graph/core_fs_tests.rs:11:9
   |
11 |         exec::SUCCESS_EXIT_CODE, ContainerClient, GenericContainer,
   |         ^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^
   |
   = note: `#[deny(unused_imports)]` implied by `#[deny(warnings)]`

error: unused doc comment
  --> crates/ggen-core/src/graph/export_tests.rs:18:5
   |
18 |     /// Test exporting graph to file
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ rustdoc does not generate documentation for macro invocations
   |
   = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion

error: unused doc comment
  --> crates/ggen-core/src/graph/export_tests.rs:47:5
   |
47 |     /// Test exporting to string
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ rustdoc does not generate documentation for macro invocations
   |
   = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion

error: unused doc comment
  --> crates/ggen-core/src/graph/export_tests.rs:69:5
   |
69 |     /// Test auto-detection of format from extension
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ rustdoc does not generate documentation for macro invocations
   |
   = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion

error: unused imports: `ContainerClient`, `GenericContainer`, and `exec::SUCCESS_EXIT_CODE`
  --> crates/ggen-core/src/graph/export_tests.rs:12:9
   |
12 |         exec::SUCCESS_EXIT_CODE, ContainerClient, GenericContainer,
   |         ^^^^^^^^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^

error: unused doc comment
  --> crates/ggen-core/src/graph/store_tests.rs:17:5
   |
17 |     /// Test persistent storage creation and retrieval
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ rustdoc does not generate documentation for macro invocations
   |
   = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion

error: unused doc comment
  --> crates/ggen-core/src/graph/store_tests.rs:42:5
   |
42 |     /// Test that data persists across store reopen
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ rustdoc does not generate documentation for macro invocations
   |
   = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion

error: unused doc comment
  --> crates/ggen-core/src/graph/store_tests.rs:72:5
   |
72 |     /// Test multiple graphs from same store share data
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ rustdoc does not generate documentation for macro invocations
   |
   = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion

error: unused import: `super::super::core::Graph`
 --> crates/ggen-core/src/graph/store_tests.rs:8:9
  |
8 |     use super::super::core::Graph;
  |         ^^^^^^^^^^^^^^^^^^^^^^^^^

error: unused imports: `ContainerClient`, `GenericContainer`, and `TestcontainersResult`
  --> crates/ggen-core/src/graph/store_tests.rs:12:9
   |
12 |         ContainerClient, GenericContainer, TestcontainersResult,
   |         ^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^  ^^^^^^^^^^^^^^^^^^^^

error: unused import: `std::path::PathBuf`
  --> crates/ggen-core/src/graph/store_tests.rs:14:9
   |
14 |     use std::path::PathBuf;
   |         ^^^^^^^^^^^^^^^^^^

error: unused import: `std::path::PathBuf`
  --> crates/ggen-core/src/lifecycle/behavior_tests.rs:13:9
   |
13 |     use std::path::PathBuf;
   |         ^^^^^^^^^^^^^^^^^^

error: unused doc comment
  --> crates/ggen-core/src/lifecycle/poka_yoke_tests.rs:14:5
   |
14 |     /// Test that phase builder requires at least one command
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ rustdoc does not generate documentation for macro invocations
   |
   = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion

error: unused doc comment
  --> crates/ggen-core/src/lifecycle/poka_yoke_tests.rs:28:5
   |
28 |     /// Test that validated phase has commands
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ rustdoc does not generate documentation for macro invocations
   |
   = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion

error: unused doc comment
  --> crates/ggen-core/src/lifecycle/poka_yoke_tests.rs:44:5
   |
44 |     /// Test state machine valid transitions
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ rustdoc does not generate documentation for macro invocations
   |
   = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion

error: unused doc comment
  --> crates/ggen-core/src/lifecycle/poka_yoke_tests.rs:96:5
   |
96 |     /// Test that state validation catches invalid state
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ rustdoc does not generate documentation for macro invocations
   |
   = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion

error: unused doc comment
   --> crates/ggen-core/src/lifecycle/poka_yoke_tests.rs:110:5
    |
110 |     /// Test that validated state can be created from valid state
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ rustdoc does not generate documentation for macro invocations
    |
    = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion

error: unused doc comment
  --> crates/ggen-core/src/lifecycle/poka_yoke_runtime_tests.rs:18:5
   |
18 |     /// Test complete lifecycle flow with state machine
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ rustdoc does not generate documentation for macro invocations
   |
   = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion

error: unused doc comment
  --> crates/ggen-core/src/lifecycle/poka_yoke_runtime_tests.rs:78:5
   |
78 |     /// Test phase builder with multiple commands
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ rustdoc does not generate documentation for macro invocations
   |
   = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion

error: unused doc comment
  --> crates/ggen-core/src/lifecycle/poka_yoke_runtime_tests.rs:92:5
   |
92 |     /// Test hook validation with valid hooks
   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ rustdoc does not generate documentation for macro invocations
   |
   = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion

error: unused doc comment
   --> crates/ggen-core/src/lifecycle/poka_yoke_runtime_tests.rs:143:5
    |
143 |     /// Test hook validation catches invalid phase reference
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ rustdoc does not generate documentation for macro invocations
    |
    = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion

error: unused doc comment
   --> crates/ggen-core/src/lifecycle/poka_yoke_runtime_tests.rs:175:5
    |
175 |     /// Test state validation with inconsistent history
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ rustdoc does not generate documentation for macro invocations
    |
    = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion

error: unused doc comment
   --> crates/ggen-core/src/lifecycle/poka_yoke_runtime_tests.rs:186:5
    |
186 |     /// Test state validation with valid history
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ rustdoc does not generate documentation for macro invocations
    |
    = help: to document an item produced by a macro, the macro must produce the documentation as part of its expansion

error: unused imports: `Hooks`, `Make`, `PhaseBuilder`, `Project`, `hooks::validate_hooks`, `state::LifecycleState`, `state_machine::*`, and `state_validation::ValidatedLifecycleState`
  --> crates/ggen-core/src/lifecycle/poka_yoke_runtime_tests.rs:10:9
   |
10 |         hooks::validate_hooks,
   |         ^^^^^^^^^^^^^^^^^^^^^
11 |         model::{Hooks, Make, PhaseBuilder, Project},
   |                 ^^^^^  ^^^^  ^^^^^^^^^^^^  ^^^^^^^
12 |         state::LifecycleState,
   |         ^^^^^^^^^^^^^^^^^^^^^
13 |         state_machine::*,
   |         ^^^^^^^^^^^^^^^^
14 |         state_validation::ValidatedLifecycleState,
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

error: unused import: `std::collections::BTreeMap`
  --> crates/ggen-core/src/lifecycle/poka_yoke_runtime_tests.rs:16:9
   |
16 |     use std::collections::BTreeMap;
   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^

error: unused import: `OntologyStats`
   --> crates/ggen-core/src/ontology/delta_proposer.rs:397:42
    |
397 |     use crate::ontology::pattern_miner::{OntologyStats, ProposedChange};
    |                                          ^^^^^^^^^^^^^

error: unused attribute `ignore`
   --> crates/ggen-core/src/poc.rs:348:5
    |
348 |     #[ignore = "POC feature - experimental, not production critical"]
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
note: the built-in attribute `ignore` will be ignored, since it's applied to the macro invocation `test`
   --> crates/ggen-core/src/poc.rs:349:5
    |
349 |     test!(poc_with_prefixes_and_inline_rdf, {
    |     ^^^^

error: unused import: `super::*`
   --> crates/ggen-core/src/project_generator/common.rs:135:9
    |
135 |     use super::*;
    |         ^^^^^^^^

error: unused import: `chicago_tdd_tools::prelude::*`
   --> crates/ggen-core/src/project_generator/common.rs:136:9
    |
136 |     use chicago_tdd_tools::prelude::*;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

error: unused import: `super::*`
   --> crates/ggen-core/src/project_generator/nextjs.rs:364:9
    |
364 |     use super::*;
    |         ^^^^^^^^

error: unused import: `chicago_tdd_tools::prelude::*`
   --> crates/ggen-core/src/project_generator/nextjs.rs:365:9
    |
365 |     use chicago_tdd_tools::prelude::*;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

error: unused import: `std::path::PathBuf`
   --> crates/ggen-core/src/project_generator/nextjs.rs:366:9
    |
366 |     use std::path::PathBuf;
    |         ^^^^^^^^^^^^^^^^^^

error: unused import: `super::*`
   --> crates/ggen-core/src/project_generator/rust.rs:322:9
    |
322 |     use super::*;
    |         ^^^^^^^^

error: unused import: `std::path::PathBuf`
   --> crates/ggen-core/src/project_generator/rust.rs:323:9
    |
323 |     use std::path::PathBuf;
    |         ^^^^^^^^^^^^^^^^^^

error: unused import: `super::*`
   --> crates/ggen-core/src/project_generator/mod.rs:332:9
    |
332 |     use super::*;
    |         ^^^^^^^^

error: unused import: `chicago_tdd_tools::prelude::*`
   --> crates/ggen-core/src/project_generator/mod.rs:333:9
    |
333 |     use chicago_tdd_tools::prelude::*;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

error: unused import: `super::*`
   --> crates/ggen-core/src/rdf/schema.rs:685:9
    |
685 |     use super::*;
    |         ^^^^^^^^

error: unused import: `chicago_tdd_tools::prelude::*`
   --> crates/ggen-core/src/rdf/schema.rs:686:9
    |
686 |     use chicago_tdd_tools::prelude::*;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

error: unused import: `super::*`
   --> crates/ggen-core/src/rdf/template_metadata.rs:605:9
    |
605 |     use super::*;
    |         ^^^^^^^^

error: unused import: `chicago_tdd_tools::prelude::*`
   --> crates/ggen-core/src/rdf/template_metadata.rs:606:9
    |
606 |     use chicago_tdd_tools::prelude::*;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

error: unused import: `super::*`
   --> crates/ggen-core/src/rdf/validation.rs:512:9
    |
512 |     use super::*;
    |         ^^^^^^^^

error: unused import: `crate::rdf::template_metadata::TemplateVariable`
   --> crates/ggen-core/src/rdf/validation.rs:513:9
    |
513 |     use crate::rdf::template_metadata::TemplateVariable;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

error: unused import: `chicago_tdd_tools::prelude::*`
   --> crates/ggen-core/src/rdf/validation.rs:514:9
    |
514 |     use chicago_tdd_tools::prelude::*;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

error: unused import: `chicago_tdd_tools::prelude::*`
   --> crates/ggen-core/src/registry.rs:642:9
    |
642 |     use chicago_tdd_tools::prelude::*;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

error: unused import: `Error`
   --> crates/ggen-core/src/template.rs:518:29
    |
518 |     use ggen_utils::error::{Error, Result};
    |                             ^^^^^

error: unused import: `super::*`
   --> crates/ggen-core/src/templates/business_logic.rs:393:9
    |
393 |     use super::*;
    |         ^^^^^^^^

error: unused import: `tempfile::TempDir`
   --> crates/ggen-core/src/templates/business_logic.rs:394:9
    |
394 |     use tempfile::TempDir;
    |         ^^^^^^^^^^^^^^^^^

error: unused attribute `ignore`
   --> crates/ggen-core/src/templates/frozen.rs:562:5
    |
562 |     #[ignore = "Frozen section merging needs implementation review - v2.0.1"]
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
note: the built-in attribute `ignore` will be ignored, since it's applied to the macro invocation `test`
   --> crates/ggen-core/src/templates/frozen.rs:563:5
    |
563 |     test!(test_merge_with_frozen, {
    |     ^^^^

error: unused attribute `ignore`
   --> crates/ggen-core/src/templates/frozen.rs:611:5
    |
611 |     #[ignore = "Frozen section merging needs implementation review - v2.0.1"]
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
note: the built-in attribute `ignore` will be ignored, since it's applied to the macro invocation `test`
   --> crates/ggen-core/src/templates/frozen.rs:612:5
    |
612 |     test!(test_merge_numbered_sections, {
    |     ^^^^

error[E0599]: no method named `with_context` found for enum `std::result::Result` in the current scope
   --> crates/ggen-core/tests/integration/lifecycle_tests.rs:62:35
    |
 62 |         fs::write(&path, content).with_context(|| format!("Failed to write file {:?}", path))
    |                                   ^^^^^^^^^^^^
    |
    = help: items from traits can only be used if the trait is in scope
help: there is a method `with_current_context` with a similar name, but with different arguments
   --> /Users/sac/.asdf/installs/rust/1.86.0/registry/src/index.crates.io-1949cf8c6b5b557f/opentelemetry-0.21.0/src/trace/context.rs:459:5
    |
459 |     fn with_current_context(self) -> WithContext<Self> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
help: the following traits which provide `with_context` are implemented but not in scope; perhaps you want to import one of them
    |
 12 + use anyhow::Context;
    |
 12 + use opentelemetry::trace::context::FutureExt;
    |

warning: unused variable: `container_path`
   --> crates/ggen-core/tests/integration/lifecycle_clnrm_tests.rs:486:9
    |
486 |     let container_path = {
    |         ^^^^^^^^^^^^^^ help: if this is intentional, prefix it with an underscore: `_container_path`
    |
    = note: `#[warn(unused_variables)]` on by default

warning: unused variable: `container`
   --> crates/ggen-core/tests/integration/lifecycle_clnrm_tests.rs:737:31
    |
737 |     pub fn run_full_lifecycle(container: &ClnrmContainer) -> Result<Vec<String>> {
    |                               ^^^^^^^^^ help: if this is intentional, prefix it with an underscore: `_container`

Some errors have detailed explanations: E0432, E0433, E0599.
warning: `ggen-core` (test "marketplace_tests_main") generated 49 warnings
error: could not compile `ggen-core` (test "marketplace_tests_main") due to 151 previous errors; 49 warnings emitted
error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/delta.rs:825:5
    |
825 | /     test!(test_delta_creation, {
826 | |         let (baseline, current) = create_test_graph().unwrap();
827 | |         let delta = GraphDelta::new(&baseline, &current).unwrap();
...   |
836 | |         assert_eq!(counts.get("modifications"), None); // No modifications
837 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/delta.rs:839:5
    |
839 | /     test!(test_delta_affected_iris, {
840 | |         let (baseline, current) = create_test_graph().unwrap();
841 | |         let delta = GraphDelta::new(&baseline, &current).unwrap();
...   |
846 | |         assert!(affected.contains("<http://www.w3.org/2000/01/rdf-schema#domain>"));
847 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/delta.rs:849:5
    |
849 | /     test!(test_delta_filtering, {
850 | |         let (baseline, current) = create_test_graph()?;
851 | |         let delta = GraphDelta::new(&baseline, &current)?;
...   |
859 | |         Ok(())
860 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/delta.rs:862:5
    |
862 | /     test!(test_impact_analyzer, {
863 | |         let (baseline, current) = create_test_graph().unwrap();
864 | |         let delta = GraphDelta::new(&baseline, &current).unwrap();
...   |
881 | |         Ok(())
882 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/delta.rs:884:5
    |
884 | /     test!(test_graph_hash, {
885 | |         let (baseline, current) = create_test_graph().unwrap();
886 | |
887 | |         let hash1 = baseline.compute_hash().unwrap();
...   |
897 | |         Ok(())
898 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/delta.rs:900:5
    |
900 | /     test!(test_delta_display, {
901 | |         let (baseline, current) = create_test_graph().unwrap();
902 | |         let delta = GraphDelta::new(&baseline, &current).unwrap();
...   |
909 | |         Ok(())
910 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/e2e_tests.rs:46:5
    |
 46 | /     test!(test_end_to_end_template_generation, {
 47 | |         // Create a temporary directory for testing
 48 | |         let temp_dir = TempDir::new()?;
 49 | |         let output_dir = temp_dir.path().join("output");
...   |
 94 | |         Ok(())
 95 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/e2e_tests.rs:97:5
    |
 97 | /     test!(test_end_to_end_with_rdf_data, {
 98 | |         let temp_dir = TempDir::new()?;
 99 | |         let output_dir = temp_dir.path().join("output");
100 | |         std::fs::create_dir_all(&output_dir)?;
...   |
160 | |         Ok(())
161 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/e2e_tests.rs:163:5
    |
163 | /     test!(test_end_to_end_deterministic_output, {
164 | |         let temp_dir = TempDir::new()?;
165 | |         let output_dir1 = temp_dir.path().join("output1");
166 | |         let output_dir2 = temp_dir.path().join("output2");
...   |
213 | |         Ok(())
214 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/e2e_tests.rs:216:5
    |
216 | /     test!(test_end_to_end_error_handling, {
217 | |         let temp_dir = TempDir::new()?;
218 | |         let output_dir = temp_dir.path().join("output");
219 | |         std::fs::create_dir_all(&output_dir)?;
...   |
252 | |         Ok(())
253 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/generator.rs:450:5
    |
450 | /     test!(test_gen_context_new, {
451 | |         let template_path = PathBuf::from("test.tmpl");
452 | |         let output_root = PathBuf::from("output");
...   |
461 | |         assert!(!ctx.dry_run);
462 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/generator.rs:464:5
    |
464 | /     test!(test_gen_context_with_vars, {
465 | |         let template_path = PathBuf::from("test.tmpl");
466 | |         let output_root = PathBuf::from("output");
467 | |         let mut vars = BTreeMap::new();
...   |
473 | |         assert_eq!(ctx.vars, vars);
474 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/generator.rs:476:5
    |
476 | /     test!(test_gen_context_with_prefixes, {
477 | |         let template_path = PathBuf::from("test.tmpl");
478 | |         let output_root = PathBuf::from("output");
479 | |         let mut prefixes = BTreeMap::new();
...   |
487 | |         assert_eq!(ctx.base, base);
488 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/generator.rs:490:5
    |
490 | /     test!(test_gen_context_dry, {
491 | |         let template_path = PathBuf::from("test.tmpl");
492 | |         let output_root = PathBuf::from("output");
...   |
498 | |         assert!(!ctx.dry_run);
499 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/generator.rs:501:5
    |
501 | /     test!(test_generator_new, {
502 | |         let pipeline = create_test_pipeline();
503 | |         let template_path = PathBuf::from("test.tmpl");
504 | |         let output_root = PathBuf::from("output");
...   |
519 | |             .contains("output"));
520 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/generator.rs:522:5
    |
522 | /     test!(test_generate_simple_template, {
523 | |         let (_temp_dir, template_path) = create_test_template(
524 | |             r#"---
525 | | to: "output/{{ name | lower }}.rs"
...   |
555 | |         assert!(content.contains("// Description: A test application"));
556 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/generator.rs:558:5
    |
558 | /     test!(test_generate_dry_run, {
559 | |         let (_temp_dir, template_path) = create_test_template(
560 | |             r#"---
561 | | to: "output/{{ name | lower }}.rs"
...   |
584 | |         assert!(!output_path.exists());
585 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/generator.rs:587:5
    |
587 | /     test!(test_generate_with_default_output, {
588 | |         let (_temp_dir, template_path) = create_test_template(
589 | |             r#"---
590 | | {}
...   |
612 | |         assert!(content.contains("// Default output content"));
613 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/generator.rs:615:5
    |
615 | /     test!(test_generate_with_nested_output_path, {
616 | |         let (_temp_dir, template_path) = create_test_template(
617 | |             r#"---
618 | | to: "src/{{ module }}/{{ name | lower }}.rs"
...   |
642 | |         assert!(content.contains("// Nested output content"));
643 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/generator.rs:645:5
    |
645 | /     test!(test_generate_invalid_template, {
646 | |         let (_temp_dir, template_path) = create_test_template(
647 | |             r#"---
648 | | invalid_yaml: [unclosed
...   |
662 | |         assert!(result.is_err());
663 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/generator.rs:665:5
    |
665 | /     test!(test_generate_missing_template_file, {
666 | |         let temp_dir = TempDir::new().expect("Failed to create temp dir");
667 | |         let template_path = temp_dir.path().join("nonexistent.tmpl");
668 | |         let output_dir = temp_dir.path();
...   |
677 | |         assert!(result.is_err());
678 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/generator.rs:680:5
    |
680 | /     test!(test_insert_env, {
681 | |         let mut ctx = Context::new();
...   |
692 | |         std::env::remove_var("TEST_GGEN_VAR");
693 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/github.rs:539:5
    |
539 | /     test!(test_repo_info_parse, {
540 | |         let repo = RepoInfo::parse("seanchatmangpt/ggen").unwrap();
541 | |         assert_eq!(repo.owner, "seanchatmangpt");
542 | |         assert_eq!(repo.name, "ggen");
543 | |         assert_eq!(repo.as_str(), "seanchatmangpt/ggen");
544 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/github.rs:546:5
    |
546 | /     test!(test_repo_info_parse_invalid, {
547 | |         assert!(RepoInfo::parse("invalid").is_err());
548 | |         assert!(RepoInfo::parse("too/many/parts").is_err());
549 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/gpack.rs:310:5
    |
310 | /     test!(test_manifest_parsing, {
311 | |         let toml_content = r#"
312 | | [gpack]
313 | | id = "io.ggen.rust.cli-subcommand"
...   |
352 | |         assert_eq!(manifest.queries.aliases.len(), 1);
353 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/gpack.rs:355:5
    |
355 | /     test!(test_manifest_load_from_file, {
356 | |         let mut temp_file = NamedTempFile::new().unwrap();
357 | |         let toml_content = r#"
358 | | [gpack]
...   |
369 | |         assert_eq!(manifest.metadata.id, "test");
370 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/graph/core.rs:731:5
    |
731 | /     test!(test_graph_new, {
732 | |         // Arrange & Act
733 | |         let graph = Graph::new().unwrap();
...   |
737 | |         assert_eq!(graph.len(), 0);
738 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/graph/core.rs:740:5
    |
740 | /     test!(test_graph_insert_turtle, {
741 | |         // Arrange
742 | |         let graph = Graph::new().unwrap();
...   |
756 | |         assert!(graph.len() > 0);
757 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/graph/core.rs:759:5
    |
759 | /     test!(test_graph_query_cached, {
760 | |         // Arrange
761 | |         let graph = Graph::new().unwrap();
762 | |         graph
...   |
785 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/graph/core.rs:787:5
    |
787 | /     test!(test_build_prolog_with_prefixes, {
788 | |         // Arrange
789 | |         let mut prefixes = BTreeMap::new();
790 | |         prefixes.insert("ex".to_string(), "http://example.org/".to_string());
...   |
801 | |         assert!(prolog.contains("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>"));
802 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/graph/core.rs:804:5
    |
804 | /     test!(test_build_prolog_with_base, {
805 | |         // Arrange
806 | |         let prefixes = BTreeMap::new();
...   |
812 | |         assert!(prolog.contains("BASE <http://example.org/>"));
813 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/graph/export.rs:191:5
    |
191 | /     test!(test_export_write_to_file, {
192 | |         // Arrange
193 | |         let graph = Graph::new().unwrap();
194 | |         graph
...   |
214 | |         assert!(content.contains("ex:Person"));
215 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/graph/export.rs:217:5
    |
217 | /     test!(test_export_write_to_string_turtle, {
218 | |         // Arrange
219 | |         let graph = Graph::new().unwrap();
220 | |         graph
...   |
236 | |         assert!(result.contains("ex:") || result.contains("http://example.org/"));
237 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/graph/export.rs:239:5
    |
239 | /     test!(test_export_write_to_string_ntriples, {
240 | |         // Arrange
241 | |         let graph = Graph::new().unwrap();
242 | |         graph
...   |
258 | |         assert!(result.contains("http://example.org/alice"));
259 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/graph/export.rs:261:5
    |
261 | /     test!(test_export_write_to_string_rdfxml, {
262 | |         // Arrange
263 | |         let graph = Graph::new().unwrap();
264 | |         graph
...   |
280 | |         assert!(result.contains("<") && result.contains(">"));
281 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/graph/export.rs:283:5
    |
283 | /     test!(test_export_write_to_file_auto_turtle, {
284 | |         // Arrange
285 | |         let graph = Graph::new().unwrap();
286 | |         graph
...   |
304 | |         assert!(!content.is_empty());
305 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/graph/export.rs:307:5
    |
307 | /     test!(test_export_write_to_file_auto_ntriples, {
308 | |         // Arrange
309 | |         let graph = Graph::new().unwrap();
310 | |         graph
...   |
328 | |         assert!(!content.is_empty());
329 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/graph/export.rs:331:5
    |
331 | /     test!(test_export_write_to_file_auto_unsupported_format, {
332 | |         // Arrange
333 | |         let graph = Graph::new().unwrap();
334 | |         let export = GraphExport::new(&graph);
...   |
341 | |         assert!(result.unwrap_err().to_string().contains("unsupported"));
342 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/graph/export.rs:344:5
    |
344 | /     test!(test_export_format_specific_serialization, {
345 | |         // Arrange
346 | |         let graph = Graph::new().unwrap();
347 | |         graph
...   |
371 | |         assert!(turtle != ntriples || turtle != rdfxml || ntriples != rdfxml);
372 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/graph/export.rs:374:5
    |
374 | /     test!(test_export_turtle_format_preserves_prefixes, {
375 | |         // Arrange
376 | |         let graph = Graph::new().unwrap();
377 | |         graph
...   |
394 | |         assert!(turtle.contains("alice") || turtle.contains("Alice"));
395 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/graph/export.rs:397:5
    |
397 | /     test!(test_export_ntriples_format_uses_full_iris, {
398 | |         // Arrange
399 | |         let graph = Graph::new().unwrap();
400 | |         graph
...   |
415 | |         assert!(ntriples.contains("http://example.org/Person"));
416 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/graph/export.rs:418:5
    |
418 | /     test!(test_export_rdfxml_format_has_xml_structure, {
419 | |         // Arrange
420 | |         let graph = Graph::new().unwrap();
421 | |         graph
...   |
436 | |         assert!(rdfxml.contains("rdf:") || rdfxml.contains("RDF"));
437 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/graph/export.rs:439:5
    |
439 | /     test!(test_export_trig_format_supports_named_graphs, {
440 | |         // Arrange
441 | |         let graph = Graph::new().unwrap();
442 | |         graph
...   |
459 | |         assert!(trig.contains("http://example.org/graph1") || trig.contains("alice"));
460 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/graph/export.rs:462:5
    |
462 | /     test!(test_export_nquads_format_includes_graph_context, {
463 | |         // Arrange
464 | |         let graph = Graph::new().unwrap();
465 | |         graph
...   |
482 | |         assert!(nquads.contains("http://example.org/graph1") || nquads.contains("alice"));
483 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/graph/export.rs:485:5
    |
485 | /     test!(test_export_empty_graph, {
486 | |         // Arrange
487 | |         let graph = Graph::new().unwrap();
488 | |         let export = GraphExport::new(&graph);
...   |
496 | |         assert!(result.is_empty() || !result.is_empty());
497 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/graph/query.rs:115:5
    |
115 | /     test!(test_query_execute_cached, {
116 | |         // Arrange
117 | |         let graph = Graph::new().unwrap();
118 | |         graph
...   |
141 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/graph/query.rs:143:5
    |
143 | /     test!(test_query_execute, {
144 | |         // Arrange
145 | |         let graph = Graph::new().unwrap();
146 | |         graph
...   |
166 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/graph/query.rs:168:5
    |
168 | /     test!(test_query_execute_with_prefixes, {
169 | |         // Arrange
170 | |         let graph = Graph::new().unwrap();
171 | |         graph
...   |
193 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/graph/query.rs:195:5
    |
195 | /     test!(test_query_execute_with_base, {
196 | |         // Arrange
197 | |         let graph = Graph::new().unwrap();
198 | |         graph
...   |
223 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/graph/query.rs:225:5
    |
225 | /     test!(test_query_execute_prepared, {
226 | |         // Arrange
227 | |         let graph = Graph::new().unwrap();
228 | |         graph
...   |
248 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/graph/query.rs:250:5
    |
250 | /     test!(test_query_builder, {
251 | |         // Arrange
252 | |         let graph = Graph::new().unwrap();
253 | |         graph
...   |
277 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/graph/query.rs:279:5
    |
279 | /     test!(test_query_ask_query, {
280 | |         // Arrange
281 | |         let graph = Graph::new().unwrap();
282 | |         graph
...   |
300 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/graph/query.rs:302:5
    |
302 | /     test!(test_query_invalid_syntax, {
303 | |         // Arrange
304 | |         let graph = Graph::new().unwrap();
305 | |         let query = GraphQuery::new(&graph);
...   |
309 | |         assert!(result.is_err());
310 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/graph/store.rs:107:5
    |
107 | /     test!(test_store_new, {
108 | |         // Arrange & Act
109 | |         let store = GraphStore::new().unwrap();
...   |
113 | |         assert!(graph.is_empty());
114 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/graph/store.rs:116:5
    |
116 | /     test!(test_store_open_and_create_graph, {
117 | |         // Arrange
118 | |         let temp_dir = TempDir::new().unwrap();
119 | |         let store_path = temp_dir.path().join("test_store");
...   |
127 | |         assert!(store_path.exists() || !store_path.exists()); // Store may or may not create directory immediately
128 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/graph/store.rs:130:5
    |
130 | /     test!(test_store_create_graph_and_insert, {
131 | |         // Arrange
132 | |         let store = GraphStore::new().unwrap();
133 | |         let graph = store.create_graph().unwrap();
...   |
147 | |         assert!(graph.len() > 0);
148 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/graph/store.rs:150:5
    |
150 | /     test!(test_store_multiple_graphs_share_data, {
151 | |         // Arrange
152 | |         let store = GraphStore::new().unwrap();
153 | |         let graph1 = store.create_graph().unwrap();
...   |
170 | |         assert_eq!(graph1.len(), graph2.len());
171 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/graph/store.rs:173:5
    |
173 | /     test!(test_store_persistent_storage, {
174 | |         // Arrange
175 | |         let temp_dir = TempDir::new().unwrap();
176 | |         let store_path = temp_dir.path().join("persistent_store");
...   |
199 | |         assert!(!graph2.is_empty());
200 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/graph/store.rs:202:5
    |
202 | /     test!(test_store_inner_access, {
203 | |         // Arrange
204 | |         let store = GraphStore::new().unwrap();
...   |
210 | |         assert_eq!(inner.len().unwrap_or(0), 0);
211 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/graph/store.rs:213:5
    |
213 | /     test!(test_store_resource_cleanup, {
214 | |         // Arrange
215 | |         let temp_dir = TempDir::new().unwrap();
216 | |         let store_path = temp_dir.path().join("cleanup_test");
...   |
238 | |         assert!(graph2.len() > 0);
239 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/graph/update.rs:245:5
    |
245 | /     test!(test_update_insert, {
246 | |         // Arrange
247 | |         let graph = Graph::new().unwrap();
248 | |         let update = GraphUpdate::new(&graph);
...   |
269 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/graph/update.rs:271:5
    |
271 | /     test!(test_update_delete, {
272 | |         // Arrange
273 | |         let graph = Graph::new().unwrap();
274 | |         graph
...   |
291 | |         assert!(graph.len() < initial_len);
292 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/graph/update.rs:294:5
    |
294 | /     test!(test_update_delete_where, {
295 | |         // Arrange
296 | |         let graph = Graph::new().unwrap();
297 | |         graph
...   |
323 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/graph/update.rs:325:5
    |
325 | /     test!(test_update_update_operation, {
326 | |         // Arrange
327 | |         let graph = Graph::new().unwrap();
328 | |         graph
...   |
356 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/graph/update.rs:358:5
    |
358 | /     test!(test_update_clear, {
359 | |         // Arrange
360 | |         let graph = Graph::new().unwrap();
361 | |         graph
...   |
376 | |         assert!(graph.is_empty());
377 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/graph/update.rs:379:5
    |
379 | /     test!(test_update_clear_graph, {
380 | |         // Arrange
381 | |         let graph = Graph::new().unwrap();
382 | |         graph
...   |
398 | |         assert!(graph.len() < initial_len);
399 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/graph/update.rs:401:5
    |
401 | /     test!(test_update_clear_all, {
402 | |         // Arrange
403 | |         let graph = Graph::new().unwrap();
404 | |         graph
...   |
419 | |         assert!(graph.is_empty());
420 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/graph/update.rs:422:5
    |
422 | /     test!(test_update_execute_invalid_syntax, {
423 | |         // Arrange
424 | |         let graph = Graph::new().unwrap();
425 | |         let update = GraphUpdate::new(&graph);
...   |
430 | |         assert!(result.unwrap_err().to_string().contains("SPARQL Update"));
431 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/graph/update.rs:433:5
    |
433 | /     test!(test_update_copy, {
434 | |         // Arrange
435 | |         let graph = Graph::new().unwrap();
436 | |         graph
...   |
466 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/inject.rs:329:5
    |
329 | /     test!(test_detect_eol_crlf, {
330 | |         let temp_file = NamedTempFile::new()?;
331 | |         fs::write(temp_file.path(), "line1\r\nline2\r\n")?;
...   |
334 | |         assert_eq!(eol, "\r\n");
335 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/inject.rs:337:5
    |
337 | /     test!(test_detect_eol_lf, {
338 | |         let temp_file = NamedTempFile::new()?;
339 | |         fs::write(temp_file.path(), "line1\nline2\n")?;
...   |
342 | |         assert_eq!(eol, "\n");
343 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/inject.rs:345:5
    |
345 | /     test!(test_detect_eol_cr, {
346 | |         let temp_file = NamedTempFile::new()?;
347 | |         fs::write(temp_file.path(), "line1\rline2\r")?;
...   |
350 | |         assert_eq!(eol, "\r");
351 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/inject.rs:353:5
    |
353 | /     test!(test_detect_eol_no_eol, {
354 | |         let temp_file = NamedTempFile::new()?;
355 | |         fs::write(temp_file.path(), "single line")?;
...   |
358 | |         assert_eq!(eol, EolNormalizer::platform_default());
359 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/inject.rs:361:5
    |
361 | /     test!(test_detect_eol_nonexistent_file, {
362 | |         let eol = EolNormalizer::detect_eol(Path::new("/nonexistent/file"))?;
363 | |         assert_eq!(eol, EolNormalizer::platform_default());
364 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/inject.rs:366:5
    |
366 | /     test!(test_normalize_to_eol, {
367 | |         let content = "line1\r\nline2\rline3\nline4";
...   |
379 | |         assert_eq!(normalized_cr, "line1\rline2\rline3\rline4");
380 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/inject.rs:382:5
    |
382 | /     test!(test_normalize_to_match_file, {
383 | |         let temp_file = NamedTempFile::new()?;
384 | |         fs::write(temp_file.path(), "existing\r\ncontent")?;
...   |
390 | |         assert_eq!(normalized, "new\r\ncontent");
391 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/inject.rs:393:5
    |
393 | /     test!(test_generate_exact_match, {
394 | |         let content = "function hello() {\n  console.log('world');\n}";
395 | |         let pattern = SkipIfGenerator::generate_exact_match(content);
...   |
402 | |         assert!(regex.is_match(content));
403 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/inject.rs:405:5
    |
405 | /     test!(test_generate_exact_match_with_special_chars, {
406 | |         let content = "function test() {\n  return /^[a-z]+$/;\n}";
407 | |         let pattern = SkipIfGenerator::generate_exact_match(content);
...   |
415 | |         assert!(!regex.is_match(different_content));
416 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/inject.rs:418:5
    |
418 | /     test!(test_content_exists_in_file, {
419 | |         let temp_file = NamedTempFile::new()?;
420 | |         let content = "function hello() {\n  console.log('world');\n}";
421 | |         fs::write(
...   |
437 | |         )?);
438 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/inject.rs:440:5
    |
440 | /     test!(test_content_exists_in_nonexistent_file, {
441 | |         let result =
442 | |             SkipIfGenerator::content_exists_in_file("content", Path::new("/nonexistent/file"))?;
443 | |         assert!(!result);
444 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/inject.rs:446:5
    |
446 | /     test!(test_generate_idempotent_pattern, {
447 | |         let content = "function test() {}";
448 | |         let pattern = SkipIfGenerator::generate_idempotent_pattern(content);
...   |
455 | |         assert!(regex.is_match(content));
456 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/inject.rs:458:5
    |
458 | /     test!(test_platform_default, {
459 | |         let default = EolNormalizer::platform_default();
...   |
463 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lifecycle/error.rs:332:5
    |
332 | /     test!(test_phase_not_found_error, {
333 | |         let err = LifecycleError::phase_not_found("build");
334 | |         assert_eq!(err.to_string(), "Phase 'build' not found in configuration");
335 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> crates/ggen-core/src/lifecycle/error.rs:325:10
    |
325 | pub type Result<T> = std::result::Result<T, LifecycleError>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lifecycle/error.rs:337:5
    |
337 | /     test!(test_command_failed_error, {
338 | |         let err = LifecycleError::command_failed("test", "cargo test", 101, "test failed");
339 | |         let msg = err.to_string();
340 | |         assert!(msg.contains("Command failed"));
341 | |         assert!(msg.contains("Exit code: 101"));
342 | |         assert!(msg.contains("test failed"));
343 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> crates/ggen-core/src/lifecycle/error.rs:325:10
    |
325 | pub type Result<T> = std::result::Result<T, LifecycleError>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lifecycle/error.rs:345:5
    |
345 | /     test!(test_hook_recursion_error, {
346 | |         let err = LifecycleError::hook_recursion("build");
347 | |         let msg = err.to_string();
348 | |         assert!(msg.contains("Hook recursion detected"));
349 | |         assert!(msg.contains("build"));
350 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> crates/ggen-core/src/lifecycle/error.rs:325:10
    |
325 | pub type Result<T> = std::result::Result<T, LifecycleError>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lifecycle/error.rs:352:5
    |
352 | /     test!(test_hook_recursion_with_chain, {
353 | |         let chain = vec![
354 | |             "init".to_string(),
355 | |             "setup".to_string(),
...   |
361 | |         assert!(msg.contains("init -> setup -> build -> init"));
362 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> crates/ggen-core/src/lifecycle/error.rs:325:10
    |
325 | pub type Result<T> = std::result::Result<T, LifecycleError>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lifecycle/error.rs:364:5
    |
364 | /     test!(test_state_errors, {
365 | |         let path = PathBuf::from("/tmp/state.json");
...   |
375 | |         assert!(err.to_string().contains("Failed to save state"));
376 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> crates/ggen-core/src/lifecycle/error.rs:325:10
    |
325 | pub type Result<T> = std::result::Result<T, LifecycleError>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lifecycle/error.rs:378:5
    |
378 | /     test!(test_make_toml_errors, {
379 | |         let path = PathBuf::from("/tmp/make.toml");
...   |
385 | |         assert!(err.to_string().contains("/tmp/make.toml"));
386 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> crates/ggen-core/src/lifecycle/error.rs:325:10
    |
325 | pub type Result<T> = std::result::Result<T, LifecycleError>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lifecycle/error.rs:388:5
    |
388 | /     test!(test_cache_errors, {
389 | |         let path = PathBuf::from("/tmp/cache");
...   |
399 | |         assert!(err.to_string().contains("build"));
400 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> crates/ggen-core/src/lifecycle/error.rs:325:10
    |
325 | pub type Result<T> = std::result::Result<T, LifecycleError>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lifecycle/error.rs:402:5
    |
402 | /     test!(test_error_downcasting, {
403 | |         let err = LifecycleError::phase_not_found("build");
404 | |         let err_ref: &dyn std::error::Error = &err;
405 | |         assert!(err_ref.source().is_none());
...   |
410 | |         assert!(err_ref.source().is_some());
411 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> crates/ggen-core/src/lifecycle/error.rs:325:10
    |
325 | pub type Result<T> = std::result::Result<T, LifecycleError>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lifecycle/error.rs:413:5
    |
413 | /     test!(test_error_display, {
414 | |         let lifecycle_err = LifecycleError::phase_not_found("test");
415 | |         let err_str = lifecycle_err.to_string();
416 | |         assert!(err_str.contains("Phase 'test' not found"));
417 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> crates/ggen-core/src/lifecycle/error.rs:325:10
    |
325 | pub type Result<T> = std::result::Result<T, LifecycleError>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lifecycle/hooks.rs:249:5
    |
249 | /     test!(test_valid_hooks_pass_validation, {
250 | |         let mut hooks = Hooks::default();
251 | |         hooks.before_build = Some(vec!["validate".to_string()]);
...   |
257 | |         assert!(ValidatedHooks::validate(&hooks, &phase_names).is_ok());
258 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> crates/ggen-core/src/lifecycle/error.rs:325:10
    |
325 | pub type Result<T> = std::result::Result<T, LifecycleError>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lifecycle/hooks.rs:260:5
    |
260 | /     test!(test_invalid_phase_reference_fails, {
261 | |         let mut hooks = Hooks::default();
262 | |         hooks.before_build = Some(vec!["nonexistent".to_string()]);
...   |
267 | |         assert!(ValidatedHooks::validate(&hooks, &phase_names).is_err());
268 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> crates/ggen-core/src/lifecycle/error.rs:325:10
    |
325 | pub type Result<T> = std::result::Result<T, LifecycleError>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lifecycle/hooks.rs:270:5
    |
270 | /     test!(test_self_reference_fails, {
271 | |         let mut hooks = Hooks::default();
272 | |         hooks.before_build = Some(vec!["build".to_string()]);
...   |
277 | |         assert!(ValidatedHooks::validate(&hooks, &phase_names).is_err());
278 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> crates/ggen-core/src/lifecycle/error.rs:325:10
    |
325 | pub type Result<T> = std::result::Result<T, LifecycleError>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lifecycle/hooks.rs:280:5
    |
280 | /     test!(test_circular_dependency_fails, {
281 | |         // Test circular dependency with existing hook types
282 | |         let mut hooks = Hooks::default();
283 | |         hooks.before_build = Some(vec!["validate".to_string()]);
...   |
300 | |         assert!(ValidatedHooks::validate(&hooks, &phase_names).is_ok());
301 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> crates/ggen-core/src/lifecycle/error.rs:325:10
    |
325 | pub type Result<T> = std::result::Result<T, LifecycleError>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lifecycle/poka_yoke.rs:375:5
    |
375 | /     test!(test_non_empty_path_valid, {
376 | |         let path = NonEmptyPath::new(PathBuf::from("test.txt")).unwrap();
377 | |         assert_eq!(path.as_path(), Path::new("test.txt"));
378 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> crates/ggen-core/src/lifecycle/error.rs:325:10
    |
325 | pub type Result<T> = std::result::Result<T, LifecycleError>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lifecycle/poka_yoke.rs:380:5
    |
380 | /     test!(test_non_empty_path_empty_rejected, {
381 | |         let empty = NonEmptyPath::new(PathBuf::from(""));
382 | |         assert!(empty.is_err());
383 | |         assert_eq!(empty.unwrap_err(), EmptyPathError);
384 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> crates/ggen-core/src/lifecycle/error.rs:325:10
    |
325 | pub type Result<T> = std::result::Result<T, LifecycleError>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lifecycle/poka_yoke.rs:386:5
    |
386 | /     test!(test_non_empty_path_join, {
387 | |         let base: NonEmptyPath = "base".parse().unwrap();
388 | |         let joined = base.join("file.txt");
389 | |         assert!(joined.as_path().to_str().unwrap().contains("base"));
390 | |         assert!(joined.as_path().to_str().unwrap().contains("file.txt"));
391 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> crates/ggen-core/src/lifecycle/error.rs:325:10
    |
325 | pub type Result<T> = std::result::Result<T, LifecycleError>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lifecycle/poka_yoke.rs:393:5
    |
393 | /     test!(test_non_empty_string_valid, {
394 | |         let s = NonEmptyString::new("hello".to_string()).unwrap();
395 | |         assert_eq!(s.as_str(), "hello");
396 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> crates/ggen-core/src/lifecycle/error.rs:325:10
    |
325 | pub type Result<T> = std::result::Result<T, LifecycleError>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lifecycle/poka_yoke.rs:398:5
    |
398 | /     test!(test_non_empty_string_empty_rejected, {
399 | |         let empty = NonEmptyString::new("".to_string());
400 | |         assert!(empty.is_err());
401 | |         assert_eq!(empty.unwrap_err(), EmptyStringError);
402 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> crates/ggen-core/src/lifecycle/error.rs:325:10
    |
325 | pub type Result<T> = std::result::Result<T, LifecycleError>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lifecycle/poka_yoke.rs:404:5
    |
404 | /     test!(test_counter_cannot_be_negative, {
405 | |         let mut counter = Counter::new(0);
406 | |         counter.decrement(); // Saturates at 0
407 | |         assert_eq!(counter.get(), 0);
...   |
410 | |         assert_eq!(counter.get(), 0);
411 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> crates/ggen-core/src/lifecycle/error.rs:325:10
    |
325 | pub type Result<T> = std::result::Result<T, LifecycleError>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lifecycle/poka_yoke.rs:413:5
    |
413 | /     test!(test_counter_cannot_overflow, {
414 | |         let mut counter = Counter::new(u32::MAX);
415 | |         counter.increment(); // Saturates at MAX
416 | |         assert_eq!(counter.get(), u32::MAX);
417 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> crates/ggen-core/src/lifecycle/error.rs:325:10
    |
325 | pub type Result<T> = std::result::Result<T, LifecycleError>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lifecycle/poka_yoke.rs:419:5
    |
419 | /     test!(test_counter_normal_operations, {
420 | |         let mut counter = Counter::new(5);
421 | |         counter.increment();
422 | |         assert_eq!(counter.get(), 6);
...   |
434 | |         assert_eq!(counter.get(), 0);
435 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> crates/ggen-core/src/lifecycle/error.rs:325:10
    |
325 | pub type Result<T> = std::result::Result<T, LifecycleError>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lifecycle/poka_yoke.rs:437:5
    |
437 | /     test!(test_file_handle_type_safety, {
...   |
451 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> crates/ggen-core/src/lifecycle/error.rs:325:10
    |
325 | pub type Result<T> = std::result::Result<T, LifecycleError>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lifecycle/state_machine.rs:212:5
    |
212 | /     test!(test_valid_state_transitions, {
213 | |         // State machine validates transitions but doesn't record phases
214 | |         // Phases are recorded in exec.rs during actual execution
215 | |         let mut lifecycle = LifecycleStateMachine::<Initial>::new();
...   |
261 | |         assert!(lifecycle.has_completed_phase("deploy"));
262 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> crates/ggen-core/src/lifecycle/error.rs:325:10
    |
325 | pub type Result<T> = std::result::Result<T, LifecycleError>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lifecycle/state_machine.rs:264:5
    |
264 | /     test!(test_state_access, {
265 | |         let lifecycle = LifecycleStateMachine::<Initial>::new();
266 | |         assert_eq!(lifecycle.last_phase(), None);
267 | |         assert!(!lifecycle.has_completed_phase("init"));
268 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> crates/ggen-core/src/lifecycle/error.rs:325:10
    |
325 | pub type Result<T> = std::result::Result<T, LifecycleError>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lifecycle/state_machine.rs:270:5
    |
270 | /     test!(test_invalid_transition_validation, {
271 | |         let lifecycle = LifecycleStateMachine::<Initial>::new();
...   |
285 | |         let _lifecycle = lifecycle.setup().unwrap(); // Now this works
286 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> crates/ggen-core/src/lifecycle/error.rs:325:10
    |
325 | pub type Result<T> = std::result::Result<T, LifecycleError>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lifecycle/state_validation.rs:190:5
    |
190 | /     test!(test_valid_state_passes_validation, {
191 | |         let mut state = LifecycleState::default();
192 | |         state.record_run("init".to_string(), 0, 100, true);
193 | |         state.record_run("setup".to_string(), 100, 200, true);
...   |
196 | |         assert!(ValidatedLifecycleState::validate(&state).is_ok());
197 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> crates/ggen-core/src/lifecycle/error.rs:325:10
    |
325 | pub type Result<T> = std::result::Result<T, LifecycleError>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lifecycle/state_validation.rs:199:5
    |
199 | /     test!(test_missing_prerequisite_fails_validation, {
200 | |         let mut state = LifecycleState::default();
201 | |         // Deploy without test should fail (critical safety check)
202 | |         state.record_run("deploy".to_string(), 0, 100, true);
203 | |
204 | |         assert!(ValidatedLifecycleState::validate(&state).is_err());
205 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> crates/ggen-core/src/lifecycle/error.rs:325:10
    |
325 | pub type Result<T> = std::result::Result<T, LifecycleError>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lifecycle/state_validation.rs:207:5
    |
207 | /     test!(test_invalid_cache_key_fails_validation, {
208 | |         let mut state = LifecycleState::default();
209 | |         state.record_run("init".to_string(), 0, 100, true);
210 | |         state.add_cache_key("nonexistent".to_string(), "key".to_string());
211 | |
212 | |         assert!(ValidatedLifecycleState::validate(&state).is_err());
213 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> crates/ggen-core/src/lifecycle/error.rs:325:10
    |
325 | pub type Result<T> = std::result::Result<T, LifecycleError>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lifecycle/state_validation.rs:215:5
    |
215 | /     test!(test_inconsistent_history_allowed_for_hooks, {
216 | |         // Hooks can run phases out of order, so this should be allowed
217 | |         let mut state = LifecycleState::default();
218 | |         state.record_run("build".to_string(), 0, 100, true);
...   |
222 | |         assert!(ValidatedLifecycleState::validate(&state).is_ok());
223 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> crates/ggen-core/src/lifecycle/error.rs:325:10
    |
325 | pub type Result<T> = std::result::Result<T, LifecycleError>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lifecycle/state_validation.rs:225:5
    |
225 | /     test!(test_validated_state_wrapper, {
226 | |         let mut state = LifecycleState::default();
227 | |         state.record_run("init".to_string(), 0, 100, true);
...   |
230 | |         assert!(validated.state().has_completed_phase("init"));
231 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> crates/ggen-core/src/lifecycle/error.rs:325:10
    |
325 | pub type Result<T> = std::result::Result<T, LifecycleError>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lifecycle/production.rs:934:5
    |
934 | /     test!(test_default_requirements, {
935 | |         let requirements = ReadinessTracker::default_requirements();
...   |
964 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> crates/ggen-core/src/lifecycle/production.rs:170:10
    |
170 | pub type Result<T> = std::result::Result<T, ProductionError>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lifecycle/production.rs:966:5
    |
966 | /     test!(test_readiness_report_generation, {
967 | |         let mut tracker = ReadinessTracker::new("/tmp/test");
968 | |         tracker.load().unwrap(); // Load default requirements
969 | |         let report = tracker.generate_report();
...   |
983 | |         );
984 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> crates/ggen-core/src/lifecycle/production.rs:170:10
    |
170 | pub type Result<T> = std::result::Result<T, ProductionError>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
    --> crates/ggen-core/src/lifecycle/production.rs:986:5
     |
 986 | /     test!(test_status_transitions, {
 987 | |         let mut tracker = ReadinessTracker::new("/tmp/test");
 988 | |         tracker.load().unwrap();
...    |
1001 | |             .is_err());
1002 | |     });
     | |      ^
     | |      |
     | |______expected 1 generic argument
     |        help: remove the unnecessary generic argument
     |
note: type alias defined here, with 1 generic parameter: `T`
    --> crates/ggen-core/src/lifecycle/production.rs:170:10
     |
 170 | pub type Result<T> = std::result::Result<T, ProductionError>;
     |          ^^^^^^ -
     = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lifecycle/optimization.rs:435:5
    |
435 | /     test!(test_performance_targets, {
436 | |         let targets = PerformanceTargets::default();
437 | |         assert_eq!(targets.total, Duration::from_secs(45));
...   |
443 | |         assert_eq!(stretch.total, Duration::from_secs(45));
444 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> crates/ggen-core/src/lifecycle/error.rs:325:10
    |
325 | pub type Result<T> = std::result::Result<T, LifecycleError>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lifecycle/optimization.rs:446:5
    |
446 | /     test!(test_stage_metrics, {
447 | |         let metric = StageMetrics::new("test", Duration::from_secs(5), Duration::from_secs(10));
448 | |         assert!(metric.met_target);
449 | |         assert!(metric.improvement_percent() > 0.0);
...   |
454 | |         assert!(metric_exceeded.improvement_percent() < 0.0);
455 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> crates/ggen-core/src/lifecycle/error.rs:325:10
    |
325 | pub type Result<T> = std::result::Result<T, LifecycleError>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lifecycle/optimization.rs:493:5
    |
493 | /     test!(test_improvement_calculation, {
494 | |         let metric = StageMetrics::new("test", Duration::from_secs(3), Duration::from_secs(5));
495 | |         assert!((metric.improvement_percent() - 40.0).abs() < 0.01);
...   |
498 | |         assert!((metric_over.improvement_percent() + 40.0).abs() < 0.01);
499 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> crates/ggen-core/src/lifecycle/error.rs:325:10
    |
325 | pub type Result<T> = std::result::Result<T, LifecycleError>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lifecycle/dag.rs:101:5
    |
101 | /     test!(test_topo_simple, {
102 | |         let phases = &["init", "setup", "build"];
103 | |         let deps = &[("init", "setup"), ("setup", "build")];
...   |
107 | |         assert_eq!(order, vec!["init", "setup", "build"]);
108 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> crates/ggen-core/src/lifecycle/error.rs:325:10
    |
325 | pub type Result<T> = std::result::Result<T, LifecycleError>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lifecycle/dag.rs:110:5
    |
110 | /     test!(test_topo_parallel, {
111 | |         let phases = &["test", "lint", "build"];
112 | |         let deps = &[("test", "build"), ("lint", "build")];
...   |
117 | |         assert_eq!(order.last(), Some(&"build".to_string()));
118 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> crates/ggen-core/src/lifecycle/error.rs:325:10
    |
325 | pub type Result<T> = std::result::Result<T, LifecycleError>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lifecycle/dag.rs:120:5
    |
120 | /     test!(test_topo_cycle_detection, {
121 | |         let phases = &["a", "b", "c"];
122 | |         let deps = &[("a", "b"), ("b", "c"), ("c", "a")]; // cycle: a->b->c->a
...   |
129 | |             .contains("Circular dependency"));
130 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> crates/ggen-core/src/lifecycle/error.rs:325:10
    |
325 | pub type Result<T> = std::result::Result<T, LifecycleError>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lifecycle/dag.rs:132:5
    |
132 | /     test!(test_deps_from_hooks, {
133 | |         let deps = deps_from_hooks("build", &["test".to_string()], &["deploy".to_string()]);
134 | |
135 | |         assert_eq!(deps.len(), 2);
136 | |         assert!(deps.contains(&("test".to_string(), "build".to_string())));
137 | |         assert!(deps.contains(&("build".to_string(), "deploy".to_string())));
138 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> crates/ggen-core/src/lifecycle/error.rs:325:10
    |
325 | pub type Result<T> = std::result::Result<T, LifecycleError>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lockfile.rs:401:5
    |
401 | /     test!(test_lockfile_manager_creation, {
402 | |         let temp_dir = TempDir::new().unwrap();
403 | |         let manager = LockfileManager::new(temp_dir.path());
...   |
406 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lockfile.rs:408:5
    |
408 | /     test!(test_lockfile_create_and_save, {
409 | |         let temp_dir = TempDir::new().unwrap();
410 | |         let manager = LockfileManager::new(temp_dir.path());
...   |
415 | |         assert!(manager.lockfile_path().exists());
416 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lockfile.rs:418:5
    |
418 | /     test!(test_lockfile_load_nonexistent, {
419 | |         let temp_dir = TempDir::new().unwrap();
420 | |         let manager = LockfileManager::new(temp_dir.path());
...   |
423 | |         assert!(loaded.is_none());
424 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lockfile.rs:426:5
    |
426 | /     test!(test_lockfile_upsert_and_get, {
427 | |         let temp_dir = TempDir::new().unwrap();
428 | |         let manager = LockfileManager::new(temp_dir.path());
...   |
442 | |         assert!(entry.pqc_pubkey.is_none());
443 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lockfile.rs:445:5
    |
445 | /     test!(test_lockfile_upsert_with_pqc, {
446 | |         let temp_dir = TempDir::new().unwrap();
447 | |         let manager = LockfileManager::new(temp_dir.path());
...   |
465 | |         assert_eq!(entry.pqc_pubkey, Some("pqc_pubkey_base64".to_string()));
466 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lockfile.rs:468:5
    |
468 | /     test!(test_lockfile_remove, {
469 | |         let temp_dir = TempDir::new().unwrap();
470 | |         let manager = LockfileManager::new(temp_dir.path());
...   |
481 | |         assert!(!manager.is_installed("io.ggen.test").unwrap());
482 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/lockfile.rs:484:5
    |
484 | /     test!(test_lockfile_stats, {
485 | |         let temp_dir = TempDir::new().unwrap();
486 | |         let manager = LockfileManager::new(temp_dir.path());
...   |
502 | |         assert_eq!(stats.version, Some("1.0".to_string()));
503 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/merge.rs:736:5
    |
736 | /     test!(test_merge_strategies, {
737 | |         let merger = ThreeWayMerger::new(MergeStrategy::GeneratedWins);
738 | |
739 | |         let baseline = "line 1\nline 2\n";
...   |
749 | |         assert_eq!(result.content, generated);
750 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/merge.rs:752:5
    |
752 | /     test!(test_region_aware_merge, {
753 | |         let merger = RegionAwareMerger::new(MergeStrategy::ManualWins);
754 | |
755 | |         let baseline = "line 1\n// GENERATED: DO NOT EDIT\nline 2\n// END GENERATED\nline 3\n";
...   |
789 | |         assert_eq!(result.strategy, MergeStrategy::ManualWins);
790 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/merge.rs:792:5
    |
792 | /     test!(test_region_parsing, {
793 | |         let content = r#"
794 | | line 1
...   |
816 | |         assert_eq!(manual[0].end, 10);
817 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/merge.rs:819:5
    |
819 | /     test!(test_region_check, {
820 | |         let regions = vec![
821 | |             Region {
822 | |                 start: 2,
...   |
844 | |         ));
845 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/pipeline.rs:767:5
    |
767 | /     test!(test_pipeline_new, {
768 | |         let pipeline = Pipeline::new()?;
769 | |         assert!(!pipeline.graph.is_empty() || pipeline.graph.is_empty()); // Just verify it exists
770 | |         Ok(())
771 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/pipeline.rs:774:5
    |
774 | /     test!(test_pipeline_render_body, {
775 | |         let mut pipeline = Pipeline::new()?;
776 | |         let mut ctx = Context::new();
777 | |         ctx.insert("name", "World");
...   |
781 | |         Ok(())
782 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/pipeline.rs:785:5
    |
785 | /     test!(test_pipeline_render_file_basic, {
786 | |         let temp_dir = TempDir::new()?;
787 | |         let template_content = r#"---
788 | | to: "output.txt"
...   |
802 | |         Ok(())
803 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/pipeline.rs:806:5
    |
806 | /     test!(test_plan_apply_dry_run, {
807 | |         let temp_dir = TempDir::new()?;
808 | |         let output_path = temp_dir.path().join("output.txt");
...   |
822 | |         Ok(())
823 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/pipeline.rs:826:5
    |
826 | /     test!(test_plan_apply_creates_file, {
827 | |         let temp_dir = TempDir::new()?;
828 | |         let output_path = temp_dir.path().join("output.txt");
...   |
844 | |         Ok(())
845 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/pipeline.rs:848:5
    |
848 | /     test!(test_plan_unless_exists, {
849 | |         let temp_dir = TempDir::new()?;
850 | |         let output_path = temp_dir.path().join("output.txt");
...   |
871 | |         Ok(())
872 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/pipeline.rs:875:5
    |
875 | /     test!(test_pipeline_builder_with_prefixes, {
876 | |         let mut prefixes = BTreeMap::new();
877 | |         prefixes.insert("ex".to_string(), "http://example.org/".to_string());
...   |
885 | |         Ok(())
886 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/pipeline.rs:889:5
    |
889 | /     test!(test_pipeline_register_prefixes, {
890 | |         let mut pipeline = Pipeline::new()?;
891 | |         let mut prefixes = BTreeMap::new();
892 | |         prefixes.insert("ex".to_string(), "http://example.org/".to_string());
...   |
900 | |         Ok(())
901 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/poc.rs:349:5
    |
349 | /     test!(poc_with_prefixes_and_inline_rdf, {
350 | |         let dir = tempfile::tempdir().unwrap();
351 | |         let root = dir.path();
...   |
378 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/pqc.rs:201:5
    |
201 | /     test!(test_pqc_signer_creation, {
202 | |         let signer = PqcSigner::new();
203 | |         assert!(!signer.public_key_base64().is_empty());
204 | |         assert!(!signer.secret_key_base64().is_empty());
205 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/pqc.rs:207:5
    |
207 | /     test!(test_pqc_sign_and_verify, {
208 | |         let signer = PqcSigner::new();
209 | |         let message = b"test message";
...   |
216 | |         assert!(verified);
217 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/pqc.rs:219:5
    |
219 | /     test!(test_pqc_pack_signature, {
220 | |         let signer = PqcSigner::new();
221 | |         let pack_id = "io.ggen.test";
222 | |         let version = "1.0.0";
...   |
232 | |         assert!(verified);
233 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/pqc.rs:235:5
    |
235 | /     test!(test_pqc_invalid_signature, {
236 | |         let signer = PqcSigner::new();
237 | |         let verifier = PqcVerifier::from_public_key(signer.public_key.as_bytes()).unwrap();
...   |
245 | |         assert!(!verified);
246 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/pqc.rs:248:5
    |
248 | /     test!(test_sha256_calculation, {
249 | |         let data = b"test data";
250 | |         let hash = calculate_sha256(data);
...   |
255 | |         );
256 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/preprocessor.rs:457:5
    |
457 | /     test!(test_freeze_stage_basic, {
458 | |         let temp_dir = TempDir::new()?;
459 | |         let stage = FreezeStage {
460 | |             slots_dir: temp_dir.path().to_path_buf(),
...   |
477 | |         Ok(())
478 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/preprocessor.rs:480:5
    |
480 | /     test!(test_include_stage_basic, {
481 | |         let temp_dir = TempDir::new()?;
482 | |         let include_file = temp_dir.path().join("included.tmpl");
483 | |         fs::write(&include_file, "Included content")?;
...   |
499 | |         Ok(())
500 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/preprocessor.rs:502:5
    |
502 | /     test!(test_preprocessor_pipeline, {
503 | |         let temp_dir = TempDir::new()?;
504 | |         let include_file = temp_dir.path().join("included.tmpl");
505 | |         fs::write(&include_file, "Included")?;
...   |
531 | |         Ok(())
532 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/resolver.rs:503:5
    |
503 | /     test!(test_parse_template_ref, {
504 | |         let temp_dir = TempDir::new().unwrap();
505 | |         let cache_manager = CacheManager::with_dir(temp_dir.path().join("cache")).unwrap();
506 | |         let lockfile_manager = LockfileManager::new(temp_dir.path());
...   |
513 | |         assert_eq!(template_path, "main.tmpl");
514 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/resolver.rs:516:5
    |
516 | /     test!(test_parse_template_ref_invalid, {
517 | |         let temp_dir = TempDir::new().unwrap();
518 | |         let cache_manager = CacheManager::with_dir(temp_dir.path().join("cache")).unwrap();
519 | |         let lockfile_manager = LockfileManager::new(temp_dir.path());
...   |
529 | |         assert!(resolver.parse_template_ref("pack:").is_err());
530 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/resolver.rs:532:5
    |
532 | /     test!(test_resolve_template_path, {
533 | |         let temp_dir = TempDir::new().unwrap();
534 | |         let pack_dir = temp_dir.path().join("pack");
535 | |         let templates_dir = pack_dir.join("templates");
...   |
553 | |         assert_eq!(resolved_path, templates_dir.join("main.tmpl"));
554 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/resolver.rs:556:5
    |
556 | /     test!(test_resolve_template_path_security, {
557 | |         let temp_dir = TempDir::new().unwrap();
558 | |         let pack_dir = temp_dir.path().join("pack");
559 | |         let cached_pack = CachedPack {
...   |
574 | |             .is_err());
575 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/resolver.rs:577:5
    |
577 | /     test!(test_template_resolver_new, {
578 | |         let temp_dir = TempDir::new().unwrap();
579 | |         let cache_manager = CacheManager::with_dir(temp_dir.path().join("cache")).unwrap();
580 | |         let lockfile_manager = LockfileManager::new(temp_dir.path());
...   |
585 | |         assert!(resolver.cache_manager.cache_dir().exists());
586 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/resolver.rs:588:5
    |
588 | /     test!(test_resolve_template_path_nested, {
589 | |         let temp_dir = TempDir::new().unwrap();
590 | |         let pack_dir = temp_dir.path().join("pack");
591 | |         let templates_dir = pack_dir.join("templates");
...   |
609 | |         assert_eq!(resolved_path, templates_dir.join("nested").join("sub.tmpl"));
610 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/resolver.rs:612:5
    |
612 | /     test!(test_resolve_template_path_empty_components, {
613 | |         let temp_dir = TempDir::new().unwrap();
614 | |         let pack_dir = temp_dir.path().join("pack");
615 | |         let templates_dir = pack_dir.join("templates");
...   |
634 | |         assert_eq!(resolved_path, templates_dir.join("a").join("b"));
635 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/resolver.rs:637:5
    |
637 | /     test!(test_parse_frontmatter_basic, {
638 | |         let temp_dir = TempDir::new().unwrap();
639 | |         let cache_manager = CacheManager::with_dir(temp_dir.path().join("cache")).unwrap();
640 | |         let lockfile_manager = LockfileManager::new(temp_dir.path());
...   |
654 | |         assert!(template_content.contains("Hello {{ name }}"));
655 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/resolver.rs:657:5
    |
657 | /     test!(test_parse_frontmatter_no_frontmatter, {
658 | |         let temp_dir = TempDir::new().unwrap();
659 | |         let cache_manager = CacheManager::with_dir(temp_dir.path().join("cache")).unwrap();
660 | |         let lockfile_manager = LockfileManager::new(temp_dir.path());
...   |
668 | |         assert_eq!(template_content, "Hello World");
669 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/resolver.rs:671:5
    |
671 | /     test!(test_find_templates_in_pack_with_manifest, {
672 | |         let temp_dir = TempDir::new().unwrap();
673 | |         let pack_dir = temp_dir.path().join("pack");
674 | |         let templates_dir = pack_dir.join("templates");
...   |
726 | |         assert!(templates.iter().any(|t| t.ends_with("sub.tmpl")));
727 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/resolver.rs:729:5
    |
729 | /     test!(test_find_templates_in_pack_without_manifest, {
730 | |         let temp_dir = TempDir::new().unwrap();
731 | |         let pack_dir = temp_dir.path().join("pack");
732 | |         let templates_dir = pack_dir.join("templates");
...   |
755 | |         assert!(templates.iter().any(|t| t.ends_with("sub.tmpl")));
756 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/resolver.rs:758:5
    |
758 | /     test!(test_search_templates_empty, {
759 | |         let temp_dir = TempDir::new().unwrap();
760 | |         let cache_manager = CacheManager::with_dir(temp_dir.path().join("cache")).unwrap();
761 | |         let lockfile_manager = LockfileManager::new(temp_dir.path());
...   |
765 | |         assert!(results.is_empty());
766 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/resolver.rs:768:5
    |
768 | /     test!(test_get_pack_templates_nonexistent_pack, {
769 | |         let temp_dir = TempDir::new().unwrap();
770 | |         let cache_manager = CacheManager::with_dir(temp_dir.path().join("cache")).unwrap();
771 | |         let lockfile_manager = LockfileManager::new(temp_dir.path());
...   |
775 | |         assert!(resolver.get_pack_templates("nonexistent.pack").is_err());
776 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/snapshot.rs:600:5
    |
600 | /     test!(test_snapshot_creation, {
601 | |         let graph = Graph::new().unwrap();
602 | |         graph
603 | |             .insert_turtle("@prefix : <http://example.org/> . :test a :Class .")
...   |
623 | |         assert!(!snapshot.graph.hash.is_empty());
624 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/snapshot.rs:626:5
    |
626 | /     test!(test_snapshot_manager, {
627 | |         let temp_dir = tempdir().unwrap();
628 | |         let manager = SnapshotManager::new(temp_dir.path().to_path_buf()).unwrap();
...   |
651 | |         assert!(!manager.exists("manager_test"));
652 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/snapshot.rs:654:5
    |
654 | /     test!(test_file_snapshot, {
655 | |         let temp_dir = tempdir().unwrap();
656 | |         let file_path = temp_dir.path().join("test.txt");
657 | |         fs::write(&file_path, "test content").unwrap();
...   |
667 | |         assert!(snapshot.has_changed("different content"));
668 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/snapshot.rs:670:5
    |
670 | /     test!(test_template_snapshot, {
671 | |         let temp_dir = tempdir().unwrap();
672 | |         let template_path = temp_dir.path().join("test.tmpl");
...   |
681 | |         assert!(!snapshot.hash.is_empty());
682 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/streaming_generator.rs:406:5
    |
406 | /     test!(test_streaming_generator_new, {
407 | |         let temp_dir = TempDir::new()?;
408 | |         let output_dir = TempDir::new()?;
...   |
418 | |         Ok(())
419 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/streaming_generator.rs:421:5
    |
421 | /     test!(test_streaming_generator_single_file, {
422 | |         let temp_dir = TempDir::new()?;
423 | |         let output_dir = TempDir::new()?;
...   |
455 | |         Ok(())
456 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/streaming_generator.rs:458:5
    |
458 | /     test!(test_streaming_generator_multiple_files, {
459 | |         let temp_dir = TempDir::new()?;
460 | |         let output_dir = TempDir::new()?;
...   |
490 | |         Ok(())
491 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/streaming_generator.rs:493:5
    |
493 | /     test!(test_streaming_generator_nested_output, {
494 | |         let temp_dir = TempDir::new()?;
495 | |         let output_dir = TempDir::new()?;
...   |
522 | |         Ok(())
523 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/streaming_generator.rs:525:5
    |
525 | /     test!(test_streaming_generator_cache_reuse, {
526 | |         let temp_dir = TempDir::new()?;
527 | |         let output_dir = TempDir::new()?;
...   |
556 | |         Ok(())
557 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/telemetry.rs:178:5
    |
178 | /     test!(test_telemetry_config_default, {
179 | |         let config = TelemetryConfig::default();
180 | |         assert_eq!(config.service_name, "ggen");
181 | |         assert_eq!(config.sample_ratio, 1.0);
182 | |         assert!(config.console_output);
183 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/telemetry.rs:185:5
    |
185 | /     test!(test_telemetry_config_custom, {
186 | |         let config = TelemetryConfig {
187 | |             endpoint: "http://custom:4318".to_string(),
188 | |             service_name: "test-service".to_string(),
...   |
195 | |         assert!(!config.console_output);
196 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/template.rs:566:5
    |
566 | /     test!(parse_variants_and_preserve_body, {
567 | |         let cases = [
...   |
594 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/template.rs:596:5
    |
596 | /     test!(frontmatter_render_core_fields, {
597 | |         let input = r#"---
598 | | to: "{{name}}.rs"
599 | | prefixes: { ex: "http://example.org/" }
...   |
620 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/template.rs:622:5
    |
622 | /     test!(deserializers_string_or_seq_and_sparql_map, {
623 | |         let fm1: Frontmatter = serde_yaml::from_str(r#"rdf_inline: "a""#).unwrap();
624 | |         let fm2: Frontmatter = serde_yaml::from_str(r#"rdf_inline: ["a","b"]"#).unwrap();
625 | |         assert_eq!(fm1.rdf_inline, vec!["a"]);
...   |
636 | |         assert!(fm5.sparql.contains_key("query_0"));
637 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/template.rs:639:5
    |
639 | /     test!(boolean_and_injection_flags, {
640 | |         let fm: Frontmatter = serde_yaml::from_str(
641 | |             r#"
642 | | force: true
...   |
665 | |         assert_eq!(fm.sh_after.as_deref(), Some("echo post"));
666 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/template.rs:670:5
    |
670 | /     test!(body_render_inline_and_from_file, {
671 | |         // inline
672 | |         let inline = r#"---
673 | | to: "x"
...   |
694 | |         assert_contains!(got2, "Hello, Bob!");
695 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/template.rs:699:5
    |
699 | /     test!(rdf_insert_and_select_visible, {
700 | |         let input = r#"---
701 | | prefixes: { ex: "http://example.org/" }
702 | | rdf_inline:
...   |
710 | |         assert_contains!(out, "Count: 1");
711 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/template.rs:713:5
    |
713 | /     test!(boolean_ask_and_empty_result_helpers, {
714 | |         let input = r#"---
715 | | prefixes: { ex: "http://example.org/" }
716 | | rdf_inline:
...   |
729 | |         assert_contains!(out, "Count: 0");
730 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/template.rs:732:5
    |
732 | /     test!(projection_helpers_and_multiple_queries, {
733 | |         let input = r#"---
734 | | prefixes: { ex: "http://example.org/" }
735 | | rdf_inline:
...   |
750 | |         assert_contains!(out, "Ages:");
751 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/template.rs:753:5
    |
753 | /     test!(preprocessor_integration, {
754 | |         use std::path::Path;
755 | |         use tempfile::TempDir;
...   |
793 | |         assert!(!template.body.contains("endfreeze"));
794 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/template_cache.rs:239:5
    |
239 | /     test!(test_template_cache_new, {
240 | |         let cache = TemplateCache::new(50);
241 | |         let stats = cache.stats().unwrap();
242 | |         assert_eq!(stats.capacity, 50);
243 | |         assert_eq!(stats.size, 0);
244 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/template_cache.rs:246:5
    |
246 | /     test!(test_template_cache_default, {
247 | |         let cache = TemplateCache::default();
248 | |         let stats = cache.stats().unwrap();
249 | |         assert_eq!(stats.capacity, 100);
250 | |         assert_eq!(stats.size, 0);
251 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/template_cache.rs:253:5
    |
253 | /     test!(test_get_or_parse, {
254 | |         let cache = TemplateCache::new(10);
255 | |
256 | |         let mut temp = NamedTempFile::new()?;
...   |
276 | |         Ok(())
277 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/template_cache.rs:279:5
    |
279 | /     test!(test_cache_clear, {
280 | |         let cache = TemplateCache::new(10);
281 | |
282 | |         let mut temp = NamedTempFile::new()?;
...   |
297 | |         Ok(())
298 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/template_cache.rs:300:5
    |
300 | /     test!(test_cache_eviction, {
301 | |         let cache = TemplateCache::new(2);
...   |
321 | |         Ok(())
322 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/templates/context.rs:577:5
    |
577 | /     test!(test_new_context, {
578 | |         let ctx = TemplateContext::new();
579 | |         assert!(ctx.variables.is_empty());
580 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/templates/context.rs:582:5
    |
582 | /     test!(test_set_and_get, {
583 | |         let mut ctx = TemplateContext::new();
584 | |         ctx.set("name", "test").unwrap();
...   |
587 | |         assert!(ctx.contains("name"));
588 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/templates/context.rs:590:5
    |
590 | /     test!(test_from_map, {
591 | |         let mut vars = BTreeMap::new();
592 | |         vars.insert("service_name".to_string(), "my-service".to_string());
593 | |         vars.insert("port".to_string(), "8080".to_string());
...   |
601 | |         assert_eq!(ctx.get_string("port"), Some("8080".to_string()));
602 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/templates/context.rs:604:5
    |
604 | /     test!(test_merge, {
605 | |         let mut ctx1 = TemplateContext::new();
606 | |         ctx1.set("name", "test1").unwrap();
...   |
614 | |         assert_eq!(ctx1.get_string("port"), Some("8080".to_string()));
615 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/templates/context.rs:617:5
    |
617 | /     test!(test_validate_required, {
618 | |         let mut ctx = TemplateContext::new();
619 | |         ctx.set("name", "test").unwrap();
...   |
625 | |         assert!(result.unwrap_err().to_string().contains("port"));
626 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/templates/context.rs:628:5
    |
628 | /     test!(test_apply_defaults, {
629 | |         let mut ctx = TemplateContext::new();
630 | |         ctx.set("name", "test").unwrap();
...   |
641 | |         assert_eq!(ctx.get_string("port"), Some("8080".to_string()));
642 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/templates/context.rs:644:5
    |
644 | /     test!(test_render_string, {
645 | |         let mut ctx = TemplateContext::new();
646 | |         ctx.set("name", "World").unwrap();
647 | |         ctx.set("count", 42).unwrap();
...   |
652 | |         assert_eq!(rendered, "Hello, World! Count: 42");
653 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/templates/context.rs:655:5
    |
655 | /     test!(test_variable_names, {
656 | |         let mut ctx = TemplateContext::new();
657 | |         ctx.set("name", "test").unwrap();
658 | |         ctx.set("port", "8080").unwrap();
...   |
663 | |         assert!(names.contains(&"port"));
664 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/templates/file_tree_generator.rs:670:5
    |
670 | /     test!(test_create_template, {
671 | |         let format = TemplateFormat::new("test-template");
672 | |         let template = FileTreeTemplate::new(format);
...   |
675 | |         assert!(template.description().is_none());
676 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/templates/file_tree_generator.rs:678:5
    |
678 | /     test!(test_parse_yaml_template, {
679 | |         let yaml = r#"
680 | | name: test-template
681 | | description: A test template
...   |
702 | |         assert_eq!(template.nodes().len(), 1);
703 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/templates/file_tree_generator.rs:705:5
    |
705 | /     test!(test_parse_template_with_rdf, {
706 | |         let yaml = r#"
707 | | name: microservice-template
708 | | rdf:
...   |
722 | |         assert!(template.rdf_turtle.is_some());
723 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/templates/file_tree_generator.rs:725:5
    |
725 | /     test!(test_template_validation, {
726 | |         let format = TemplateFormat::new("test");
727 | |         let template = FileTreeTemplate::new(format);
...   |
730 | |         assert!(template.validate().is_err());
731 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/templates/file_tree_generator.rs:733:5
    |
733 | /     test!(test_parser_extract_name, {
734 | |         let line = r#"[directory: "src"]"#;
735 | |         let name = TemplateParser::extract_name(line).unwrap();
736 | |         assert_eq!(name, "src");
737 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/templates/file_tree_generator.rs:739:5
    |
739 | /     test!(test_parse_simple_format, {
740 | |         let content = r#"
741 | | [directory: "src"]
742 | | [file: "main.rs"]
...   |
746 | |         assert_eq!(template.nodes().len(), 2);
747 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/templates/format.rs:669:5
    |
669 | /     test!(test_directory_node, {
670 | |         let node = FileTreeNode::directory("src");
671 | |         assert_eq!(node.node_type, NodeType::Directory);
672 | |         assert_eq!(node.name, "src");
673 | |         assert!(node.children.is_empty());
674 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/templates/format.rs:676:5
    |
676 | /     test!(test_file_node_with_content, {
677 | |         let node = FileTreeNode::file_with_content("main.rs", "fn main() {}");
678 | |         assert_eq!(node.node_type, NodeType::File);
679 | |         assert_eq!(node.name, "main.rs");
680 | |         assert_eq!(node.content, Some("fn main() {}".to_string()));
681 | |         assert_eq!(node.template, None);
682 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/templates/format.rs:684:5
    |
684 | /     test!(test_file_node_with_template, {
685 | |         let node = FileTreeNode::file_with_template("lib.rs", "templates/lib.rs.tera");
686 | |         assert_eq!(node.node_type, NodeType::File);
687 | |         assert_eq!(node.name, "lib.rs");
688 | |         assert_eq!(node.template, Some("templates/lib.rs.tera".to_string()));
689 | |         assert_eq!(node.content, None);
690 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/templates/format.rs:692:5
    |
692 | /     test!(test_template_format_creation, {
693 | |         let mut format = TemplateFormat::new("test-template");
694 | |         format.add_variable("service_name");
695 | |         format.add_default("port", "8080");
...   |
699 | |         assert_eq!(format.defaults.get("port"), Some(&"8080".to_string()));
700 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/templates/format.rs:702:5
    |
702 | /     test!(test_template_format_validation, {
703 | |         let mut format = TemplateFormat::new("test");
704 | |         format.add_node(FileTreeNode::directory("src"));
...   |
707 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/templates/format.rs:709:5
    |
709 | /     test!(test_empty_template_validation_fails, {
710 | |         let format = TemplateFormat::new("test");
711 | |         assert!(format.validate().is_err());
712 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/templates/frozen.rs:493:5
    |
493 | /     test!(test_parse_simple_frozen_section, {
494 | |         let content = r#"
495 | | Before frozen
496 | | {% frozen %}
...   |
505 | |         assert_eq!(sections[0].id, None);
506 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/templates/frozen.rs:508:5
    |
508 | /     test!(test_parse_frozen_section_with_id, {
509 | |         let content = r#"
510 | | {% frozen id="custom_logic" %}
511 | | my implementation
...   |
518 | |         assert_eq!(sections[0].id, Some("custom_logic".to_string()));
519 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/templates/frozen.rs:521:5
    |
521 | /     test!(test_parse_multiple_frozen_sections, {
522 | |         let content = r#"
523 | | {% frozen id="section1" %}
524 | | code 1
...   |
537 | |         assert_eq!(sections[1].id, Some("section2".to_string()));
538 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/templates/frozen.rs:540:5
    |
540 | /     test!(test_parse_unclosed_frozen_tag, {
541 | |         let content = r#"
542 | | {% frozen %}
543 | | unclosed section
...   |
547 | |         assert!(result.is_err());
548 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/templates/frozen.rs:550:5
    |
550 | /     test!(test_extract_frozen_map, {
551 | |         let content = r#"
552 | | {% frozen id="logic" %}
553 | | preserved code
...   |
559 | |         assert!(map.get("logic").unwrap().contains("preserved code"));
560 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/templates/frozen.rs:563:5
    |
563 | /     test!(test_merge_with_frozen, {
564 | |         let old_content = r#"
565 | | {% frozen id="custom" %}
566 | | old user code
...   |
578 | |         assert!(!merged.contains("new generated code"));
579 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/templates/frozen.rs:581:5
    |
581 | /     test!(test_merge_without_frozen_sections, {
582 | |         let old_content = "no frozen sections";
583 | |         let new_content = "new content";
...   |
586 | |         assert_eq!(merged, "new content");
587 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/templates/frozen.rs:589:5
    |
589 | /     test!(test_has_frozen_sections, {
590 | |         assert!(FrozenMerger::has_frozen_sections(
591 | |             "{% frozen %}code{% endfrozen %}"
592 | |         ));
593 | |         assert!(!FrozenMerger::has_frozen_sections("no frozen sections"));
594 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/templates/frozen.rs:596:5
    |
596 | /     test!(test_strip_frozen_tags, {
597 | |         let content = r#"
598 | | Before
599 | | {% frozen id="test" %}
...   |
608 | |         assert!(stripped.contains("keep this content"));
609 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/templates/frozen.rs:612:5
    |
612 | /     test!(test_merge_numbered_sections, {
613 | |         let old_content = r#"
614 | | {% frozen %}
615 | | first section
...   |
635 | |         assert!(!merged.contains("new second"));
636 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/tera_env.rs:99:5
    |
 99 | /     test!(test_build_tera_with_glob, {
100 | |         let temp_dir = TempDir::new()?;
101 | |         let templates_dir = temp_dir.path().join("templates");
102 | |         fs::create_dir_all(&templates_dir)?;
...   |
116 | |         Ok(())
117 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/tera_env.rs:119:5
    |
119 | /     test!(test_build_tera_empty_directory, {
120 | |         let temp_dir = TempDir::new()?;
121 | |         let templates_dir = temp_dir.path().join("templates");
122 | |         fs::create_dir_all(&templates_dir)?;
...   |
133 | |         Ok(())
134 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/tera_env.rs:136:5
    |
136 | /     test!(test_build_tera_minimal, {
137 | |         let mut tera = build_tera_minimal()?;
...   |
144 | |         Ok(())
145 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0107]: type alias takes 1 generic argument but 2 generic arguments were supplied
   --> crates/ggen-core/src/tera_env.rs:147:5
    |
147 | /     test!(test_autoescape_disabled, {
148 | |         let mut tera = build_tera_minimal()?;
...   |
155 | |         Ok(())
156 | |     });
    | |      ^
    | |      |
    | |______expected 1 generic argument
    |        help: remove the unnecessary generic argument
    |
note: type alias defined here, with 1 generic parameter: `T`
   --> /Users/sac/ggen/crates/ggen-utils/src/error.rs:188:10
    |
188 | pub type Result<T> = std::result::Result<T, Error>;
    |          ^^^^^^ -
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
   --> crates/ggen-core/src/cache.rs:591:68
    |
588 |     fn test_cache_manager_creation() {
    |     -------------------------------- this function should return `Result` or `Option` to accept `?`
...
591 |             .map_err(|e| Box::new(e) as Box<dyn std::error::Error>)?;
    |                                                                    ^ cannot use the `?` operator in a function that returns `()`
    |
help: consider adding return type
    |
588 |     fn test_cache_manager_creation() -> Result<(), Box<dyn std::error::Error>> {
    |                                      +++++++++++++++++++++++++++++++++++++++++

error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
   --> crates/ggen-core/src/cache.rs:595:68
    |
588 |     fn test_cache_manager_creation() {
    |     -------------------------------- this function should return `Result` or `Option` to accept `?`
...
595 |             .map_err(|e| Box::new(e) as Box<dyn std::error::Error>)?;
    |                                                                    ^ cannot use the `?` operator in a function that returns `()`
    |
help: consider adding return type
    |
588 |     fn test_cache_manager_creation() -> Result<(), Box<dyn std::error::Error>> {
    |                                      +++++++++++++++++++++++++++++++++++++++++

error[E0308]: mismatched types
   --> crates/ggen-core/src/cache.rs:597:9
    |
588 |     fn test_cache_manager_creation() {
    |                                     - help: try adding a return type: `-> std::result::Result<(), Box<dyn StdError>>`
...
597 |         Ok::<(), Box<dyn std::error::Error>>(())
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `()`, found `Result<(), Box<dyn Error>>`
    |
    = note: expected unit type `()`
                    found enum `std::result::Result<(), Box<dyn StdError>>`

error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
   --> crates/ggen-core/src/cache.rs:604:68
    |
601 |     fn test_sha256_calculation() {
    |     ---------------------------- this function should return `Result` or `Option` to accept `?`
...
604 |             .map_err(|e| Box::new(e) as Box<dyn std::error::Error>)?;
    |                                                                    ^ cannot use the `?` operator in a function that returns `()`
    |
help: consider adding return type
    |
601 |     fn test_sha256_calculation() -> Result<(), Box<dyn std::error::Error>> {
    |                                  +++++++++++++++++++++++++++++++++++++++++

error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
   --> crates/ggen-core/src/cache.rs:608:68
    |
601 |     fn test_sha256_calculation() {
    |     ---------------------------- this function should return `Result` or `Option` to accept `?`
...
608 |             .map_err(|e| Box::new(e) as Box<dyn std::error::Error>)?;
    |                                                                    ^ cannot use the `?` operator in a function that returns `()`
    |
help: consider adding return type
    |
601 |     fn test_sha256_calculation() -> Result<(), Box<dyn std::error::Error>> {
    |                                  +++++++++++++++++++++++++++++++++++++++++

error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
   --> crates/ggen-core/src/cache.rs:613:68
    |
601 |     fn test_sha256_calculation() {
    |     ---------------------------- this function should return `Result` or `Option` to accept `?`
...
613 |             .map_err(|e| Box::new(e) as Box<dyn std::error::Error>)?;
    |                                                                    ^ cannot use the `?` operator in a function that returns `()`
    |
help: consider adding return type
    |
601 |     fn test_sha256_calculation() -> Result<(), Box<dyn std::error::Error>> {
    |                                  +++++++++++++++++++++++++++++++++++++++++

error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
   --> crates/ggen-core/src/cache.rs:616:68
    |
601 |     fn test_sha256_calculation() {
    |     ---------------------------- this function should return `Result` or `Option` to accept `?`
...
616 |             .map_err(|e| Box::new(e) as Box<dyn std::error::Error>)?;
    |                                                                    ^ cannot use the `?` operator in a function that returns `()`
    |
help: consider adding return type
    |
601 |     fn test_sha256_calculation() -> Result<(), Box<dyn std::error::Error>> {
    |                                  +++++++++++++++++++++++++++++++++++++++++

error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
   --> crates/ggen-core/src/cache.rs:619:68
    |
601 |     fn test_sha256_calculation() {
    |     ---------------------------- this function should return `Result` or `Option` to accept `?`
...
619 |             .map_err(|e| Box::new(e) as Box<dyn std::error::Error>)?;
    |                                                                    ^ cannot use the `?` operator in a function that returns `()`
    |
help: consider adding return type
    |
601 |     fn test_sha256_calculation() -> Result<(), Box<dyn std::error::Error>> {
    |                                  +++++++++++++++++++++++++++++++++++++++++

error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
   --> crates/ggen-core/src/cache.rs:622:68
    |
601 |     fn test_sha256_calculation() {
    |     ---------------------------- this function should return `Result` or `Option` to accept `?`
...
622 |             .map_err(|e| Box::new(e) as Box<dyn std::error::Error>)?;
    |                                                                    ^ cannot use the `?` operator in a function that returns `()`
    |
help: consider adding return type
    |
601 |     fn test_sha256_calculation() -> Result<(), Box<dyn std::error::Error>> {
    |                                  +++++++++++++++++++++++++++++++++++++++++

error[E0308]: mismatched types
   --> crates/ggen-core/src/cache.rs:627:9
    |
601 |     fn test_sha256_calculation() {
    |                                 - help: try adding a return type: `-> std::result::Result<(), Box<dyn StdError>>`
...
627 |         Ok::<(), Box<dyn std::error::Error>>(())
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `()`, found `Result<(), Box<dyn Error>>`
    |
    = note: expected unit type `()`
                    found enum `std::result::Result<(), Box<dyn StdError>>`

error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
   --> crates/ggen-core/src/cache.rs:634:68
    |
631 |     fn test_list_cached_empty() {
    |     --------------------------- this function should return `Result` or `Option` to accept `?`
...
634 |             .map_err(|e| Box::new(e) as Box<dyn std::error::Error>)?;
    |                                                                    ^ cannot use the `?` operator in a function that returns `()`
    |
help: consider adding return type
    |
631 |     fn test_list_cached_empty() -> Result<(), Box<dyn std::error::Error>> {
    |                                 +++++++++++++++++++++++++++++++++++++++++

error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
   --> crates/ggen-core/src/cache.rs:636:68
    |
631 |     fn test_list_cached_empty() {
    |     --------------------------- this function should return `Result` or `Option` to accept `?`
...
636 |             .map_err(|e| Box::new(e) as Box<dyn std::error::Error>)?;
    |                                                                    ^ cannot use the `?` operator in a function that returns `()`
    |
help: consider adding return type
    |
631 |     fn test_list_cached_empty() -> Result<(), Box<dyn std::error::Error>> {
    |                                 +++++++++++++++++++++++++++++++++++++++++

error[E0277]: the `?` operator can only be used in a function that returns `Result` or `Option` (or another type that implements `FromResidual`)
   --> crates/ggen-core/src/cache.rs:640:68
    |
631 |     fn test_list_cached_empty() {
    |     --------------------------- this function should return `Result` or `Option` to accept `?`
...
640 |             .map_err(|e| Box::new(e) as Box<dyn std::error::Error>)?;
    |                                                                    ^ cannot use the `?` operator in a function that returns `()`
    |
help: consider adding return type
    |
631 |     fn test_list_cached_empty() -> Result<(), Box<dyn std::error::Error>> {
    |                                 +++++++++++++++++++++++++++++++++++++++++

error[E0308]: mismatched types
   --> crates/ggen-core/src/cache.rs:642:9
    |
631 |     fn test_list_cached_empty() {
    |                                - help: try adding a return type: `-> std::result::Result<(), Box<dyn StdError>>`
...
642 |         Ok::<(), Box<dyn std::error::Error>>(())
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `()`, found `Result<(), Box<dyn Error>>`
    |
    = note: expected unit type `()`
                    found enum `std::result::Result<(), Box<dyn StdError>>`

error[E0308]: mismatched types
   --> crates/ggen-core/src/delta.rs:825:5
    |
825 | /     test!(test_delta_creation, {
826 | |         let (baseline, current) = create_test_graph().unwrap();
827 | |         let delta = GraphDelta::new(&baseline, &current).unwrap();
...   |
836 | |         assert_eq!(counts.get("modifications"), None); // No modifications
837 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/delta.rs:839:5
    |
839 | /     test!(test_delta_affected_iris, {
840 | |         let (baseline, current) = create_test_graph().unwrap();
841 | |         let delta = GraphDelta::new(&baseline, &current).unwrap();
...   |
846 | |         assert!(affected.contains("<http://www.w3.org/2000/01/rdf-schema#domain>"));
847 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/delta.rs:849:5
    |
849 | /     test!(test_delta_filtering, {
850 | |         let (baseline, current) = create_test_graph()?;
851 | |         let delta = GraphDelta::new(&baseline, &current)?;
...   |
859 | |         Ok(())
860 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/delta.rs:862:5
    |
862 | /     test!(test_impact_analyzer, {
863 | |         let (baseline, current) = create_test_graph().unwrap();
864 | |         let delta = GraphDelta::new(&baseline, &current).unwrap();
...   |
881 | |         Ok(())
882 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/delta.rs:884:5
    |
884 | /     test!(test_graph_hash, {
885 | |         let (baseline, current) = create_test_graph().unwrap();
886 | |
887 | |         let hash1 = baseline.compute_hash().unwrap();
...   |
897 | |         Ok(())
898 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/delta.rs:900:5
    |
900 | /     test!(test_delta_display, {
901 | |         let (baseline, current) = create_test_graph().unwrap();
902 | |         let delta = GraphDelta::new(&baseline, &current).unwrap();
...   |
909 | |         Ok(())
910 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
  --> crates/ggen-core/src/e2e_tests.rs:46:5
   |
46 | /     test!(test_end_to_end_template_generation, {
47 | |         // Create a temporary directory for testing
48 | |         let temp_dir = TempDir::new()?;
49 | |         let output_dir = temp_dir.path().join("output");
...  |
94 | |         Ok(())
95 | |     });
   | |      ^
   | |      |
   | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
   |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
   |
   = note: expected enum `std::result::Result<_, ggen_utils::Error>`
              found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
   = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/e2e_tests.rs:97:5
    |
 97 | /     test!(test_end_to_end_with_rdf_data, {
 98 | |         let temp_dir = TempDir::new()?;
 99 | |         let output_dir = temp_dir.path().join("output");
100 | |         std::fs::create_dir_all(&output_dir)?;
...   |
160 | |         Ok(())
161 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/e2e_tests.rs:163:5
    |
163 | /     test!(test_end_to_end_deterministic_output, {
164 | |         let temp_dir = TempDir::new()?;
165 | |         let output_dir1 = temp_dir.path().join("output1");
166 | |         let output_dir2 = temp_dir.path().join("output2");
...   |
213 | |         Ok(())
214 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/e2e_tests.rs:216:5
    |
216 | /     test!(test_end_to_end_error_handling, {
217 | |         let temp_dir = TempDir::new()?;
218 | |         let output_dir = temp_dir.path().join("output");
219 | |         std::fs::create_dir_all(&output_dir)?;
...   |
252 | |         Ok(())
253 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/generator.rs:450:5
    |
450 | /     test!(test_gen_context_new, {
451 | |         let template_path = PathBuf::from("test.tmpl");
452 | |         let output_root = PathBuf::from("output");
...   |
461 | |         assert!(!ctx.dry_run);
462 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/generator.rs:464:5
    |
464 | /     test!(test_gen_context_with_vars, {
465 | |         let template_path = PathBuf::from("test.tmpl");
466 | |         let output_root = PathBuf::from("output");
467 | |         let mut vars = BTreeMap::new();
...   |
473 | |         assert_eq!(ctx.vars, vars);
474 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/generator.rs:476:5
    |
476 | /     test!(test_gen_context_with_prefixes, {
477 | |         let template_path = PathBuf::from("test.tmpl");
478 | |         let output_root = PathBuf::from("output");
479 | |         let mut prefixes = BTreeMap::new();
...   |
487 | |         assert_eq!(ctx.base, base);
488 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/generator.rs:490:5
    |
490 | /     test!(test_gen_context_dry, {
491 | |         let template_path = PathBuf::from("test.tmpl");
492 | |         let output_root = PathBuf::from("output");
...   |
498 | |         assert!(!ctx.dry_run);
499 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/generator.rs:501:5
    |
501 | /     test!(test_generator_new, {
502 | |         let pipeline = create_test_pipeline();
503 | |         let template_path = PathBuf::from("test.tmpl");
504 | |         let output_root = PathBuf::from("output");
...   |
519 | |             .contains("output"));
520 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/generator.rs:522:5
    |
522 | /     test!(test_generate_simple_template, {
523 | |         let (_temp_dir, template_path) = create_test_template(
524 | |             r#"---
525 | | to: "output/{{ name | lower }}.rs"
...   |
555 | |         assert!(content.contains("// Description: A test application"));
556 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/generator.rs:558:5
    |
558 | /     test!(test_generate_dry_run, {
559 | |         let (_temp_dir, template_path) = create_test_template(
560 | |             r#"---
561 | | to: "output/{{ name | lower }}.rs"
...   |
584 | |         assert!(!output_path.exists());
585 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/generator.rs:587:5
    |
587 | /     test!(test_generate_with_default_output, {
588 | |         let (_temp_dir, template_path) = create_test_template(
589 | |             r#"---
590 | | {}
...   |
612 | |         assert!(content.contains("// Default output content"));
613 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/generator.rs:615:5
    |
615 | /     test!(test_generate_with_nested_output_path, {
616 | |         let (_temp_dir, template_path) = create_test_template(
617 | |             r#"---
618 | | to: "src/{{ module }}/{{ name | lower }}.rs"
...   |
642 | |         assert!(content.contains("// Nested output content"));
643 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/generator.rs:645:5
    |
645 | /     test!(test_generate_invalid_template, {
646 | |         let (_temp_dir, template_path) = create_test_template(
647 | |             r#"---
648 | | invalid_yaml: [unclosed
...   |
662 | |         assert!(result.is_err());
663 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/generator.rs:665:5
    |
665 | /     test!(test_generate_missing_template_file, {
666 | |         let temp_dir = TempDir::new().expect("Failed to create temp dir");
667 | |         let template_path = temp_dir.path().join("nonexistent.tmpl");
668 | |         let output_dir = temp_dir.path();
...   |
677 | |         assert!(result.is_err());
678 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/generator.rs:680:5
    |
680 | /     test!(test_insert_env, {
681 | |         let mut ctx = Context::new();
...   |
692 | |         std::env::remove_var("TEST_GGEN_VAR");
693 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/github.rs:539:5
    |
539 | /     test!(test_repo_info_parse, {
540 | |         let repo = RepoInfo::parse("seanchatmangpt/ggen").unwrap();
541 | |         assert_eq!(repo.owner, "seanchatmangpt");
542 | |         assert_eq!(repo.name, "ggen");
543 | |         assert_eq!(repo.as_str(), "seanchatmangpt/ggen");
544 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/github.rs:546:5
    |
546 | /     test!(test_repo_info_parse_invalid, {
547 | |         assert!(RepoInfo::parse("invalid").is_err());
548 | |         assert!(RepoInfo::parse("too/many/parts").is_err());
549 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/gpack.rs:310:5
    |
310 | /     test!(test_manifest_parsing, {
311 | |         let toml_content = r#"
312 | | [gpack]
313 | | id = "io.ggen.rust.cli-subcommand"
...   |
352 | |         assert_eq!(manifest.queries.aliases.len(), 1);
353 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/gpack.rs:355:5
    |
355 | /     test!(test_manifest_load_from_file, {
356 | |         let mut temp_file = NamedTempFile::new().unwrap();
357 | |         let toml_content = r#"
358 | | [gpack]
...   |
369 | |         assert_eq!(manifest.metadata.id, "test");
370 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/graph/core.rs:731:5
    |
731 | /     test!(test_graph_new, {
732 | |         // Arrange & Act
733 | |         let graph = Graph::new().unwrap();
...   |
737 | |         assert_eq!(graph.len(), 0);
738 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/graph/core.rs:740:5
    |
740 | /     test!(test_graph_insert_turtle, {
741 | |         // Arrange
742 | |         let graph = Graph::new().unwrap();
...   |
756 | |         assert!(graph.len() > 0);
757 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/graph/core.rs:759:5
    |
759 | /     test!(test_graph_query_cached, {
760 | |         // Arrange
761 | |         let graph = Graph::new().unwrap();
762 | |         graph
...   |
785 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/graph/core.rs:787:5
    |
787 | /     test!(test_build_prolog_with_prefixes, {
788 | |         // Arrange
789 | |         let mut prefixes = BTreeMap::new();
790 | |         prefixes.insert("ex".to_string(), "http://example.org/".to_string());
...   |
801 | |         assert!(prolog.contains("PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>"));
802 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/graph/core.rs:804:5
    |
804 | /     test!(test_build_prolog_with_base, {
805 | |         // Arrange
806 | |         let prefixes = BTreeMap::new();
...   |
812 | |         assert!(prolog.contains("BASE <http://example.org/>"));
813 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/graph/export.rs:191:5
    |
191 | /     test!(test_export_write_to_file, {
192 | |         // Arrange
193 | |         let graph = Graph::new().unwrap();
194 | |         graph
...   |
214 | |         assert!(content.contains("ex:Person"));
215 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/graph/export.rs:217:5
    |
217 | /     test!(test_export_write_to_string_turtle, {
218 | |         // Arrange
219 | |         let graph = Graph::new().unwrap();
220 | |         graph
...   |
236 | |         assert!(result.contains("ex:") || result.contains("http://example.org/"));
237 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/graph/export.rs:239:5
    |
239 | /     test!(test_export_write_to_string_ntriples, {
240 | |         // Arrange
241 | |         let graph = Graph::new().unwrap();
242 | |         graph
...   |
258 | |         assert!(result.contains("http://example.org/alice"));
259 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/graph/export.rs:261:5
    |
261 | /     test!(test_export_write_to_string_rdfxml, {
262 | |         // Arrange
263 | |         let graph = Graph::new().unwrap();
264 | |         graph
...   |
280 | |         assert!(result.contains("<") && result.contains(">"));
281 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/graph/export.rs:283:5
    |
283 | /     test!(test_export_write_to_file_auto_turtle, {
284 | |         // Arrange
285 | |         let graph = Graph::new().unwrap();
286 | |         graph
...   |
304 | |         assert!(!content.is_empty());
305 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/graph/export.rs:307:5
    |
307 | /     test!(test_export_write_to_file_auto_ntriples, {
308 | |         // Arrange
309 | |         let graph = Graph::new().unwrap();
310 | |         graph
...   |
328 | |         assert!(!content.is_empty());
329 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/graph/export.rs:331:5
    |
331 | /     test!(test_export_write_to_file_auto_unsupported_format, {
332 | |         // Arrange
333 | |         let graph = Graph::new().unwrap();
334 | |         let export = GraphExport::new(&graph);
...   |
341 | |         assert!(result.unwrap_err().to_string().contains("unsupported"));
342 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/graph/export.rs:344:5
    |
344 | /     test!(test_export_format_specific_serialization, {
345 | |         // Arrange
346 | |         let graph = Graph::new().unwrap();
347 | |         graph
...   |
371 | |         assert!(turtle != ntriples || turtle != rdfxml || ntriples != rdfxml);
372 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/graph/export.rs:374:5
    |
374 | /     test!(test_export_turtle_format_preserves_prefixes, {
375 | |         // Arrange
376 | |         let graph = Graph::new().unwrap();
377 | |         graph
...   |
394 | |         assert!(turtle.contains("alice") || turtle.contains("Alice"));
395 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/graph/export.rs:397:5
    |
397 | /     test!(test_export_ntriples_format_uses_full_iris, {
398 | |         // Arrange
399 | |         let graph = Graph::new().unwrap();
400 | |         graph
...   |
415 | |         assert!(ntriples.contains("http://example.org/Person"));
416 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/graph/export.rs:418:5
    |
418 | /     test!(test_export_rdfxml_format_has_xml_structure, {
419 | |         // Arrange
420 | |         let graph = Graph::new().unwrap();
421 | |         graph
...   |
436 | |         assert!(rdfxml.contains("rdf:") || rdfxml.contains("RDF"));
437 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/graph/export.rs:439:5
    |
439 | /     test!(test_export_trig_format_supports_named_graphs, {
440 | |         // Arrange
441 | |         let graph = Graph::new().unwrap();
442 | |         graph
...   |
459 | |         assert!(trig.contains("http://example.org/graph1") || trig.contains("alice"));
460 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/graph/export.rs:462:5
    |
462 | /     test!(test_export_nquads_format_includes_graph_context, {
463 | |         // Arrange
464 | |         let graph = Graph::new().unwrap();
465 | |         graph
...   |
482 | |         assert!(nquads.contains("http://example.org/graph1") || nquads.contains("alice"));
483 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/graph/export.rs:485:5
    |
485 | /     test!(test_export_empty_graph, {
486 | |         // Arrange
487 | |         let graph = Graph::new().unwrap();
488 | |         let export = GraphExport::new(&graph);
...   |
496 | |         assert!(result.is_empty() || !result.is_empty());
497 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/graph/query.rs:115:5
    |
115 | /     test!(test_query_execute_cached, {
116 | |         // Arrange
117 | |         let graph = Graph::new().unwrap();
118 | |         graph
...   |
141 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/graph/query.rs:143:5
    |
143 | /     test!(test_query_execute, {
144 | |         // Arrange
145 | |         let graph = Graph::new().unwrap();
146 | |         graph
...   |
166 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/graph/query.rs:168:5
    |
168 | /     test!(test_query_execute_with_prefixes, {
169 | |         // Arrange
170 | |         let graph = Graph::new().unwrap();
171 | |         graph
...   |
193 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/graph/query.rs:195:5
    |
195 | /     test!(test_query_execute_with_base, {
196 | |         // Arrange
197 | |         let graph = Graph::new().unwrap();
198 | |         graph
...   |
223 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/graph/query.rs:225:5
    |
225 | /     test!(test_query_execute_prepared, {
226 | |         // Arrange
227 | |         let graph = Graph::new().unwrap();
228 | |         graph
...   |
248 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/graph/query.rs:250:5
    |
250 | /     test!(test_query_builder, {
251 | |         // Arrange
252 | |         let graph = Graph::new().unwrap();
253 | |         graph
...   |
277 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/graph/query.rs:279:5
    |
279 | /     test!(test_query_ask_query, {
280 | |         // Arrange
281 | |         let graph = Graph::new().unwrap();
282 | |         graph
...   |
300 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/graph/query.rs:302:5
    |
302 | /     test!(test_query_invalid_syntax, {
303 | |         // Arrange
304 | |         let graph = Graph::new().unwrap();
305 | |         let query = GraphQuery::new(&graph);
...   |
309 | |         assert!(result.is_err());
310 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/graph/store.rs:107:5
    |
107 | /     test!(test_store_new, {
108 | |         // Arrange & Act
109 | |         let store = GraphStore::new().unwrap();
...   |
113 | |         assert!(graph.is_empty());
114 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/graph/store.rs:116:5
    |
116 | /     test!(test_store_open_and_create_graph, {
117 | |         // Arrange
118 | |         let temp_dir = TempDir::new().unwrap();
119 | |         let store_path = temp_dir.path().join("test_store");
...   |
127 | |         assert!(store_path.exists() || !store_path.exists()); // Store may or may not create directory immediately
128 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/graph/store.rs:130:5
    |
130 | /     test!(test_store_create_graph_and_insert, {
131 | |         // Arrange
132 | |         let store = GraphStore::new().unwrap();
133 | |         let graph = store.create_graph().unwrap();
...   |
147 | |         assert!(graph.len() > 0);
148 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/graph/store.rs:150:5
    |
150 | /     test!(test_store_multiple_graphs_share_data, {
151 | |         // Arrange
152 | |         let store = GraphStore::new().unwrap();
153 | |         let graph1 = store.create_graph().unwrap();
...   |
170 | |         assert_eq!(graph1.len(), graph2.len());
171 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/graph/store.rs:173:5
    |
173 | /     test!(test_store_persistent_storage, {
174 | |         // Arrange
175 | |         let temp_dir = TempDir::new().unwrap();
176 | |         let store_path = temp_dir.path().join("persistent_store");
...   |
199 | |         assert!(!graph2.is_empty());
200 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/graph/store.rs:202:5
    |
202 | /     test!(test_store_inner_access, {
203 | |         // Arrange
204 | |         let store = GraphStore::new().unwrap();
...   |
210 | |         assert_eq!(inner.len().unwrap_or(0), 0);
211 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/graph/store.rs:213:5
    |
213 | /     test!(test_store_resource_cleanup, {
214 | |         // Arrange
215 | |         let temp_dir = TempDir::new().unwrap();
216 | |         let store_path = temp_dir.path().join("cleanup_test");
...   |
238 | |         assert!(graph2.len() > 0);
239 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/graph/update.rs:245:5
    |
245 | /     test!(test_update_insert, {
246 | |         // Arrange
247 | |         let graph = Graph::new().unwrap();
248 | |         let update = GraphUpdate::new(&graph);
...   |
269 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/graph/update.rs:271:5
    |
271 | /     test!(test_update_delete, {
272 | |         // Arrange
273 | |         let graph = Graph::new().unwrap();
274 | |         graph
...   |
291 | |         assert!(graph.len() < initial_len);
292 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/graph/update.rs:294:5
    |
294 | /     test!(test_update_delete_where, {
295 | |         // Arrange
296 | |         let graph = Graph::new().unwrap();
297 | |         graph
...   |
323 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/graph/update.rs:325:5
    |
325 | /     test!(test_update_update_operation, {
326 | |         // Arrange
327 | |         let graph = Graph::new().unwrap();
328 | |         graph
...   |
356 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/graph/update.rs:358:5
    |
358 | /     test!(test_update_clear, {
359 | |         // Arrange
360 | |         let graph = Graph::new().unwrap();
361 | |         graph
...   |
376 | |         assert!(graph.is_empty());
377 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/graph/update.rs:379:5
    |
379 | /     test!(test_update_clear_graph, {
380 | |         // Arrange
381 | |         let graph = Graph::new().unwrap();
382 | |         graph
...   |
398 | |         assert!(graph.len() < initial_len);
399 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/graph/update.rs:401:5
    |
401 | /     test!(test_update_clear_all, {
402 | |         // Arrange
403 | |         let graph = Graph::new().unwrap();
404 | |         graph
...   |
419 | |         assert!(graph.is_empty());
420 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/graph/update.rs:422:5
    |
422 | /     test!(test_update_execute_invalid_syntax, {
423 | |         // Arrange
424 | |         let graph = Graph::new().unwrap();
425 | |         let update = GraphUpdate::new(&graph);
...   |
430 | |         assert!(result.unwrap_err().to_string().contains("SPARQL Update"));
431 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/graph/update.rs:433:5
    |
433 | /     test!(test_update_copy, {
434 | |         // Arrange
435 | |         let graph = Graph::new().unwrap();
436 | |         graph
...   |
466 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/inject.rs:329:5
    |
329 | /     test!(test_detect_eol_crlf, {
330 | |         let temp_file = NamedTempFile::new()?;
331 | |         fs::write(temp_file.path(), "line1\r\nline2\r\n")?;
...   |
334 | |         assert_eq!(eol, "\r\n");
335 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/inject.rs:337:5
    |
337 | /     test!(test_detect_eol_lf, {
338 | |         let temp_file = NamedTempFile::new()?;
339 | |         fs::write(temp_file.path(), "line1\nline2\n")?;
...   |
342 | |         assert_eq!(eol, "\n");
343 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/inject.rs:345:5
    |
345 | /     test!(test_detect_eol_cr, {
346 | |         let temp_file = NamedTempFile::new()?;
347 | |         fs::write(temp_file.path(), "line1\rline2\r")?;
...   |
350 | |         assert_eq!(eol, "\r");
351 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/inject.rs:353:5
    |
353 | /     test!(test_detect_eol_no_eol, {
354 | |         let temp_file = NamedTempFile::new()?;
355 | |         fs::write(temp_file.path(), "single line")?;
...   |
358 | |         assert_eq!(eol, EolNormalizer::platform_default());
359 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/inject.rs:361:5
    |
361 | /     test!(test_detect_eol_nonexistent_file, {
362 | |         let eol = EolNormalizer::detect_eol(Path::new("/nonexistent/file"))?;
363 | |         assert_eq!(eol, EolNormalizer::platform_default());
364 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/inject.rs:366:5
    |
366 | /     test!(test_normalize_to_eol, {
367 | |         let content = "line1\r\nline2\rline3\nline4";
...   |
379 | |         assert_eq!(normalized_cr, "line1\rline2\rline3\rline4");
380 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/inject.rs:382:5
    |
382 | /     test!(test_normalize_to_match_file, {
383 | |         let temp_file = NamedTempFile::new()?;
384 | |         fs::write(temp_file.path(), "existing\r\ncontent")?;
...   |
390 | |         assert_eq!(normalized, "new\r\ncontent");
391 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/inject.rs:393:5
    |
393 | /     test!(test_generate_exact_match, {
394 | |         let content = "function hello() {\n  console.log('world');\n}";
395 | |         let pattern = SkipIfGenerator::generate_exact_match(content);
...   |
402 | |         assert!(regex.is_match(content));
403 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/inject.rs:405:5
    |
405 | /     test!(test_generate_exact_match_with_special_chars, {
406 | |         let content = "function test() {\n  return /^[a-z]+$/;\n}";
407 | |         let pattern = SkipIfGenerator::generate_exact_match(content);
...   |
415 | |         assert!(!regex.is_match(different_content));
416 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/inject.rs:418:5
    |
418 | /     test!(test_content_exists_in_file, {
419 | |         let temp_file = NamedTempFile::new()?;
420 | |         let content = "function hello() {\n  console.log('world');\n}";
421 | |         fs::write(
...   |
437 | |         )?);
438 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/inject.rs:440:5
    |
440 | /     test!(test_content_exists_in_nonexistent_file, {
441 | |         let result =
442 | |             SkipIfGenerator::content_exists_in_file("content", Path::new("/nonexistent/file"))?;
443 | |         assert!(!result);
444 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/inject.rs:446:5
    |
446 | /     test!(test_generate_idempotent_pattern, {
447 | |         let content = "function test() {}";
448 | |         let pattern = SkipIfGenerator::generate_idempotent_pattern(content);
...   |
455 | |         assert!(regex.is_match(content));
456 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/inject.rs:458:5
    |
458 | /     test!(test_platform_default, {
459 | |         let default = EolNormalizer::platform_default();
...   |
463 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lifecycle/error.rs:332:5
    |
332 | /     test!(test_phase_not_found_error, {
333 | |         let err = LifecycleError::phase_not_found("build");
334 | |         assert_eq!(err.to_string(), "Phase 'build' not found in configuration");
335 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), LifecycleError>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), lifecycle::error::LifecycleError>` because of return type
    |
    = note: expected enum `std::result::Result<_, lifecycle::error::LifecycleError>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lifecycle/error.rs:337:5
    |
337 | /     test!(test_command_failed_error, {
338 | |         let err = LifecycleError::command_failed("test", "cargo test", 101, "test failed");
339 | |         let msg = err.to_string();
340 | |         assert!(msg.contains("Command failed"));
341 | |         assert!(msg.contains("Exit code: 101"));
342 | |         assert!(msg.contains("test failed"));
343 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), LifecycleError>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), lifecycle::error::LifecycleError>` because of return type
    |
    = note: expected enum `std::result::Result<_, lifecycle::error::LifecycleError>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lifecycle/error.rs:345:5
    |
345 | /     test!(test_hook_recursion_error, {
346 | |         let err = LifecycleError::hook_recursion("build");
347 | |         let msg = err.to_string();
348 | |         assert!(msg.contains("Hook recursion detected"));
349 | |         assert!(msg.contains("build"));
350 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), LifecycleError>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), lifecycle::error::LifecycleError>` because of return type
    |
    = note: expected enum `std::result::Result<_, lifecycle::error::LifecycleError>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lifecycle/error.rs:352:5
    |
352 | /     test!(test_hook_recursion_with_chain, {
353 | |         let chain = vec![
354 | |             "init".to_string(),
355 | |             "setup".to_string(),
...   |
361 | |         assert!(msg.contains("init -> setup -> build -> init"));
362 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), LifecycleError>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), lifecycle::error::LifecycleError>` because of return type
    |
    = note: expected enum `std::result::Result<_, lifecycle::error::LifecycleError>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lifecycle/error.rs:364:5
    |
364 | /     test!(test_state_errors, {
365 | |         let path = PathBuf::from("/tmp/state.json");
...   |
375 | |         assert!(err.to_string().contains("Failed to save state"));
376 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), LifecycleError>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), lifecycle::error::LifecycleError>` because of return type
    |
    = note: expected enum `std::result::Result<_, lifecycle::error::LifecycleError>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lifecycle/error.rs:378:5
    |
378 | /     test!(test_make_toml_errors, {
379 | |         let path = PathBuf::from("/tmp/make.toml");
...   |
385 | |         assert!(err.to_string().contains("/tmp/make.toml"));
386 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), LifecycleError>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), lifecycle::error::LifecycleError>` because of return type
    |
    = note: expected enum `std::result::Result<_, lifecycle::error::LifecycleError>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lifecycle/error.rs:388:5
    |
388 | /     test!(test_cache_errors, {
389 | |         let path = PathBuf::from("/tmp/cache");
...   |
399 | |         assert!(err.to_string().contains("build"));
400 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), LifecycleError>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), lifecycle::error::LifecycleError>` because of return type
    |
    = note: expected enum `std::result::Result<_, lifecycle::error::LifecycleError>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lifecycle/error.rs:402:5
    |
402 | /     test!(test_error_downcasting, {
403 | |         let err = LifecycleError::phase_not_found("build");
404 | |         let err_ref: &dyn std::error::Error = &err;
405 | |         assert!(err_ref.source().is_none());
...   |
410 | |         assert!(err_ref.source().is_some());
411 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), LifecycleError>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), lifecycle::error::LifecycleError>` because of return type
    |
    = note: expected enum `std::result::Result<_, lifecycle::error::LifecycleError>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lifecycle/error.rs:413:5
    |
413 | /     test!(test_error_display, {
414 | |         let lifecycle_err = LifecycleError::phase_not_found("test");
415 | |         let err_str = lifecycle_err.to_string();
416 | |         assert!(err_str.contains("Phase 'test' not found"));
417 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), LifecycleError>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), lifecycle::error::LifecycleError>` because of return type
    |
    = note: expected enum `std::result::Result<_, lifecycle::error::LifecycleError>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lifecycle/hooks.rs:249:5
    |
249 | /     test!(test_valid_hooks_pass_validation, {
250 | |         let mut hooks = Hooks::default();
251 | |         hooks.before_build = Some(vec!["validate".to_string()]);
...   |
257 | |         assert!(ValidatedHooks::validate(&hooks, &phase_names).is_ok());
258 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), LifecycleError>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), lifecycle::error::LifecycleError>` because of return type
    |
    = note: expected enum `std::result::Result<_, lifecycle::error::LifecycleError>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lifecycle/hooks.rs:260:5
    |
260 | /     test!(test_invalid_phase_reference_fails, {
261 | |         let mut hooks = Hooks::default();
262 | |         hooks.before_build = Some(vec!["nonexistent".to_string()]);
...   |
267 | |         assert!(ValidatedHooks::validate(&hooks, &phase_names).is_err());
268 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), LifecycleError>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), lifecycle::error::LifecycleError>` because of return type
    |
    = note: expected enum `std::result::Result<_, lifecycle::error::LifecycleError>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lifecycle/hooks.rs:270:5
    |
270 | /     test!(test_self_reference_fails, {
271 | |         let mut hooks = Hooks::default();
272 | |         hooks.before_build = Some(vec!["build".to_string()]);
...   |
277 | |         assert!(ValidatedHooks::validate(&hooks, &phase_names).is_err());
278 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), LifecycleError>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), lifecycle::error::LifecycleError>` because of return type
    |
    = note: expected enum `std::result::Result<_, lifecycle::error::LifecycleError>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lifecycle/hooks.rs:280:5
    |
280 | /     test!(test_circular_dependency_fails, {
281 | |         // Test circular dependency with existing hook types
282 | |         let mut hooks = Hooks::default();
283 | |         hooks.before_build = Some(vec!["validate".to_string()]);
...   |
300 | |         assert!(ValidatedHooks::validate(&hooks, &phase_names).is_ok());
301 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), LifecycleError>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), lifecycle::error::LifecycleError>` because of return type
    |
    = note: expected enum `std::result::Result<_, lifecycle::error::LifecycleError>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lifecycle/poka_yoke.rs:375:5
    |
375 | /     test!(test_non_empty_path_valid, {
376 | |         let path = NonEmptyPath::new(PathBuf::from("test.txt")).unwrap();
377 | |         assert_eq!(path.as_path(), Path::new("test.txt"));
378 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), LifecycleError>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), lifecycle::error::LifecycleError>` because of return type
    |
    = note: expected enum `std::result::Result<_, lifecycle::error::LifecycleError>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lifecycle/poka_yoke.rs:380:5
    |
380 | /     test!(test_non_empty_path_empty_rejected, {
381 | |         let empty = NonEmptyPath::new(PathBuf::from(""));
382 | |         assert!(empty.is_err());
383 | |         assert_eq!(empty.unwrap_err(), EmptyPathError);
384 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), LifecycleError>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), lifecycle::error::LifecycleError>` because of return type
    |
    = note: expected enum `std::result::Result<_, lifecycle::error::LifecycleError>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lifecycle/poka_yoke.rs:386:5
    |
386 | /     test!(test_non_empty_path_join, {
387 | |         let base: NonEmptyPath = "base".parse().unwrap();
388 | |         let joined = base.join("file.txt");
389 | |         assert!(joined.as_path().to_str().unwrap().contains("base"));
390 | |         assert!(joined.as_path().to_str().unwrap().contains("file.txt"));
391 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), LifecycleError>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), lifecycle::error::LifecycleError>` because of return type
    |
    = note: expected enum `std::result::Result<_, lifecycle::error::LifecycleError>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lifecycle/poka_yoke.rs:393:5
    |
393 | /     test!(test_non_empty_string_valid, {
394 | |         let s = NonEmptyString::new("hello".to_string()).unwrap();
395 | |         assert_eq!(s.as_str(), "hello");
396 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), LifecycleError>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), lifecycle::error::LifecycleError>` because of return type
    |
    = note: expected enum `std::result::Result<_, lifecycle::error::LifecycleError>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lifecycle/poka_yoke.rs:398:5
    |
398 | /     test!(test_non_empty_string_empty_rejected, {
399 | |         let empty = NonEmptyString::new("".to_string());
400 | |         assert!(empty.is_err());
401 | |         assert_eq!(empty.unwrap_err(), EmptyStringError);
402 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), LifecycleError>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), lifecycle::error::LifecycleError>` because of return type
    |
    = note: expected enum `std::result::Result<_, lifecycle::error::LifecycleError>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lifecycle/poka_yoke.rs:404:5
    |
404 | /     test!(test_counter_cannot_be_negative, {
405 | |         let mut counter = Counter::new(0);
406 | |         counter.decrement(); // Saturates at 0
407 | |         assert_eq!(counter.get(), 0);
...   |
410 | |         assert_eq!(counter.get(), 0);
411 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), LifecycleError>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), lifecycle::error::LifecycleError>` because of return type
    |
    = note: expected enum `std::result::Result<_, lifecycle::error::LifecycleError>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lifecycle/poka_yoke.rs:413:5
    |
413 | /     test!(test_counter_cannot_overflow, {
414 | |         let mut counter = Counter::new(u32::MAX);
415 | |         counter.increment(); // Saturates at MAX
416 | |         assert_eq!(counter.get(), u32::MAX);
417 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), LifecycleError>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), lifecycle::error::LifecycleError>` because of return type
    |
    = note: expected enum `std::result::Result<_, lifecycle::error::LifecycleError>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lifecycle/poka_yoke.rs:419:5
    |
419 | /     test!(test_counter_normal_operations, {
420 | |         let mut counter = Counter::new(5);
421 | |         counter.increment();
422 | |         assert_eq!(counter.get(), 6);
...   |
434 | |         assert_eq!(counter.get(), 0);
435 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), LifecycleError>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), lifecycle::error::LifecycleError>` because of return type
    |
    = note: expected enum `std::result::Result<_, lifecycle::error::LifecycleError>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lifecycle/poka_yoke.rs:437:5
    |
437 | /     test!(test_file_handle_type_safety, {
...   |
451 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), LifecycleError>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), lifecycle::error::LifecycleError>` because of return type
    |
    = note: expected enum `std::result::Result<_, lifecycle::error::LifecycleError>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lifecycle/state_machine.rs:212:5
    |
212 | /     test!(test_valid_state_transitions, {
213 | |         // State machine validates transitions but doesn't record phases
214 | |         // Phases are recorded in exec.rs during actual execution
215 | |         let mut lifecycle = LifecycleStateMachine::<Initial>::new();
...   |
261 | |         assert!(lifecycle.has_completed_phase("deploy"));
262 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), LifecycleError>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), lifecycle::error::LifecycleError>` because of return type
    |
    = note: expected enum `std::result::Result<_, lifecycle::error::LifecycleError>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lifecycle/state_machine.rs:264:5
    |
264 | /     test!(test_state_access, {
265 | |         let lifecycle = LifecycleStateMachine::<Initial>::new();
266 | |         assert_eq!(lifecycle.last_phase(), None);
267 | |         assert!(!lifecycle.has_completed_phase("init"));
268 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), LifecycleError>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), lifecycle::error::LifecycleError>` because of return type
    |
    = note: expected enum `std::result::Result<_, lifecycle::error::LifecycleError>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lifecycle/state_machine.rs:270:5
    |
270 | /     test!(test_invalid_transition_validation, {
271 | |         let lifecycle = LifecycleStateMachine::<Initial>::new();
...   |
285 | |         let _lifecycle = lifecycle.setup().unwrap(); // Now this works
286 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), LifecycleError>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), lifecycle::error::LifecycleError>` because of return type
    |
    = note: expected enum `std::result::Result<_, lifecycle::error::LifecycleError>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lifecycle/state_validation.rs:190:5
    |
190 | /     test!(test_valid_state_passes_validation, {
191 | |         let mut state = LifecycleState::default();
192 | |         state.record_run("init".to_string(), 0, 100, true);
193 | |         state.record_run("setup".to_string(), 100, 200, true);
...   |
196 | |         assert!(ValidatedLifecycleState::validate(&state).is_ok());
197 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), LifecycleError>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), lifecycle::error::LifecycleError>` because of return type
    |
    = note: expected enum `std::result::Result<_, lifecycle::error::LifecycleError>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lifecycle/state_validation.rs:199:5
    |
199 | /     test!(test_missing_prerequisite_fails_validation, {
200 | |         let mut state = LifecycleState::default();
201 | |         // Deploy without test should fail (critical safety check)
202 | |         state.record_run("deploy".to_string(), 0, 100, true);
203 | |
204 | |         assert!(ValidatedLifecycleState::validate(&state).is_err());
205 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), LifecycleError>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), lifecycle::error::LifecycleError>` because of return type
    |
    = note: expected enum `std::result::Result<_, lifecycle::error::LifecycleError>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lifecycle/state_validation.rs:207:5
    |
207 | /     test!(test_invalid_cache_key_fails_validation, {
208 | |         let mut state = LifecycleState::default();
209 | |         state.record_run("init".to_string(), 0, 100, true);
210 | |         state.add_cache_key("nonexistent".to_string(), "key".to_string());
211 | |
212 | |         assert!(ValidatedLifecycleState::validate(&state).is_err());
213 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), LifecycleError>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), lifecycle::error::LifecycleError>` because of return type
    |
    = note: expected enum `std::result::Result<_, lifecycle::error::LifecycleError>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lifecycle/state_validation.rs:215:5
    |
215 | /     test!(test_inconsistent_history_allowed_for_hooks, {
216 | |         // Hooks can run phases out of order, so this should be allowed
217 | |         let mut state = LifecycleState::default();
218 | |         state.record_run("build".to_string(), 0, 100, true);
...   |
222 | |         assert!(ValidatedLifecycleState::validate(&state).is_ok());
223 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), LifecycleError>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), lifecycle::error::LifecycleError>` because of return type
    |
    = note: expected enum `std::result::Result<_, lifecycle::error::LifecycleError>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lifecycle/state_validation.rs:225:5
    |
225 | /     test!(test_validated_state_wrapper, {
226 | |         let mut state = LifecycleState::default();
227 | |         state.record_run("init".to_string(), 0, 100, true);
...   |
230 | |         assert!(validated.state().has_completed_phase("init"));
231 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), LifecycleError>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), lifecycle::error::LifecycleError>` because of return type
    |
    = note: expected enum `std::result::Result<_, lifecycle::error::LifecycleError>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lifecycle/production.rs:934:5
    |
934 | /     test!(test_default_requirements, {
935 | |         let requirements = ReadinessTracker::default_requirements();
...   |
964 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), ProductionError>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ProductionError>` because of return type
    |
    = note: expected enum `std::result::Result<_, ProductionError>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lifecycle/production.rs:966:5
    |
966 | /     test!(test_readiness_report_generation, {
967 | |         let mut tracker = ReadinessTracker::new("/tmp/test");
968 | |         tracker.load().unwrap(); // Load default requirements
969 | |         let report = tracker.generate_report();
...   |
983 | |         );
984 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), ProductionError>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ProductionError>` because of return type
    |
    = note: expected enum `std::result::Result<_, ProductionError>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
    --> crates/ggen-core/src/lifecycle/production.rs:986:5
     |
 986 | /     test!(test_status_transitions, {
 987 | |         let mut tracker = ReadinessTracker::new("/tmp/test");
 988 | |         tracker.load().unwrap();
...    |
1001 | |             .is_err());
1002 | |     });
     | |      ^
     | |      |
     | |______expected `Result<(), ProductionError>`, found `Result<(), Box<dyn Error>>`
     |        expected `std::result::Result<(), ProductionError>` because of return type
     |
     = note: expected enum `std::result::Result<_, ProductionError>`
                found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
     = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lifecycle/optimization.rs:435:5
    |
435 | /     test!(test_performance_targets, {
436 | |         let targets = PerformanceTargets::default();
437 | |         assert_eq!(targets.total, Duration::from_secs(45));
...   |
443 | |         assert_eq!(stretch.total, Duration::from_secs(45));
444 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), LifecycleError>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), lifecycle::error::LifecycleError>` because of return type
    |
    = note: expected enum `std::result::Result<_, lifecycle::error::LifecycleError>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lifecycle/optimization.rs:446:5
    |
446 | /     test!(test_stage_metrics, {
447 | |         let metric = StageMetrics::new("test", Duration::from_secs(5), Duration::from_secs(10));
448 | |         assert!(metric.met_target);
449 | |         assert!(metric.improvement_percent() > 0.0);
...   |
454 | |         assert!(metric_exceeded.improvement_percent() < 0.0);
455 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), LifecycleError>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), lifecycle::error::LifecycleError>` because of return type
    |
    = note: expected enum `std::result::Result<_, lifecycle::error::LifecycleError>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lifecycle/optimization.rs:493:5
    |
493 | /     test!(test_improvement_calculation, {
494 | |         let metric = StageMetrics::new("test", Duration::from_secs(3), Duration::from_secs(5));
495 | |         assert!((metric.improvement_percent() - 40.0).abs() < 0.01);
...   |
498 | |         assert!((metric_over.improvement_percent() + 40.0).abs() < 0.01);
499 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), LifecycleError>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), lifecycle::error::LifecycleError>` because of return type
    |
    = note: expected enum `std::result::Result<_, lifecycle::error::LifecycleError>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lifecycle/dag.rs:101:5
    |
101 | /     test!(test_topo_simple, {
102 | |         let phases = &["init", "setup", "build"];
103 | |         let deps = &[("init", "setup"), ("setup", "build")];
...   |
107 | |         assert_eq!(order, vec!["init", "setup", "build"]);
108 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), LifecycleError>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), lifecycle::error::LifecycleError>` because of return type
    |
    = note: expected enum `std::result::Result<_, lifecycle::error::LifecycleError>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lifecycle/dag.rs:110:5
    |
110 | /     test!(test_topo_parallel, {
111 | |         let phases = &["test", "lint", "build"];
112 | |         let deps = &[("test", "build"), ("lint", "build")];
...   |
117 | |         assert_eq!(order.last(), Some(&"build".to_string()));
118 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), LifecycleError>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), lifecycle::error::LifecycleError>` because of return type
    |
    = note: expected enum `std::result::Result<_, lifecycle::error::LifecycleError>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lifecycle/dag.rs:120:5
    |
120 | /     test!(test_topo_cycle_detection, {
121 | |         let phases = &["a", "b", "c"];
122 | |         let deps = &[("a", "b"), ("b", "c"), ("c", "a")]; // cycle: a->b->c->a
...   |
129 | |             .contains("Circular dependency"));
130 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), LifecycleError>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), lifecycle::error::LifecycleError>` because of return type
    |
    = note: expected enum `std::result::Result<_, lifecycle::error::LifecycleError>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lifecycle/dag.rs:132:5
    |
132 | /     test!(test_deps_from_hooks, {
133 | |         let deps = deps_from_hooks("build", &["test".to_string()], &["deploy".to_string()]);
134 | |
135 | |         assert_eq!(deps.len(), 2);
136 | |         assert!(deps.contains(&("test".to_string(), "build".to_string())));
137 | |         assert!(deps.contains(&("build".to_string(), "deploy".to_string())));
138 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), LifecycleError>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), lifecycle::error::LifecycleError>` because of return type
    |
    = note: expected enum `std::result::Result<_, lifecycle::error::LifecycleError>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lockfile.rs:401:5
    |
401 | /     test!(test_lockfile_manager_creation, {
402 | |         let temp_dir = TempDir::new().unwrap();
403 | |         let manager = LockfileManager::new(temp_dir.path());
...   |
406 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lockfile.rs:408:5
    |
408 | /     test!(test_lockfile_create_and_save, {
409 | |         let temp_dir = TempDir::new().unwrap();
410 | |         let manager = LockfileManager::new(temp_dir.path());
...   |
415 | |         assert!(manager.lockfile_path().exists());
416 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lockfile.rs:418:5
    |
418 | /     test!(test_lockfile_load_nonexistent, {
419 | |         let temp_dir = TempDir::new().unwrap();
420 | |         let manager = LockfileManager::new(temp_dir.path());
...   |
423 | |         assert!(loaded.is_none());
424 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lockfile.rs:426:5
    |
426 | /     test!(test_lockfile_upsert_and_get, {
427 | |         let temp_dir = TempDir::new().unwrap();
428 | |         let manager = LockfileManager::new(temp_dir.path());
...   |
442 | |         assert!(entry.pqc_pubkey.is_none());
443 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lockfile.rs:445:5
    |
445 | /     test!(test_lockfile_upsert_with_pqc, {
446 | |         let temp_dir = TempDir::new().unwrap();
447 | |         let manager = LockfileManager::new(temp_dir.path());
...   |
465 | |         assert_eq!(entry.pqc_pubkey, Some("pqc_pubkey_base64".to_string()));
466 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lockfile.rs:468:5
    |
468 | /     test!(test_lockfile_remove, {
469 | |         let temp_dir = TempDir::new().unwrap();
470 | |         let manager = LockfileManager::new(temp_dir.path());
...   |
481 | |         assert!(!manager.is_installed("io.ggen.test").unwrap());
482 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/lockfile.rs:484:5
    |
484 | /     test!(test_lockfile_stats, {
485 | |         let temp_dir = TempDir::new().unwrap();
486 | |         let manager = LockfileManager::new(temp_dir.path());
...   |
502 | |         assert_eq!(stats.version, Some("1.0".to_string()));
503 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/merge.rs:736:5
    |
736 | /     test!(test_merge_strategies, {
737 | |         let merger = ThreeWayMerger::new(MergeStrategy::GeneratedWins);
738 | |
739 | |         let baseline = "line 1\nline 2\n";
...   |
749 | |         assert_eq!(result.content, generated);
750 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/merge.rs:752:5
    |
752 | /     test!(test_region_aware_merge, {
753 | |         let merger = RegionAwareMerger::new(MergeStrategy::ManualWins);
754 | |
755 | |         let baseline = "line 1\n// GENERATED: DO NOT EDIT\nline 2\n// END GENERATED\nline 3\n";
...   |
789 | |         assert_eq!(result.strategy, MergeStrategy::ManualWins);
790 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/merge.rs:792:5
    |
792 | /     test!(test_region_parsing, {
793 | |         let content = r#"
794 | | line 1
...   |
816 | |         assert_eq!(manual[0].end, 10);
817 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/merge.rs:819:5
    |
819 | /     test!(test_region_check, {
820 | |         let regions = vec![
821 | |             Region {
822 | |                 start: 2,
...   |
844 | |         ));
845 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0277]: the trait bound `sigma_runtime::SnapshotMetadata: std::default::Default` is not satisfied
   --> crates/ggen-core/src/ontology/constitution.rs:318:13
    |
318 |             Default::default(),
    |             ^^^^^^^^^^^^^^^^^^ the trait `std::default::Default` is not implemented for `sigma_runtime::SnapshotMetadata`
    |
help: consider annotating `sigma_runtime::SnapshotMetadata` with `#[derive(Default)]`
   --> crates/ggen-core/src/ontology/sigma_runtime.rs:124:1
    |
124 + #[derive(Default)]
125 | pub struct SnapshotMetadata {
    |

error[E0277]: the trait bound `sigma_runtime::SnapshotMetadata: std::default::Default` is not satisfied
   --> crates/ggen-core/src/ontology/control_loop.rs:338:13
    |
338 |             Default::default(),
    |             ^^^^^^^^^^^^^^^^^^ the trait `std::default::Default` is not implemented for `sigma_runtime::SnapshotMetadata`
    |
help: consider annotating `sigma_runtime::SnapshotMetadata` with `#[derive(Default)]`
   --> crates/ggen-core/src/ontology/sigma_runtime.rs:124:1
    |
124 + #[derive(Default)]
125 | pub struct SnapshotMetadata {
    |

error[E0277]: the trait bound `sigma_runtime::SnapshotMetadata: std::default::Default` is not satisfied
   --> crates/ggen-core/src/ontology/delta_proposer.rs:433:13
    |
433 |             Default::default(),
    |             ^^^^^^^^^^^^^^^^^^ the trait `std::default::Default` is not implemented for `sigma_runtime::SnapshotMetadata`
    |
help: consider annotating `sigma_runtime::SnapshotMetadata` with `#[derive(Default)]`
   --> crates/ggen-core/src/ontology/sigma_runtime.rs:124:1
    |
124 + #[derive(Default)]
125 | pub struct SnapshotMetadata {
    |

error[E0277]: the trait bound `sigma_runtime::SnapshotMetadata: std::default::Default` is not satisfied
   --> crates/ggen-core/src/ontology/delta_proposer.rs:459:13
    |
459 |             Default::default(),
    |             ^^^^^^^^^^^^^^^^^^ the trait `std::default::Default` is not implemented for `sigma_runtime::SnapshotMetadata`
    |
help: consider annotating `sigma_runtime::SnapshotMetadata` with `#[derive(Default)]`
   --> crates/ggen-core/src/ontology/sigma_runtime.rs:124:1
    |
124 + #[derive(Default)]
125 | pub struct SnapshotMetadata {
    |

error[E0277]: the trait bound `sigma_runtime::SnapshotMetadata: std::default::Default` is not satisfied
   --> crates/ggen-core/src/ontology/delta_proposer.rs:490:13
    |
490 |             Default::default(),
    |             ^^^^^^^^^^^^^^^^^^ the trait `std::default::Default` is not implemented for `sigma_runtime::SnapshotMetadata`
    |
help: consider annotating `sigma_runtime::SnapshotMetadata` with `#[derive(Default)]`
   --> crates/ggen-core/src/ontology/sigma_runtime.rs:124:1
    |
124 + #[derive(Default)]
125 | pub struct SnapshotMetadata {
    |

error[E0277]: the trait bound `sigma_runtime::SnapshotMetadata: std::default::Default` is not satisfied
   --> crates/ggen-core/src/ontology/e2e_example.rs:156:13
    |
156 |             Default::default(),
    |             ^^^^^^^^^^^^^^^^^^ the trait `std::default::Default` is not implemented for `sigma_runtime::SnapshotMetadata`
    |
help: consider annotating `sigma_runtime::SnapshotMetadata` with `#[derive(Default)]`
   --> crates/ggen-core/src/ontology/sigma_runtime.rs:124:1
    |
124 + #[derive(Default)]
125 | pub struct SnapshotMetadata {
    |

error[E0277]: the trait bound `sigma_runtime::SnapshotMetadata: std::default::Default` is not satisfied
   --> crates/ggen-core/src/ontology/e2e_example.rs:186:13
    |
186 |             Default::default(),
    |             ^^^^^^^^^^^^^^^^^^ the trait `std::default::Default` is not implemented for `sigma_runtime::SnapshotMetadata`
    |
help: consider annotating `sigma_runtime::SnapshotMetadata` with `#[derive(Default)]`
   --> crates/ggen-core/src/ontology/sigma_runtime.rs:124:1
    |
124 + #[derive(Default)]
125 | pub struct SnapshotMetadata {
    |

error[E0277]: the trait bound `sigma_runtime::SnapshotMetadata: std::default::Default` is not satisfied
   --> crates/ggen-core/src/ontology/e2e_example.rs:199:17
    |
199 |                 Default::default(),
    |                 ^^^^^^^^^^^^^^^^^^ the trait `std::default::Default` is not implemented for `sigma_runtime::SnapshotMetadata`
    |
help: consider annotating `sigma_runtime::SnapshotMetadata` with `#[derive(Default)]`
   --> crates/ggen-core/src/ontology/sigma_runtime.rs:124:1
    |
124 + #[derive(Default)]
125 | pub struct SnapshotMetadata {
    |

error[E0277]: the trait bound `sigma_runtime::SnapshotMetadata: std::default::Default` is not satisfied
   --> crates/ggen-core/src/ontology/e2e_example.rs:250:13
    |
250 |             Default::default(),
    |             ^^^^^^^^^^^^^^^^^^ the trait `std::default::Default` is not implemented for `sigma_runtime::SnapshotMetadata`
    |
help: consider annotating `sigma_runtime::SnapshotMetadata` with `#[derive(Default)]`
   --> crates/ggen-core/src/ontology/sigma_runtime.rs:124:1
    |
124 + #[derive(Default)]
125 | pub struct SnapshotMetadata {
    |

error[E0277]: the trait bound `sigma_runtime::SnapshotMetadata: std::default::Default` is not satisfied
   --> crates/ggen-core/src/ontology/promotion.rs:191:13
    |
191 |             Default::default(),
    |             ^^^^^^^^^^^^^^^^^^ the trait `std::default::Default` is not implemented for `sigma_runtime::SnapshotMetadata`
    |
help: consider annotating `sigma_runtime::SnapshotMetadata` with `#[derive(Default)]`
   --> crates/ggen-core/src/ontology/sigma_runtime.rs:124:1
    |
124 + #[derive(Default)]
125 | pub struct SnapshotMetadata {
    |

error[E0277]: the trait bound `sigma_runtime::SnapshotMetadata: std::default::Default` is not satisfied
   --> crates/ggen-core/src/ontology/validators.rs:394:13
    |
394 |             Default::default(),
    |             ^^^^^^^^^^^^^^^^^^ the trait `std::default::Default` is not implemented for `sigma_runtime::SnapshotMetadata`
    |
help: consider annotating `sigma_runtime::SnapshotMetadata` with `#[derive(Default)]`
   --> crates/ggen-core/src/ontology/sigma_runtime.rs:124:1
    |
124 + #[derive(Default)]
125 | pub struct SnapshotMetadata {
    |

error[E0308]: mismatched types
   --> crates/ggen-core/src/pipeline.rs:767:5
    |
767 | /     test!(test_pipeline_new, {
768 | |         let pipeline = Pipeline::new()?;
769 | |         assert!(!pipeline.graph.is_empty() || pipeline.graph.is_empty()); // Just verify it exists
770 | |         Ok(())
771 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/pipeline.rs:774:5
    |
774 | /     test!(test_pipeline_render_body, {
775 | |         let mut pipeline = Pipeline::new()?;
776 | |         let mut ctx = Context::new();
777 | |         ctx.insert("name", "World");
...   |
781 | |         Ok(())
782 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/pipeline.rs:785:5
    |
785 | /     test!(test_pipeline_render_file_basic, {
786 | |         let temp_dir = TempDir::new()?;
787 | |         let template_content = r#"---
788 | | to: "output.txt"
...   |
802 | |         Ok(())
803 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/pipeline.rs:806:5
    |
806 | /     test!(test_plan_apply_dry_run, {
807 | |         let temp_dir = TempDir::new()?;
808 | |         let output_path = temp_dir.path().join("output.txt");
...   |
822 | |         Ok(())
823 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/pipeline.rs:826:5
    |
826 | /     test!(test_plan_apply_creates_file, {
827 | |         let temp_dir = TempDir::new()?;
828 | |         let output_path = temp_dir.path().join("output.txt");
...   |
844 | |         Ok(())
845 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/pipeline.rs:848:5
    |
848 | /     test!(test_plan_unless_exists, {
849 | |         let temp_dir = TempDir::new()?;
850 | |         let output_path = temp_dir.path().join("output.txt");
...   |
871 | |         Ok(())
872 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/pipeline.rs:875:5
    |
875 | /     test!(test_pipeline_builder_with_prefixes, {
876 | |         let mut prefixes = BTreeMap::new();
877 | |         prefixes.insert("ex".to_string(), "http://example.org/".to_string());
...   |
885 | |         Ok(())
886 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/pipeline.rs:889:5
    |
889 | /     test!(test_pipeline_register_prefixes, {
890 | |         let mut pipeline = Pipeline::new()?;
891 | |         let mut prefixes = BTreeMap::new();
892 | |         prefixes.insert("ex".to_string(), "http://example.org/".to_string());
...   |
900 | |         Ok(())
901 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/poc.rs:349:5
    |
349 | /     test!(poc_with_prefixes_and_inline_rdf, {
350 | |         let dir = tempfile::tempdir().unwrap();
351 | |         let root = dir.path();
...   |
378 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/pqc.rs:201:5
    |
201 | /     test!(test_pqc_signer_creation, {
202 | |         let signer = PqcSigner::new();
203 | |         assert!(!signer.public_key_base64().is_empty());
204 | |         assert!(!signer.secret_key_base64().is_empty());
205 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/pqc.rs:207:5
    |
207 | /     test!(test_pqc_sign_and_verify, {
208 | |         let signer = PqcSigner::new();
209 | |         let message = b"test message";
...   |
216 | |         assert!(verified);
217 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/pqc.rs:219:5
    |
219 | /     test!(test_pqc_pack_signature, {
220 | |         let signer = PqcSigner::new();
221 | |         let pack_id = "io.ggen.test";
222 | |         let version = "1.0.0";
...   |
232 | |         assert!(verified);
233 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/pqc.rs:235:5
    |
235 | /     test!(test_pqc_invalid_signature, {
236 | |         let signer = PqcSigner::new();
237 | |         let verifier = PqcVerifier::from_public_key(signer.public_key.as_bytes()).unwrap();
...   |
245 | |         assert!(!verified);
246 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/pqc.rs:248:5
    |
248 | /     test!(test_sha256_calculation, {
249 | |         let data = b"test data";
250 | |         let hash = calculate_sha256(data);
...   |
255 | |         );
256 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/preprocessor.rs:457:5
    |
457 | /     test!(test_freeze_stage_basic, {
458 | |         let temp_dir = TempDir::new()?;
459 | |         let stage = FreezeStage {
460 | |             slots_dir: temp_dir.path().to_path_buf(),
...   |
477 | |         Ok(())
478 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/preprocessor.rs:480:5
    |
480 | /     test!(test_include_stage_basic, {
481 | |         let temp_dir = TempDir::new()?;
482 | |         let include_file = temp_dir.path().join("included.tmpl");
483 | |         fs::write(&include_file, "Included content")?;
...   |
499 | |         Ok(())
500 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/preprocessor.rs:502:5
    |
502 | /     test!(test_preprocessor_pipeline, {
503 | |         let temp_dir = TempDir::new()?;
504 | |         let include_file = temp_dir.path().join("included.tmpl");
505 | |         fs::write(&include_file, "Included")?;
...   |
531 | |         Ok(())
532 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/resolver.rs:503:5
    |
503 | /     test!(test_parse_template_ref, {
504 | |         let temp_dir = TempDir::new().unwrap();
505 | |         let cache_manager = CacheManager::with_dir(temp_dir.path().join("cache")).unwrap();
506 | |         let lockfile_manager = LockfileManager::new(temp_dir.path());
...   |
513 | |         assert_eq!(template_path, "main.tmpl");
514 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/resolver.rs:516:5
    |
516 | /     test!(test_parse_template_ref_invalid, {
517 | |         let temp_dir = TempDir::new().unwrap();
518 | |         let cache_manager = CacheManager::with_dir(temp_dir.path().join("cache")).unwrap();
519 | |         let lockfile_manager = LockfileManager::new(temp_dir.path());
...   |
529 | |         assert!(resolver.parse_template_ref("pack:").is_err());
530 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/resolver.rs:532:5
    |
532 | /     test!(test_resolve_template_path, {
533 | |         let temp_dir = TempDir::new().unwrap();
534 | |         let pack_dir = temp_dir.path().join("pack");
535 | |         let templates_dir = pack_dir.join("templates");
...   |
553 | |         assert_eq!(resolved_path, templates_dir.join("main.tmpl"));
554 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/resolver.rs:556:5
    |
556 | /     test!(test_resolve_template_path_security, {
557 | |         let temp_dir = TempDir::new().unwrap();
558 | |         let pack_dir = temp_dir.path().join("pack");
559 | |         let cached_pack = CachedPack {
...   |
574 | |             .is_err());
575 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/resolver.rs:577:5
    |
577 | /     test!(test_template_resolver_new, {
578 | |         let temp_dir = TempDir::new().unwrap();
579 | |         let cache_manager = CacheManager::with_dir(temp_dir.path().join("cache")).unwrap();
580 | |         let lockfile_manager = LockfileManager::new(temp_dir.path());
...   |
585 | |         assert!(resolver.cache_manager.cache_dir().exists());
586 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/resolver.rs:588:5
    |
588 | /     test!(test_resolve_template_path_nested, {
589 | |         let temp_dir = TempDir::new().unwrap();
590 | |         let pack_dir = temp_dir.path().join("pack");
591 | |         let templates_dir = pack_dir.join("templates");
...   |
609 | |         assert_eq!(resolved_path, templates_dir.join("nested").join("sub.tmpl"));
610 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/resolver.rs:612:5
    |
612 | /     test!(test_resolve_template_path_empty_components, {
613 | |         let temp_dir = TempDir::new().unwrap();
614 | |         let pack_dir = temp_dir.path().join("pack");
615 | |         let templates_dir = pack_dir.join("templates");
...   |
634 | |         assert_eq!(resolved_path, templates_dir.join("a").join("b"));
635 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/resolver.rs:637:5
    |
637 | /     test!(test_parse_frontmatter_basic, {
638 | |         let temp_dir = TempDir::new().unwrap();
639 | |         let cache_manager = CacheManager::with_dir(temp_dir.path().join("cache")).unwrap();
640 | |         let lockfile_manager = LockfileManager::new(temp_dir.path());
...   |
654 | |         assert!(template_content.contains("Hello {{ name }}"));
655 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/resolver.rs:657:5
    |
657 | /     test!(test_parse_frontmatter_no_frontmatter, {
658 | |         let temp_dir = TempDir::new().unwrap();
659 | |         let cache_manager = CacheManager::with_dir(temp_dir.path().join("cache")).unwrap();
660 | |         let lockfile_manager = LockfileManager::new(temp_dir.path());
...   |
668 | |         assert_eq!(template_content, "Hello World");
669 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/resolver.rs:671:5
    |
671 | /     test!(test_find_templates_in_pack_with_manifest, {
672 | |         let temp_dir = TempDir::new().unwrap();
673 | |         let pack_dir = temp_dir.path().join("pack");
674 | |         let templates_dir = pack_dir.join("templates");
...   |
726 | |         assert!(templates.iter().any(|t| t.ends_with("sub.tmpl")));
727 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/resolver.rs:729:5
    |
729 | /     test!(test_find_templates_in_pack_without_manifest, {
730 | |         let temp_dir = TempDir::new().unwrap();
731 | |         let pack_dir = temp_dir.path().join("pack");
732 | |         let templates_dir = pack_dir.join("templates");
...   |
755 | |         assert!(templates.iter().any(|t| t.ends_with("sub.tmpl")));
756 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/resolver.rs:758:5
    |
758 | /     test!(test_search_templates_empty, {
759 | |         let temp_dir = TempDir::new().unwrap();
760 | |         let cache_manager = CacheManager::with_dir(temp_dir.path().join("cache")).unwrap();
761 | |         let lockfile_manager = LockfileManager::new(temp_dir.path());
...   |
765 | |         assert!(results.is_empty());
766 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/resolver.rs:768:5
    |
768 | /     test!(test_get_pack_templates_nonexistent_pack, {
769 | |         let temp_dir = TempDir::new().unwrap();
770 | |         let cache_manager = CacheManager::with_dir(temp_dir.path().join("cache")).unwrap();
771 | |         let lockfile_manager = LockfileManager::new(temp_dir.path());
...   |
775 | |         assert!(resolver.get_pack_templates("nonexistent.pack").is_err());
776 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/snapshot.rs:600:5
    |
600 | /     test!(test_snapshot_creation, {
601 | |         let graph = Graph::new().unwrap();
602 | |         graph
603 | |             .insert_turtle("@prefix : <http://example.org/> . :test a :Class .")
...   |
623 | |         assert!(!snapshot.graph.hash.is_empty());
624 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/snapshot.rs:626:5
    |
626 | /     test!(test_snapshot_manager, {
627 | |         let temp_dir = tempdir().unwrap();
628 | |         let manager = SnapshotManager::new(temp_dir.path().to_path_buf()).unwrap();
...   |
651 | |         assert!(!manager.exists("manager_test"));
652 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/snapshot.rs:654:5
    |
654 | /     test!(test_file_snapshot, {
655 | |         let temp_dir = tempdir().unwrap();
656 | |         let file_path = temp_dir.path().join("test.txt");
657 | |         fs::write(&file_path, "test content").unwrap();
...   |
667 | |         assert!(snapshot.has_changed("different content"));
668 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/snapshot.rs:670:5
    |
670 | /     test!(test_template_snapshot, {
671 | |         let temp_dir = tempdir().unwrap();
672 | |         let template_path = temp_dir.path().join("test.tmpl");
...   |
681 | |         assert!(!snapshot.hash.is_empty());
682 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/streaming_generator.rs:406:5
    |
406 | /     test!(test_streaming_generator_new, {
407 | |         let temp_dir = TempDir::new()?;
408 | |         let output_dir = TempDir::new()?;
...   |
418 | |         Ok(())
419 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/streaming_generator.rs:421:5
    |
421 | /     test!(test_streaming_generator_single_file, {
422 | |         let temp_dir = TempDir::new()?;
423 | |         let output_dir = TempDir::new()?;
...   |
455 | |         Ok(())
456 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/streaming_generator.rs:458:5
    |
458 | /     test!(test_streaming_generator_multiple_files, {
459 | |         let temp_dir = TempDir::new()?;
460 | |         let output_dir = TempDir::new()?;
...   |
490 | |         Ok(())
491 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/streaming_generator.rs:493:5
    |
493 | /     test!(test_streaming_generator_nested_output, {
494 | |         let temp_dir = TempDir::new()?;
495 | |         let output_dir = TempDir::new()?;
...   |
522 | |         Ok(())
523 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/streaming_generator.rs:525:5
    |
525 | /     test!(test_streaming_generator_cache_reuse, {
526 | |         let temp_dir = TempDir::new()?;
527 | |         let output_dir = TempDir::new()?;
...   |
556 | |         Ok(())
557 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/telemetry.rs:178:5
    |
178 | /     test!(test_telemetry_config_default, {
179 | |         let config = TelemetryConfig::default();
180 | |         assert_eq!(config.service_name, "ggen");
181 | |         assert_eq!(config.sample_ratio, 1.0);
182 | |         assert!(config.console_output);
183 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/telemetry.rs:185:5
    |
185 | /     test!(test_telemetry_config_custom, {
186 | |         let config = TelemetryConfig {
187 | |             endpoint: "http://custom:4318".to_string(),
188 | |             service_name: "test-service".to_string(),
...   |
195 | |         assert!(!config.console_output);
196 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/template.rs:566:5
    |
566 | /     test!(parse_variants_and_preserve_body, {
567 | |         let cases = [
...   |
594 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/template.rs:596:5
    |
596 | /     test!(frontmatter_render_core_fields, {
597 | |         let input = r#"---
598 | | to: "{{name}}.rs"
599 | | prefixes: { ex: "http://example.org/" }
...   |
620 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/template.rs:622:5
    |
622 | /     test!(deserializers_string_or_seq_and_sparql_map, {
623 | |         let fm1: Frontmatter = serde_yaml::from_str(r#"rdf_inline: "a""#).unwrap();
624 | |         let fm2: Frontmatter = serde_yaml::from_str(r#"rdf_inline: ["a","b"]"#).unwrap();
625 | |         assert_eq!(fm1.rdf_inline, vec!["a"]);
...   |
636 | |         assert!(fm5.sparql.contains_key("query_0"));
637 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/template.rs:639:5
    |
639 | /     test!(boolean_and_injection_flags, {
640 | |         let fm: Frontmatter = serde_yaml::from_str(
641 | |             r#"
642 | | force: true
...   |
665 | |         assert_eq!(fm.sh_after.as_deref(), Some("echo post"));
666 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/template.rs:670:5
    |
670 | /     test!(body_render_inline_and_from_file, {
671 | |         // inline
672 | |         let inline = r#"---
673 | | to: "x"
...   |
694 | |         assert_contains!(got2, "Hello, Bob!");
695 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/template.rs:699:5
    |
699 | /     test!(rdf_insert_and_select_visible, {
700 | |         let input = r#"---
701 | | prefixes: { ex: "http://example.org/" }
702 | | rdf_inline:
...   |
710 | |         assert_contains!(out, "Count: 1");
711 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/template.rs:713:5
    |
713 | /     test!(boolean_ask_and_empty_result_helpers, {
714 | |         let input = r#"---
715 | | prefixes: { ex: "http://example.org/" }
716 | | rdf_inline:
...   |
729 | |         assert_contains!(out, "Count: 0");
730 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/template.rs:732:5
    |
732 | /     test!(projection_helpers_and_multiple_queries, {
733 | |         let input = r#"---
734 | | prefixes: { ex: "http://example.org/" }
735 | | rdf_inline:
...   |
750 | |         assert_contains!(out, "Ages:");
751 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/template.rs:753:5
    |
753 | /     test!(preprocessor_integration, {
754 | |         use std::path::Path;
755 | |         use tempfile::TempDir;
...   |
793 | |         assert!(!template.body.contains("endfreeze"));
794 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/template_cache.rs:239:5
    |
239 | /     test!(test_template_cache_new, {
240 | |         let cache = TemplateCache::new(50);
241 | |         let stats = cache.stats().unwrap();
242 | |         assert_eq!(stats.capacity, 50);
243 | |         assert_eq!(stats.size, 0);
244 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/template_cache.rs:246:5
    |
246 | /     test!(test_template_cache_default, {
247 | |         let cache = TemplateCache::default();
248 | |         let stats = cache.stats().unwrap();
249 | |         assert_eq!(stats.capacity, 100);
250 | |         assert_eq!(stats.size, 0);
251 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/template_cache.rs:253:5
    |
253 | /     test!(test_get_or_parse, {
254 | |         let cache = TemplateCache::new(10);
255 | |
256 | |         let mut temp = NamedTempFile::new()?;
...   |
276 | |         Ok(())
277 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/template_cache.rs:279:5
    |
279 | /     test!(test_cache_clear, {
280 | |         let cache = TemplateCache::new(10);
281 | |
282 | |         let mut temp = NamedTempFile::new()?;
...   |
297 | |         Ok(())
298 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/template_cache.rs:300:5
    |
300 | /     test!(test_cache_eviction, {
301 | |         let cache = TemplateCache::new(2);
...   |
321 | |         Ok(())
322 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/templates/context.rs:577:5
    |
577 | /     test!(test_new_context, {
578 | |         let ctx = TemplateContext::new();
579 | |         assert!(ctx.variables.is_empty());
580 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/templates/context.rs:582:5
    |
582 | /     test!(test_set_and_get, {
583 | |         let mut ctx = TemplateContext::new();
584 | |         ctx.set("name", "test").unwrap();
...   |
587 | |         assert!(ctx.contains("name"));
588 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/templates/context.rs:590:5
    |
590 | /     test!(test_from_map, {
591 | |         let mut vars = BTreeMap::new();
592 | |         vars.insert("service_name".to_string(), "my-service".to_string());
593 | |         vars.insert("port".to_string(), "8080".to_string());
...   |
601 | |         assert_eq!(ctx.get_string("port"), Some("8080".to_string()));
602 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/templates/context.rs:604:5
    |
604 | /     test!(test_merge, {
605 | |         let mut ctx1 = TemplateContext::new();
606 | |         ctx1.set("name", "test1").unwrap();
...   |
614 | |         assert_eq!(ctx1.get_string("port"), Some("8080".to_string()));
615 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/templates/context.rs:617:5
    |
617 | /     test!(test_validate_required, {
618 | |         let mut ctx = TemplateContext::new();
619 | |         ctx.set("name", "test").unwrap();
...   |
625 | |         assert!(result.unwrap_err().to_string().contains("port"));
626 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/templates/context.rs:628:5
    |
628 | /     test!(test_apply_defaults, {
629 | |         let mut ctx = TemplateContext::new();
630 | |         ctx.set("name", "test").unwrap();
...   |
641 | |         assert_eq!(ctx.get_string("port"), Some("8080".to_string()));
642 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/templates/context.rs:644:5
    |
644 | /     test!(test_render_string, {
645 | |         let mut ctx = TemplateContext::new();
646 | |         ctx.set("name", "World").unwrap();
647 | |         ctx.set("count", 42).unwrap();
...   |
652 | |         assert_eq!(rendered, "Hello, World! Count: 42");
653 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/templates/context.rs:655:5
    |
655 | /     test!(test_variable_names, {
656 | |         let mut ctx = TemplateContext::new();
657 | |         ctx.set("name", "test").unwrap();
658 | |         ctx.set("port", "8080").unwrap();
...   |
663 | |         assert!(names.contains(&"port"));
664 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/templates/file_tree_generator.rs:670:5
    |
670 | /     test!(test_create_template, {
671 | |         let format = TemplateFormat::new("test-template");
672 | |         let template = FileTreeTemplate::new(format);
...   |
675 | |         assert!(template.description().is_none());
676 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/templates/file_tree_generator.rs:678:5
    |
678 | /     test!(test_parse_yaml_template, {
679 | |         let yaml = r#"
680 | | name: test-template
681 | | description: A test template
...   |
702 | |         assert_eq!(template.nodes().len(), 1);
703 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/templates/file_tree_generator.rs:705:5
    |
705 | /     test!(test_parse_template_with_rdf, {
706 | |         let yaml = r#"
707 | | name: microservice-template
708 | | rdf:
...   |
722 | |         assert!(template.rdf_turtle.is_some());
723 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/templates/file_tree_generator.rs:725:5
    |
725 | /     test!(test_template_validation, {
726 | |         let format = TemplateFormat::new("test");
727 | |         let template = FileTreeTemplate::new(format);
...   |
730 | |         assert!(template.validate().is_err());
731 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/templates/file_tree_generator.rs:733:5
    |
733 | /     test!(test_parser_extract_name, {
734 | |         let line = r#"[directory: "src"]"#;
735 | |         let name = TemplateParser::extract_name(line).unwrap();
736 | |         assert_eq!(name, "src");
737 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/templates/file_tree_generator.rs:739:5
    |
739 | /     test!(test_parse_simple_format, {
740 | |         let content = r#"
741 | | [directory: "src"]
742 | | [file: "main.rs"]
...   |
746 | |         assert_eq!(template.nodes().len(), 2);
747 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/templates/format.rs:669:5
    |
669 | /     test!(test_directory_node, {
670 | |         let node = FileTreeNode::directory("src");
671 | |         assert_eq!(node.node_type, NodeType::Directory);
672 | |         assert_eq!(node.name, "src");
673 | |         assert!(node.children.is_empty());
674 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/templates/format.rs:676:5
    |
676 | /     test!(test_file_node_with_content, {
677 | |         let node = FileTreeNode::file_with_content("main.rs", "fn main() {}");
678 | |         assert_eq!(node.node_type, NodeType::File);
679 | |         assert_eq!(node.name, "main.rs");
680 | |         assert_eq!(node.content, Some("fn main() {}".to_string()));
681 | |         assert_eq!(node.template, None);
682 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/templates/format.rs:684:5
    |
684 | /     test!(test_file_node_with_template, {
685 | |         let node = FileTreeNode::file_with_template("lib.rs", "templates/lib.rs.tera");
686 | |         assert_eq!(node.node_type, NodeType::File);
687 | |         assert_eq!(node.name, "lib.rs");
688 | |         assert_eq!(node.template, Some("templates/lib.rs.tera".to_string()));
689 | |         assert_eq!(node.content, None);
690 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/templates/format.rs:692:5
    |
692 | /     test!(test_template_format_creation, {
693 | |         let mut format = TemplateFormat::new("test-template");
694 | |         format.add_variable("service_name");
695 | |         format.add_default("port", "8080");
...   |
699 | |         assert_eq!(format.defaults.get("port"), Some(&"8080".to_string()));
700 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/templates/format.rs:702:5
    |
702 | /     test!(test_template_format_validation, {
703 | |         let mut format = TemplateFormat::new("test");
704 | |         format.add_node(FileTreeNode::directory("src"));
...   |
707 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/templates/format.rs:709:5
    |
709 | /     test!(test_empty_template_validation_fails, {
710 | |         let format = TemplateFormat::new("test");
711 | |         assert!(format.validate().is_err());
712 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/templates/frozen.rs:493:5
    |
493 | /     test!(test_parse_simple_frozen_section, {
494 | |         let content = r#"
495 | | Before frozen
496 | | {% frozen %}
...   |
505 | |         assert_eq!(sections[0].id, None);
506 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/templates/frozen.rs:508:5
    |
508 | /     test!(test_parse_frozen_section_with_id, {
509 | |         let content = r#"
510 | | {% frozen id="custom_logic" %}
511 | | my implementation
...   |
518 | |         assert_eq!(sections[0].id, Some("custom_logic".to_string()));
519 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/templates/frozen.rs:521:5
    |
521 | /     test!(test_parse_multiple_frozen_sections, {
522 | |         let content = r#"
523 | | {% frozen id="section1" %}
524 | | code 1
...   |
537 | |         assert_eq!(sections[1].id, Some("section2".to_string()));
538 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/templates/frozen.rs:540:5
    |
540 | /     test!(test_parse_unclosed_frozen_tag, {
541 | |         let content = r#"
542 | | {% frozen %}
543 | | unclosed section
...   |
547 | |         assert!(result.is_err());
548 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/templates/frozen.rs:550:5
    |
550 | /     test!(test_extract_frozen_map, {
551 | |         let content = r#"
552 | | {% frozen id="logic" %}
553 | | preserved code
...   |
559 | |         assert!(map.get("logic").unwrap().contains("preserved code"));
560 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/templates/frozen.rs:563:5
    |
563 | /     test!(test_merge_with_frozen, {
564 | |         let old_content = r#"
565 | | {% frozen id="custom" %}
566 | | old user code
...   |
578 | |         assert!(!merged.contains("new generated code"));
579 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/templates/frozen.rs:581:5
    |
581 | /     test!(test_merge_without_frozen_sections, {
582 | |         let old_content = "no frozen sections";
583 | |         let new_content = "new content";
...   |
586 | |         assert_eq!(merged, "new content");
587 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/templates/frozen.rs:589:5
    |
589 | /     test!(test_has_frozen_sections, {
590 | |         assert!(FrozenMerger::has_frozen_sections(
591 | |             "{% frozen %}code{% endfrozen %}"
592 | |         ));
593 | |         assert!(!FrozenMerger::has_frozen_sections("no frozen sections"));
594 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/templates/frozen.rs:596:5
    |
596 | /     test!(test_strip_frozen_tags, {
597 | |         let content = r#"
598 | | Before
599 | | {% frozen id="test" %}
...   |
608 | |         assert!(stripped.contains("keep this content"));
609 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/templates/frozen.rs:612:5
    |
612 | /     test!(test_merge_numbered_sections, {
613 | |         let old_content = r#"
614 | | {% frozen %}
615 | | first section
...   |
635 | |         assert!(!merged.contains("new second"));
636 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/tera_env.rs:99:5
    |
 99 | /     test!(test_build_tera_with_glob, {
100 | |         let temp_dir = TempDir::new()?;
101 | |         let templates_dir = temp_dir.path().join("templates");
102 | |         fs::create_dir_all(&templates_dir)?;
...   |
116 | |         Ok(())
117 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/tera_env.rs:119:5
    |
119 | /     test!(test_build_tera_empty_directory, {
120 | |         let temp_dir = TempDir::new()?;
121 | |         let templates_dir = temp_dir.path().join("templates");
122 | |         fs::create_dir_all(&templates_dir)?;
...   |
133 | |         Ok(())
134 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/tera_env.rs:136:5
    |
136 | /     test!(test_build_tera_minimal, {
137 | |         let mut tera = build_tera_minimal()?;
...   |
144 | |         Ok(())
145 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error[E0308]: mismatched types
   --> crates/ggen-core/src/tera_env.rs:147:5
    |
147 | /     test!(test_autoescape_disabled, {
148 | |         let mut tera = build_tera_minimal()?;
...   |
155 | |         Ok(())
156 | |     });
    | |      ^
    | |      |
    | |______expected `Result<(), Error>`, found `Result<(), Box<dyn Error>>`
    |        expected `std::result::Result<(), ggen_utils::Error>` because of return type
    |
    = note: expected enum `std::result::Result<_, ggen_utils::Error>`
               found enum `std::result::Result<_, Box<(dyn StdError + 'static)>>`
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)

error: variable does not need to be mutable
   --> crates/ggen-core/src/ontology/sigma_runtime.rs:550:13
    |
550 |         let mut receipt = SigmaReceipt::new(snap.id.clone(), None, "Change".to_string());
    |             ----^^^^^^^
    |             |
    |             help: remove this `mut`
    |
    = note: `#[deny(unused_mut)]` implied by `#[deny(warnings)]`

error[E0382]: use of moved value: `receipt`
   --> crates/ggen-core/src/ontology/sigma_runtime.rs:553:32
    |
550 |         let mut receipt = SigmaReceipt::new(snap.id.clone(), None, "Change".to_string());
    |             ----------- move occurs because `receipt` has type `sigma_runtime::SigmaReceipt`, which does not implement the `Copy` trait
551 |         receipt.mark_valid();
    |                 ------------ `receipt` moved due to this method call
552 |
553 |         runtime.record_receipt(receipt);
    |                                ^^^^^^^ value used here after move
    |
note: `sigma_runtime::SigmaReceipt::mark_valid` takes ownership of the receiver `self`, which moves `receipt`
   --> crates/ggen-core/src/ontology/sigma_runtime.rs:343:27
    |
343 |     pub fn mark_valid(mut self) -> Self {
    |                           ^^^^
help: you can `clone` the value and consume it, but this might not be your desired behavior
    |
551 |         receipt.clone().mark_valid();
    |                ++++++++

Some errors have detailed explanations: E0107, E0277, E0308, E0382, E0433.
For more information about an error, try `rustc --explain E0107`.
error: could not compile `ggen-core` (lib test) due to 620 previous errors