@layerzerolabs/protocol-stellar-v2 0.2.21 → 0.2.23

package/contracts/common-macros/src/tests/contract_ttl.rs

@@ -1,7 +1,7 @@
 use proc_macro2::TokenStream;
 use quote::quote;
 
-use crate::tests::test_helpers::assert_panics_contains;
+use crate::tests::test_helpers::{assert_panics_contains, filter_item_inputs_excluding_labels};
 
 // ============================================================================
 // Snapshot Tests
@@ -19,6 +19,10 @@ fn snapshot_generated_contractimpl_code() {
     let empty_attr = TokenStream::new();
     let inherent_input = quote! {
         impl MyContract {
+            // Non-fn items should be preserved by the macro
+            const A_CONST: u32 = 1;
+            type Alias = u32;
+
             /// Public method with Env - should have TTL extension
             pub fn public_with_env(env: Env, value: u32) -> u32 {
                 value * 2
@@ -121,6 +125,10 @@ fn snapshot_generated_contracttrait_code() {
     let empty_attr = TokenStream::new();
     let trait_input = quote! {
         pub trait MyTrait: Sized {
+            // Non-fn items should be preserved by the macro
+            const A_CONST: u32;
+            type Alias;
+
             /// Default method with Env - should have TTL extension
             fn default_with_env(env: Env, value: u32) -> u32 {
                 value * 2
@@ -183,175 +191,107 @@ fn snapshot_generated_contracttrait_code() {
 // ============================================================================
 
 #[test]
-fn test_contractimpl_non_impl_block_input() {
-    let invalid_inputs = vec![
-        (
-            "struct",
-            quote! {
-                struct MyStruct {
-                    field: u32,
-                }
-            },
-        ),
+fn test_contractimpl_with_ttl_rejects_non_impl_block_input() {
+    for (case, input) in filter_item_inputs_excluding_labels(&["impl block"]) {
+        assert_panics_contains(case, "failed to parse impl block", || {
+            crate::contract_ttl::contractimpl_with_ttl(TokenStream::new(), input.clone());
+        });
+    }
+}
+
+#[test]
+fn test_contracttrait_with_ttl_rejects_non_trait_input() {
+    for (case, input) in filter_item_inputs_excluding_labels(&["trait"]) {
+        assert_panics_contains(case, "failed to parse trait definition", || {
+            crate::contract_ttl::contracttrait_with_ttl(TokenStream::new(), input.clone());
+        });
+    }
+}
+
+// ============================================================================
+// Unit Tests: Attribute Handling
+// ============================================================================
+
+#[test]
+fn test_contractimpl_with_ttl_adds_contractimpl_attribute_table_driven() {
+    // (name, attr, input, expected_substrings, forbidden_substrings)
+    let cases: Vec<(&str, TokenStream, TokenStream, Vec<&str>, Vec<&str>)> = vec![
         (
-            "enum",
+            "empty attr",
+            TokenStream::new(),
             quote! {
-                enum MyEnum {
-                    Variant1,
-                    Variant2,
+                impl MyContract {
+                    pub fn my_method(env: Env) {}
                 }
             },
+            vec!["# [soroban_sdk :: contractimpl]"],
+            // ensure we don't emit `#[...::contractimpl(...)]` when attr is empty
+            vec!["contractimpl(", "contractimpl ("],
         ),
-        ("function", quote! { fn a_function() {} }),
-        ("const item", quote! { const A_CONST: u32 = 1; }),
-        ("type alias", quote! { type AnAlias = u32; }),
         (
-            "trait",
+            "with attr",
+            quote! { contracttrait },
             quote! {
-                trait ATrait {
-                    fn method(&self);
+                impl SomeTrait for MyContract {
+                    fn my_method(env: Env) {}
                 }
             },
+            vec!["contractimpl (contracttrait)"],
+            vec![],
         ),
     ];
 
-    for (case, input) in invalid_inputs {
-        assert_panics_contains(case, "failed to parse impl block", || {
-            crate::contract_ttl::contractimpl_with_ttl(TokenStream::new(), input.clone());
-        });
+    for (name, attr, input, expected, forbidden) in cases {
+        let result = crate::contract_ttl::contractimpl_with_ttl(attr, input);
+        let result_str = result.to_string();
+        for needle in expected {
+            assert!(result_str.contains(needle), "{name}: expected '{needle}'. Got: {result_str}");
+        }
+        for needle in forbidden {
+            assert!(!result_str.contains(needle), "{name}: should NOT contain '{needle}'. Got: {result_str}");
+        }
     }
 }
 
 #[test]
-fn test_contracttrait_non_trait_input() {
-    let invalid_inputs = vec![
-        (
-            "struct",
-            quote! {
-                struct MyStruct {
-                    field: u32,
-                }
-            },
-        ),
+fn test_contracttrait_with_ttl_adds_contracttrait_attribute_table_driven() {
+    // (name, attr, input, expected_substrings, forbidden_substrings)
+    let cases: Vec<(&str, TokenStream, TokenStream, Vec<&str>, Vec<&str>)> = vec![
         (
-            "enum",
+            "empty attr",
+            TokenStream::new(),
             quote! {
-                enum MyEnum {
-                    Variant1,
-                    Variant2,
+                pub trait MyTrait {
+                    fn my_method(env: Env) {}
                 }
             },
+            vec!["# [soroban_sdk :: contracttrait]"],
+            // ensure we don't emit `#[...::contracttrait(...)]` when attr is empty
+            vec!["contracttrait(", "contracttrait ("],
         ),
-        ("function", quote! { fn a_function() {} }),
-        ("const item", quote! { const A_CONST: u32 = 1; }),
-        ("type alias", quote! { type AnAlias = u32; }),
         (
-            "impl block",
+            "with attr",
+            quote! { crate = "my_crate" },
             quote! {
-                impl MyContract {
-                    fn method(&self) {}
+                pub trait MyTrait {
+                    fn my_method(env: Env) {}
                 }
             },
+            vec!["contracttrait (crate = \"my_crate\")"],
+            vec![],
         ),
     ];
 
-    for (case, input) in invalid_inputs {
-        assert_panics_contains(case, "failed to parse trait definition", || {
-            crate::contract_ttl::contracttrait_with_ttl(TokenStream::new(), input.clone());
-        });
-    }
-}
-
-// ============================================================================
-// Unit Tests: Attribute Handling
-// ============================================================================
-
-/// Verifies that contractimpl_with_ttl adds #[soroban_sdk::contractimpl] without parentheses when attr is empty
-#[test]
-fn test_contractimpl_adds_attribute_without_attr() {
-    let input = quote! {
-        impl MyContract {
-            pub fn my_method(env: Env) {}
-        }
-    };
-
-    let result = crate::contract_ttl::contractimpl_with_ttl(TokenStream::new(), input);
-    let result_str = result.to_string();
-
-    assert!(
-        result_str.contains("# [soroban_sdk :: contractimpl]"),
-        "should add #[soroban_sdk::contractimpl] attribute without parentheses when attr is empty. Got: {}",
-        result_str
-    );
-    assert!(
-        !result_str.contains("contractimpl ()"),
-        "should NOT have empty parentheses when attr is empty. Got: {}",
-        result_str
-    );
-}
-
-/// Verifies that contractimpl_with_ttl adds #[soroban_sdk::contractimpl(attr)] when attr is provided
-#[test]
-fn test_contractimpl_adds_attribute_with_attr() {
-    let input = quote! {
-        impl SomeTrait for MyContract {
-            fn my_method(env: Env) {}
+    for (name, attr, input, expected, forbidden) in cases {
+        let result = crate::contract_ttl::contracttrait_with_ttl(attr, input);
+        let result_str = result.to_string();
+        for needle in expected {
+            assert!(result_str.contains(needle), "{name}: expected '{needle}'. Got: {result_str}");
         }
-    };
-
-    let attr = quote! { contracttrait };
-    let result = crate::contract_ttl::contractimpl_with_ttl(attr, input);
-    let result_str = result.to_string();
-
-    assert!(
-        result_str.contains("contractimpl (contracttrait)"),
-        "should add #[soroban_sdk::contractimpl(contracttrait)] attribute. Got: {}",
-        result_str
-    );
-}
-
-/// Verifies that contracttrait_with_ttl adds #[soroban_sdk::contracttrait] without parentheses when attr is empty
-#[test]
-fn test_contracttrait_adds_attribute_without_attr() {
-    let input = quote! {
-        pub trait MyTrait {
-            fn my_method(env: Env) {}
+        for needle in forbidden {
+            assert!(!result_str.contains(needle), "{name}: should NOT contain '{needle}'. Got: {result_str}");
         }
-    };
-
-    let result = crate::contract_ttl::contracttrait_with_ttl(TokenStream::new(), input);
-    let result_str = result.to_string();
-
-    assert!(
-        result_str.contains("# [soroban_sdk :: contracttrait]"),
-        "should add #[soroban_sdk::contracttrait] attribute without parentheses when attr is empty. Got: {}",
-        result_str
-    );
-    assert!(
-        !result_str.contains("contracttrait ()"),
-        "should NOT have empty parentheses when attr is empty. Got: {}",
-        result_str
-    );
-}
-
-/// Verifies that contracttrait_with_ttl adds #[soroban_sdk::contracttrait(attr)] when attr is provided
-#[test]
-fn test_contracttrait_adds_attribute_with_attr() {
-    let input = quote! {
-        pub trait MyTrait {
-            fn my_method(env: Env) {}
-        }
-    };
-
-    let attr = quote! { crate = "my_crate" };
-    let result = crate::contract_ttl::contracttrait_with_ttl(attr, input);
-    let result_str = result.to_string();
-
-    assert!(
-        result_str.contains("contracttrait (crate = \"my_crate\")"),
-        "should add #[soroban_sdk::contracttrait(crate = \"my_crate\")] attribute. Got: {}",
-        result_str
-    );
+    }
 }
 
 // ============================================================================
@@ -363,10 +303,9 @@ fn test_contracttrait_adds_attribute_with_attr() {
 enum TtlExpectation {
     /// TTL extension should NOT be inserted
     None,
-    /// TTL extension should be inserted with the given env patterns
-    /// - `instance_arg`: pattern in `TtlConfigStorage::instance(...)` (e.g., "& env" for owned, "env" for ref)
-    /// - `storage_ident`: identifier for `.storage()` call
-    Present { instance_arg: &'static str, storage_ident: &'static str },
+    /// TTL extension should be inserted with the given env argument
+    /// - `env_arg`: pattern in `extend_instance_ttl(...)` (e.g., "& env" for owned, "env" for ref)
+    Present { env_arg: &'static str },
 }
 
 /// Test runner for contractimpl_with_ttl TTL behavior
@@ -377,13 +316,8 @@ struct ImplTtlTestCase {
 }
 
 impl ImplTtlTestCase {
-    fn expect_ttl(
-        name: &'static str,
-        input: TokenStream,
-        instance_arg: &'static str,
-        storage_ident: &'static str,
-    ) -> Self {
-        Self { name, input, expectation: TtlExpectation::Present { instance_arg, storage_ident } }
+    fn expect_ttl(name: &'static str, input: TokenStream, env_arg: &'static str) -> Self {
+        Self { name, input, expectation: TtlExpectation::Present { env_arg } }
     }
 
     fn expect_no_ttl(name: &'static str, input: TokenStream) -> Self {
@@ -405,13 +339,8 @@ struct TraitTtlTestCase {
 }
 
 impl TraitTtlTestCase {
-    fn expect_ttl(
-        name: &'static str,
-        input: TokenStream,
-        instance_arg: &'static str,
-        storage_ident: &'static str,
-    ) -> Self {
-        Self { name, input, expectation: TtlExpectation::Present { instance_arg, storage_ident } }
+    fn expect_ttl(name: &'static str, input: TokenStream, env_arg: &'static str) -> Self {
+        Self { name, input, expectation: TtlExpectation::Present { env_arg } }
     }
 
     fn expect_no_ttl(name: &'static str, input: TokenStream) -> Self {
@@ -426,27 +355,23 @@ impl TraitTtlTestCase {
 }
 
 fn assert_ttl_expectation(expectation: &TtlExpectation, result_str: &str, name: &str) {
-    let has_ttl = result_str.contains("TtlConfigStorage :: instance");
+    let has_ttl = result_str.contains("extend_instance_ttl");
 
     match expectation {
         TtlExpectation::None => {
             assert!(!has_ttl, "{}: TTL extension should NOT be present, but was found", name);
         }
-        TtlExpectation::Present { instance_arg, storage_ident } => {
+        TtlExpectation::Present { env_arg } => {
             assert!(has_ttl, "{}: TTL extension should be present, but was not found", name);
-            assert!(result_str.contains("extend_ttl"), "{}: should insert extend_ttl call", name);
 
-            let instance_pattern = format!("TtlConfigStorage :: instance ({})", instance_arg);
+            let extend_pattern = format!("extend_instance_ttl ({})", env_arg);
             assert!(
-                result_str.contains(&instance_pattern),
-                "{}: expected '{}' in TtlConfigStorage::instance call. Got: {}",
+                result_str.contains(&extend_pattern),
+                "{}: expected '{}' in extend_instance_ttl call. Got: {}",
                 name,
-                instance_arg,
+                env_arg,
                 result_str
             );
-
-            let storage_pattern = format!("{} . storage ()", storage_ident);
-            assert!(result_str.contains(&storage_pattern), "{}: expected '{}.storage()' call", name, storage_ident);
         }
     }
 }
@@ -456,119 +381,168 @@ fn assert_ttl_expectation(expectation: &TtlExpectation, result_str: &str, name:
 // ============================================================================
 
 #[test]
-fn test_impl_ttl_extension_with_owned_env() {
-    ImplTtlTestCase::expect_ttl(
-        "public method with owned Env",
-        quote! {
-            impl MyContract {
-                pub fn my_method(env: Env) { let x = 1; }
-            }
-        },
-        "& env", // instance takes reference
-        "env",   // storage called on ident
-    )
-    .run();
-}
-
-#[test]
-fn test_impl_ttl_extension_with_ref_env() {
-    ImplTtlTestCase::expect_ttl(
-        "public method with ref Env",
-        quote! {
-            impl MyContract {
-                pub fn my_method(env: &Env) { let x = 1; }
-            }
-        },
-        "env", // instance takes ident directly (already a ref)
-        "env",
-    )
-    .run();
-}
-
-#[test]
-fn test_impl_ttl_extension_with_custom_env_ident_owned() {
-    ImplTtlTestCase::expect_ttl(
-        "custom Env identifier (owned)",
-        quote! {
-            impl MyContract {
-                pub fn my_method(my_custom_env: Env) { let x = 1; }
-            }
-        },
-        "& my_custom_env",
-        "my_custom_env",
-    )
-    .run();
-}
-
-#[test]
-fn test_impl_ttl_extension_with_custom_env_ident_ref() {
-    ImplTtlTestCase::expect_ttl(
-        "custom Env identifier (ref)",
-        quote! {
-            impl MyContract {
-                pub fn my_method(my_custom_env: &Env) { let x = 1; }
-            }
-        },
-        "my_custom_env",
-        "my_custom_env",
-    )
-    .run();
-}
-
-#[test]
-fn test_impl_ttl_extension_for_trait_impl_owned_env() {
-    ImplTtlTestCase::expect_ttl(
-        "trait impl method with owned Env",
-        quote! {
-            impl SomeTrait for MyContract {
-                fn trait_method(env: Env) { let x = 1; }
-            }
-        },
-        "& env",
-        "env",
-    )
-    .run();
-}
+fn test_contractimpl_with_ttl_inserts_ttl_for_methods_with_env_table_driven() {
+    // contractimpl_with_ttl: TTL should be inserted for methods with Env
+    // - inherent impl: only `pub` methods are eligible
+    // - trait impl: all methods are eligible
+    //
+    // (name, input, env_arg)
+    let test_data = vec![
+        (
+            "public method with owned Env",
+            quote! {
+                impl MyContract {
+                    pub fn my_method(env: Env) { let x = 1; }
+                }
+            },
+            "& env",
+        ),
+        (
+            "public method with ref Env",
+            quote! {
+                impl MyContract {
+                    pub fn my_method(env: &Env) { let x = 1; }
+                }
+            },
+            "env",
+        ),
+        (
+            "public method with mut ref Env",
+            quote! {
+                impl MyContract {
+                    pub fn my_method(env: &mut Env) { let x = 1; }
+                }
+            },
+            "env",
+        ),
+        (
+            "custom Env identifier (owned)",
+            quote! {
+                impl MyContract {
+                    pub fn my_method(my_custom_env: Env) { let x = 1; }
+                }
+            },
+            "& my_custom_env",
+        ),
+        (
+            "custom Env identifier (ref)",
+            quote! {
+                impl MyContract {
+                    pub fn my_method(my_custom_env: &Env) { let x = 1; }
+                }
+            },
+            "my_custom_env",
+        ),
+        (
+            "public method with receiver and Env",
+            quote! {
+                impl MyContract {
+                    pub fn my_method(&self, env: &Env) { let x = 1; }
+                }
+            },
+            "env",
+        ),
+        (
+            "public method with mut Env binding (owned)",
+            quote! {
+                impl MyContract {
+                    pub fn my_method(mut env: Env) { let x = 1; }
+                }
+            },
+            "& env",
+        ),
+        (
+            "public method with ::soroban_sdk::Env (owned)",
+            quote! {
+                impl MyContract {
+                    pub fn my_method(env: ::soroban_sdk::Env) { let x = 1; }
+                }
+            },
+            "& env",
+        ),
+        (
+            "public method with &::soroban_sdk::Env (ref)",
+            quote! {
+                impl MyContract {
+                    pub fn my_method(env: &::soroban_sdk::Env) { let x = 1; }
+                }
+            },
+            "env",
+        ),
+        (
+            "trait impl method with owned Env",
+            quote! {
+                impl SomeTrait for MyContract {
+                    fn trait_method(env: Env) { let x = 1; }
+                }
+            },
+            "& env",
+        ),
+        (
+            "trait impl method with ref Env",
+            quote! {
+                impl SomeTrait for MyContract {
+                    fn trait_method(env: &Env) { let x = 1; }
+                }
+            },
+            "env",
+        ),
+    ];
 
-#[test]
-fn test_impl_ttl_extension_for_trait_impl_ref_env() {
-    ImplTtlTestCase::expect_ttl(
-        "trait impl method with ref Env",
-        quote! {
-            impl SomeTrait for MyContract {
-                fn trait_method(env: &Env) { let x = 1; }
-            }
-        },
-        "env",
-        "env",
-    )
-    .run();
+    for (name, input, env_arg) in test_data {
+        ImplTtlTestCase::expect_ttl(name, input, env_arg).run();
+    }
 }
 
 #[test]
-fn test_impl_no_ttl_extension_for_private_method() {
-    ImplTtlTestCase::expect_no_ttl(
-        "private method with Env",
-        quote! {
-            impl MyContract {
-                fn private_method(env: Env) { let x = 1; }
-            }
-        },
-    )
-    .run();
-}
+fn test_contractimpl_with_ttl_skips_ttl_insertion_table_driven() {
+    // (name, input)
+    let cases = vec![
+        (
+            "private method with Env",
+            quote! {
+                impl MyContract {
+                    fn private_method(env: Env) { let x = 1; }
+                }
+            },
+        ),
+        (
+            "public method without Env",
+            quote! {
+                impl MyContract {
+                    pub fn no_env_method(value: u32) -> u32 { value }
+                }
+            },
+        ),
+        (
+            "public method with wildcard Env binding (unsupported pattern)",
+            quote! {
+                impl MyContract {
+                    pub fn my_method(_: Env) { let x = 1; }
+                }
+            },
+        ),
+        (
+            "pub(super) method with Env (not fully public)",
+            quote! {
+                impl MyContract {
+                    pub(super) fn my_method(env: Env) { let x = 1; }
+                }
+            },
+        ),
+        (
+            "pub(in ...) method with Env (not fully public)",
+            quote! {
+                impl MyContract {
+                    pub(in crate::some_module) fn my_method(env: Env) { let x = 1; }
+                }
+            },
+        ),
+    ];
 
-#[test]
-fn test_impl_no_ttl_extension_without_env_param() {
-    ImplTtlTestCase::expect_no_ttl(
-        "public method without Env",
-        quote! {
-            impl MyContract {
-                pub fn no_env_method(value: u32) -> u32 { value }
-            }
-        },
-    )
-    .run();
+    for (name, input) in cases {
+        ImplTtlTestCase::expect_no_ttl(name, input).run();
+    }
 }
 
 // ============================================================================
@@ -576,87 +550,146 @@ fn test_impl_no_ttl_extension_without_env_param() {
 // ============================================================================
 
 #[test]
-fn test_trait_ttl_extension_with_owned_env() {
-    TraitTtlTestCase::expect_ttl(
-        "default method with owned Env",
-        quote! {
-            trait MyTrait {
-                fn my_method(env: Env) { let x = 1; }
-            }
-        },
-        "& env", // instance takes reference
-        "env",   // storage called on ident
-    )
-    .run();
-}
+fn test_contracttrait_with_ttl_inserts_ttl_for_default_methods_with_env_table_driven() {
+    // (name, input, env_arg)
+    let test_data = vec![
+        (
+            "default method with owned Env",
+            quote! {
+                trait MyTrait {
+                    fn my_method(env: Env) { let x = 1; }
+                }
+            },
+            "& env",
+        ),
+        (
+            "default method with ref Env",
+            quote! {
+                trait MyTrait {
+                    fn my_method(env: &Env) { let x = 1; }
+                }
+            },
+            "env",
+        ),
+        (
+            "default method with mut ref Env",
+            quote! {
+                trait MyTrait {
+                    fn my_method(env: &mut Env) { let x = 1; }
+                }
+            },
+            "env",
+        ),
+        (
+            "custom Env identifier (owned)",
+            quote! {
+                trait MyTrait {
+                    fn my_method(my_custom_env: Env) { let x = 1; }
+                }
+            },
+            "& my_custom_env",
+        ),
+        (
+            "custom Env identifier (ref)",
+            quote! {
+                trait MyTrait {
+                    fn my_method(my_custom_env: &Env) { let x = 1; }
+                }
+            },
+            "my_custom_env",
+        ),
+        (
+            "default method with receiver and Env",
+            quote! {
+                trait MyTrait {
+                    fn my_method(&self, env: &Env) { let x = 1; }
+                }
+            },
+            "env",
+        ),
+    ];
 
-#[test]
-fn test_trait_ttl_extension_with_ref_env() {
-    TraitTtlTestCase::expect_ttl(
-        "default method with ref Env",
-        quote! {
-            trait MyTrait {
-                fn my_method(env: &Env) { let x = 1; }
-            }
-        },
-        "env", // instance takes ident directly (already a ref)
-        "env",
-    )
-    .run();
+    for (name, input, env_arg) in test_data {
+        TraitTtlTestCase::expect_ttl(name, input, env_arg).run();
+    }
 }
 
-#[test]
-fn test_trait_ttl_extension_with_custom_env_ident_owned() {
-    TraitTtlTestCase::expect_ttl(
-        "custom Env identifier (owned)",
-        quote! {
-            trait MyTrait {
-                fn my_method(my_custom_env: Env) { let x = 1; }
-            }
-        },
-        "& my_custom_env",
-        "my_custom_env",
-    )
-    .run();
-}
+// ============================================================================
+// Constructor behavior: contractimpl_with_ttl
+// ============================================================================
 
 #[test]
-fn test_trait_ttl_extension_with_custom_env_ident_ref() {
-    TraitTtlTestCase::expect_ttl(
-        "custom Env identifier (ref)",
-        quote! {
-            trait MyTrait {
-                fn my_method(my_custom_env: &Env) { let x = 1; }
-            }
-        },
-        "my_custom_env",
-        "my_custom_env",
-    )
-    .run();
-}
+fn test_contractimpl_with_ttl_injects_init_default_ttl_configs_only_in_constructor() {
+    // `__constructor` should get default TTL config init, and should NOT get TTL extension.
+    let cases: Vec<(&str, TokenStream, Vec<&str>, Vec<&str>)> = vec![
+        (
+            "constructor with owned Env",
+            quote! {
+                impl MyContract {
+                    pub fn __constructor(env: Env) { let x = 1; }
+                }
+            },
+            // expects init call and correct arg form (`&env` because Env is owned)
+            vec!["ttl_configurable :: init_default_ttl_configs (& env)"],
+            // should not insert TTL extension
+            vec!["TtlConfigStorage :: instance", "extend_ttl"],
+        ),
+        (
+            "constructor with ref Env",
+            quote! {
+                impl MyContract {
+                    pub fn __constructor(env: &Env) { let x = 1; }
+                }
+            },
+            // expects init call and correct arg form (`env` because Env is already a ref)
+            vec!["ttl_configurable :: init_default_ttl_configs (env)"],
+            vec!["TtlConfigStorage :: instance", "extend_ttl"],
+        ),
+    ];
 
-#[test]
-fn test_trait_no_ttl_extension_for_abstract_method() {
-    TraitTtlTestCase::expect_no_ttl(
-        "abstract method with Env (no body)",
-        quote! {
-            trait MyTrait {
-                fn abstract_method(env: Env) -> u32;
-            }
-        },
-    )
-    .run();
+    for (name, input, expected, forbidden) in cases {
+        let result = crate::contract_ttl::contractimpl_with_ttl(TokenStream::new(), input);
+        let result_str = result.to_string();
+        for needle in expected {
+            assert!(result_str.contains(needle), "{name}: expected '{needle}'. Got: {result_str}");
+        }
+        for needle in forbidden {
+            assert!(!result_str.contains(needle), "{name}: should NOT contain '{needle}'. Got: {result_str}");
+        }
+    }
 }
 
 #[test]
-fn test_trait_no_ttl_extension_without_env_param() {
-    TraitTtlTestCase::expect_no_ttl(
-        "default method without Env",
-        quote! {
-            trait MyTrait {
-                fn no_env_method(value: u32) -> u32 { value }
-            }
-        },
-    )
-    .run();
+fn test_contracttrait_with_ttl_skips_ttl_insertion_table_driven() {
+    // (name, input)
+    let cases = vec![
+        (
+            "abstract method with Env (no body)",
+            quote! {
+                trait MyTrait {
+                    fn abstract_method(env: Env) -> u32;
+                }
+            },
+        ),
+        (
+            "default method without Env",
+            quote! {
+                trait MyTrait {
+                    fn no_env_method(value: u32) -> u32 { value }
+                }
+            },
+        ),
+        (
+            "default method with wildcard Env binding (unsupported pattern)",
+            quote! {
+                trait MyTrait {
+                    fn my_method(_: Env) { let x = 1; }
+                }
+            },
+        ),
+    ];
+
+    for (name, input) in cases {
+        TraitTtlTestCase::expect_no_ttl(name, input).run();
+    }
 }