Repository: CosmWasm/sylvia
Pull request #312 (2024-02-27 13:08:13)

chore: Remove tarpaulin exclusions


Patch:
diff --git a/examples/contracts/cw1-subkeys/src/error.rs b/examples/contracts/cw1-subkeys/src/error.rs
index 39b1959..f3baaa4 100644
--- a/examples/contracts/cw1-subkeys/src/error.rs
+++ b/examples/contracts/cw1-subkeys/src/error.rs
@@ -24,7 +24,6 @@ pub enum ContractError {
     SettingExpiredAllowance(Expiration),
 }
 
-#[cfg(not(tarpaulin_include))]
 impl From<WhitelistError> for ContractError {
     fn from(err: WhitelistError) -> Self {
         match err {
diff --git a/examples/contracts/cw1-subkeys/src/whitelist.rs b/examples/contracts/cw1-subkeys/src/whitelist.rs
index 3c96592..9fa62d8 100644
--- a/examples/contracts/cw1-subkeys/src/whitelist.rs
+++ b/examples/contracts/cw1-subkeys/src/whitelist.rs
@@ -7,8 +7,6 @@ use whitelist::Whitelist;
 use crate::contract::Cw1SubkeysContract;
 use crate::error::ContractError;
 
-// This can be skipped by tarpaulin as it's covered in cw1-whitelist
-#[cfg(not(tarpaulin_include))]
 #[contract(module=crate::contract)]
 #[sv::messages(whitelist as Whitelist)]
 impl Whitelist for Cw1SubkeysContract<'_> {
diff --git a/sylvia-derive/src/input.rs b/sylvia-derive/src/input.rs
index 6a2b2fb..55bb910 100644
--- a/sylvia-derive/src/input.rs
+++ b/sylvia-derive/src/input.rs
@@ -38,7 +38,6 @@ pub struct ImplInput<'a> {
 }
 
 impl<'a> TraitInput<'a> {
-    #[cfg(not(tarpaulin_include))]
     pub fn new(item: &'a ItemTrait) -> Self {
         if !item.generics.params.is_empty() {
             emit_error!(
@@ -87,19 +86,16 @@ impl<'a> TraitInput<'a> {
 
         let interface_messages = InterfaceApi::new(item, associated_types, custom).emit();
 
-        #[cfg(not(tarpaulin_include))]
-        {
-            quote! {
-                pub mod sv {
-                    use super::*;
-                    #messages
+        quote! {
+            pub mod sv {
+                use super::*;
+                #messages
 
-                    #remote
+                #remote
 
-                    #querier
+                #querier
 
-                    #interface_messages
-                }
+                #interface_messages
             }
         }
     }
@@ -109,15 +105,12 @@ impl<'a> TraitInput<'a> {
         let query = self.emit_msg(MsgType::Query);
         let sudo = self.emit_msg(MsgType::Sudo);
 
-        #[cfg(not(tarpaulin_include))]
-        {
-            quote! {
-                #exec
+        quote! {
+            #exec
 
-                #query
+            #query
 
-                #sudo
-            }
+            #sudo
         }
     }
 
@@ -177,7 +170,6 @@ impl<'a> ImplInput<'a> {
         let multitest_helpers = self.emit_multitest_helpers();
         let querier = self.emit_querier_for_bound_impl();
 
-        #[cfg(not(tarpaulin_include))]
         quote! {
             pub mod sv {
                 use super::*;
@@ -204,22 +196,19 @@ impl<'a> ImplInput<'a> {
         let remote = ContractRemote::new(item, interfaces).emit();
         let contract_api = ContractApi::new(item, generics, custom, interfaces).emit();
 
-        #[cfg(not(tarpaulin_include))]
-        {
-            quote! {
-                pub mod sv {
-                    use super::*;
+        quote! {
+            pub mod sv {
+                use super::*;
 
-                    #messages
+                #messages
 
-                    #multitest_helpers
+                #multitest_helpers
 
-                    #remote
+                #remote
 
-                    #querier
+                #querier
 
-                    #contract_api
-                }
+                #contract_api
             }
         }
     }
@@ -234,25 +223,22 @@ impl<'a> ImplInput<'a> {
         let query = self.emit_glue_msg(MsgType::Query);
         let sudo = self.emit_glue_msg(MsgType::Sudo);
 
-        #[cfg(not(tarpaulin_include))]
-        {
-            quote! {
-                #instantiate
+        quote! {
+            #instantiate
 
-                #exec_impl
+            #exec_impl
 
-                #query_impl
+            #query_impl
 
-                #sudo_impl
+            #sudo_impl
 
-                #migrate
+            #migrate
 
-                #exec
+            #exec
 
-                #query
+            #query
 
-                #sudo
-            }
+            #sudo
         }
     }
 
diff --git a/sylvia-derive/src/lib.rs b/sylvia-derive/src/lib.rs
index 25a5a95..59e1be7 100644
--- a/sylvia-derive/src/lib.rs
+++ b/sylvia-derive/src/lib.rs
@@ -137,7 +137,6 @@ pub(crate) fn crate_module() -> Path {
 ///
 /// For now `#[sv::msg(...)]` attribute doesn't support anymore data on `#[interface]`
 /// elements, but it may be extended in future.
-#[cfg(not(tarpaulin_include))]
 #[proc_macro_error]
 #[proc_macro_attribute]
 pub fn interface(attr: TokenStream, item: TokenStream) -> TokenStream {
@@ -228,7 +227,6 @@ fn interface_impl(_attr: TokenStream2, item: TokenStream2) -> TokenStream2 {
 ///     #[sv::msg(query, resp=MemberQueryResponse)]
 ///     fn member(&self, ctx: (Deps, Env), addr: String, at_height: Option<u64>) -> Result<MemberQueryResponse, Error>
 /// ```
-#[cfg(not(tarpaulin_include))]
 #[proc_macro_error]
 #[proc_macro_attribute]
 pub fn contract(attr: TokenStream, item: TokenStream) -> TokenStream {
@@ -253,14 +251,12 @@ fn contract_impl(attr: TokenStream2, item: TokenStream2) -> TokenStream2 {
     inner(attr, item).unwrap_or_else(syn::Error::into_compile_error)
 }
 
-#[cfg(not(tarpaulin_include))]
 #[proc_macro_error]
 #[proc_macro_attribute]
 pub fn entry_points(attr: TokenStream, item: TokenStream) -> TokenStream {
     entry_points_impl(attr.into(), item.into()).into()
 }
 
-#[cfg(not(tarpaulin_include))]
 fn entry_points_impl(attr: TokenStream2, item: TokenStream2) -> TokenStream2 {
     fn inner(attr: TokenStream2, item: TokenStream2) -> syn::Result<TokenStream2> {
         let attrs: parser::EntryPointArgs = parse2(attr)?;
diff --git a/sylvia-derive/src/message.rs b/sylvia-derive/src/message.rs
index 43e69ac..2209037 100644
--- a/sylvia-derive/src/message.rs
+++ b/sylvia-derive/src/message.rs
@@ -153,27 +153,24 @@ impl<'a> StructMessage<'a> {
         let generics = emit_bracketed_generics(generics);
         let unused_generics = emit_bracketed_generics(unused_generics);
 
-        #[cfg(not(tarpaulin_include))]
-        {
-            quote! {
-                #[allow(clippy::derive_partial_eq_without_eq)]
-                #[derive(#sylvia ::serde::Serialize, #sylvia ::serde::Deserialize, Clone, Debug, PartialEq, #sylvia ::schemars::JsonSchema)]
-                #[serde(rename_all="snake_case")]
-                pub struct #name #generics {
-                    #(pub #fields,)*
-                }
+        quote! {
+            #[allow(clippy::derive_partial_eq_without_eq)]
+            #[derive(#sylvia ::serde::Serialize, #sylvia ::serde::Deserialize, Clone, Debug, PartialEq, #sylvia ::schemars::JsonSchema)]
+            #[serde(rename_all="snake_case")]
+            pub struct #name #generics {
+                #(pub #fields,)*
+            }
 
-                impl #generics #name #generics #where_clause {
-                    pub fn new(#(#parameters,)*) -> Self {
-                        Self { #(#fields_names,)* }
-                    }
+            impl #generics #name #generics #where_clause {
+                pub fn new(#(#parameters,)*) -> Self {
+                    Self { #(#fields_names,)* }
+                }
 
-                    pub fn dispatch #unused_generics(self, contract: &#contract_type, ctx: #ctx_type)
-                        #result #full_where
-                    {
-                        let Self { #(#fields_names,)* } = self;
-                        contract.#function_name(Into::into(ctx), #(#fields_names,)*).map_err(Into::into)
-                    }
+                pub fn dispatch #unused_generics(self, contract: &#contract_type, ctx: #ctx_type)
+                    #result #full_where
+                {
+                    let Self { #(#fields_names,)* } = self;
+                    contract.#function_name(Into::into(ctx), #(#fields_names,)*).map_err(Into::into)
                 }
             }
         }
@@ -262,38 +259,35 @@ impl<'a> EnumMessage<'a> {
         let messages_fn_name = Ident::new(&format!("{}_messages", ep_name), enum_name.span());
         let derive_call = msg_ty.emit_derive_call();
 
-        #[cfg(not(tarpaulin_include))]
-        {
-            quote! {
-                #[allow(clippy::derive_partial_eq_without_eq)]
-                #derive_call
-                #[serde(rename_all="snake_case")]
-                pub enum #unique_enum_name #bracketed_used_generics {
-                    #(#msg_variants,)*
-                    #phantom_variant
-                }
-                pub type #enum_name #bracketed_used_generics = #unique_enum_name #bracketed_used_generics;
-
-                impl #bracketed_used_generics #unique_enum_name #bracketed_used_generics #where_clause {
-                    pub fn dispatch<ContractT, #(#unused_generics,)*>(self, contract: &ContractT, ctx: #ctx_type)
-                        -> #dispatch_type
-                    where
-                        #(#where_predicates,)*
-                        #contract_predicate
-                    {
-                        use #unique_enum_name::*;
-
-                        match self {
-                            #(#match_arms,)*
-                            #phatom_match_arm
-                        }
+        quote! {
+            #[allow(clippy::derive_partial_eq_without_eq)]
+            #derive_call
+            #[serde(rename_all="snake_case")]
+            pub enum #unique_enum_name #bracketed_used_generics {
+                #(#msg_variants,)*
+                #phantom_variant
+            }
+            pub type #enum_name #bracketed_used_generics = #unique_enum_name #bracketed_used_generics;
+
+            impl #bracketed_used_generics #unique_enum_name #bracketed_used_generics #where_clause {
+                pub fn dispatch<ContractT, #(#unused_generics,)*>(self, contract: &ContractT, ctx: #ctx_type)
+                    -> #dispatch_type
+                where
+                    #(#where_predicates,)*
+                    #contract_predicate
+                {
+                    use #unique_enum_name::*;
+
+                    match self {
+                        #(#match_arms,)*
+                        #phatom_match_arm
                     }
-                    #(#variants_constructors)*
                 }
+                #(#variants_constructors)*
+            }
 
-                pub const fn #messages_fn_name () -> [&'static str; #msgs_cnt] {
-                    [#(#msgs,)*]
-                }
+            pub const fn #messages_fn_name () -> [&'static str; #msgs_cnt] {
+                [#(#msgs,)*]
             }
         }
     }
@@ -375,33 +369,30 @@ impl<'a> ContractEnumMessage<'a> {
             false => quote! {},
         };
 
-        #[cfg(not(tarpaulin_include))]
-        {
-            quote! {
-                #[allow(clippy::derive_partial_eq_without_eq)]
-                #[derive(#sylvia ::serde::Serialize, #sylvia ::serde::Deserialize, Clone, Debug, PartialEq, #sylvia ::schemars::JsonSchema, #derive_query )]
-                #[serde(rename_all="snake_case")]
-                pub enum #enum_name #bracketed_used_generics {
-                    #(#variants,)*
-                    #phantom_variant
-                }
+        quote! {
+            #[allow(clippy::derive_partial_eq_without_eq)]
+            #[derive(#sylvia ::serde::Serialize, #sylvia ::serde::Deserialize, Clone, Debug, PartialEq, #sylvia ::schemars::JsonSchema, #derive_query )]
+            #[serde(rename_all="snake_case")]
+            pub enum #enum_name #bracketed_used_generics {
+                #(#variants,)*
+                #phantom_variant
+            }
 
-                impl #bracketed_used_generics #enum_name #bracketed_used_generics {
-                    pub fn dispatch #bracketed_unused_generics (self, contract: &#contract, ctx: #ctx_type) -> #ret_type #where_clause {
-                        use #enum_name::*;
+            impl #bracketed_used_generics #enum_name #bracketed_used_generics {
+                pub fn dispatch #bracketed_unused_generics (self, contract: &#contract, ctx: #ctx_type) -> #ret_type #where_clause {
+                    use #enum_name::*;
 
-                        match self {
-                            #(#match_arms,)*
-                            #phantom_match_arm
-                        }
+                    match self {
+                        #(#match_arms,)*
+                        #phantom_match_arm
                     }
-
-                    #(#variants_constructors)*
                 }
 
-                pub const fn #messages_fn_name () -> [&'static str; #variants_cnt] {
-                    [#(#variant_names,)*]
-                }
+                #(#variants_constructors)*
+            }
+
+            pub const fn #messages_fn_name () -> [&'static str; #variants_cnt] {
+                [#(#variant_names,)*]
             }
         }
     }
@@ -482,13 +473,10 @@ impl<'a> MsgVariant<'a> {
             _ => quote! {},
         };
 
-        #[cfg(not(tarpaulin_include))]
-        {
-            quote! {
-                #returns_attribute
-                #name {
-                    #(#fields,)*
-                }
+        quote! {
+            #returns_attribute
+            #name {
+                #(#fields,)*
             }
         }
     }
@@ -520,7 +508,6 @@ impl<'a> MsgVariant<'a> {
             .zip(args.clone())
             .map(|(field, num_field)| quote!(#field : #num_field));
 
-        #[cfg(not(tarpaulin_include))]
         match msg_type {
             Exec | Sudo => quote! {
                 #name {
@@ -569,13 +556,10 @@ impl<'a> MsgVariant<'a> {
         let variant_name = Ident::new(&name.to_string().to_case(Case::Snake), name.span());
         let bracketed_generics = emit_bracketed_generics(associated_name);
 
-        #[cfg(not(tarpaulin_include))]
-        {
-            quote! {
-                fn #variant_name(&self, #(#parameters),*) -> Result< #return_type, #sylvia:: cw_std::StdError> {
-                    let query = <Api #bracketed_generics as sylvia::types::InterfaceApi>::Query:: #variant_name (#(#fields_names),*);
-                    self.querier().query_wasm_smart(self.contract(), &query)
-                }
+        quote! {
+            fn #variant_name(&self, #(#parameters),*) -> Result< #return_type, #sylvia:: cw_std::StdError> {
+                let query = <Api #bracketed_generics as sylvia::types::InterfaceApi>::Query:: #variant_name (#(#fields_names),*);
+                self.querier().query_wasm_smart(self.contract(), &query)
             }
         }
     }
@@ -603,13 +587,10 @@ impl<'a> MsgVariant<'a> {
         let fields_names = fields.iter().map(MsgField::name);
         let variant_name = Ident::new(&name.to_string().to_case(Case::Snake), name.span());
 
-        #[cfg(not(tarpaulin_include))]
-        {
-            quote! {
-                fn #variant_name(&self, #(#parameters),*) -> Result< #return_type, #sylvia:: cw_std::StdError> {
-                    let query = #api_path :: #variant_name (#(#fields_names),*);
-                    self.querier().query_wasm_smart(self.contract(), &query)
-                }
+        quote! {
+            fn #variant_name(&self, #(#parameters),*) -> Result< #return_type, #sylvia:: cw_std::StdError> {
+                let query = #api_path :: #variant_name (#(#fields_names),*);
+                self.querier().query_wasm_smart(self.contract(), &query)
             }
         }
     }
@@ -632,11 +613,8 @@ impl<'a> MsgVariant<'a> {
             .map(|field| field.emit_method_field_folded(&mut fold));
         let variant_name = Ident::new(&name.to_string().to_case(Case::Snake), name.span());
 
-        #[cfg(not(tarpaulin_include))]
-        {
-            quote! {
-                fn #variant_name(&self, #(#parameters),*) -> Result< #return_type, #sylvia:: cw_std::StdError>;
-            }
+        quote! {
+            fn #variant_name(&self, #(#parameters),*) -> Result< #return_type, #sylvia:: cw_std::StdError>;
         }
     }
 
@@ -1122,12 +1100,9 @@ impl<'a> MsgField<'a> {
             ..
         } = self;
 
-        #[cfg(not(tarpaulin_include))]
-        {
-            quote! {
-                #(#attrs)*
-                #name: #stripped_ty
-            }
+        quote! {
+            #(#attrs)*
+            #name: #stripped_ty
         }
     }
 
@@ -1137,11 +1112,8 @@ impl<'a> MsgField<'a> {
             name, stripped_ty, ..
         } = self;
 
-        #[cfg(not(tarpaulin_include))]
-        {
-            quote! {
-                #name: #stripped_ty
-            }
+        quote! {
+            #name: #stripped_ty
         }
     }
 
@@ -1155,11 +1127,8 @@ impl<'a> MsgField<'a> {
 
         let ty = fold.fold_type((*stripped_ty).clone());
 
-        #[cfg(not(tarpaulin_include))]
-        {
-            quote! {
-                #name: #ty
-            }
+        quote! {
+            #name: #ty
         }
     }
 
@@ -1268,7 +1237,6 @@ impl<'a> GlueMessage<'a> {
 
         let interfaces_deserialization_attempts = interfaces.emit_deserialization_attempts(msg_ty);
 
-        #[cfg(not(tarpaulin_include))]
         let contract_deserialization_attempt = quote! {
             let msgs = &#messages_fn_name();
             if msgs.into_iter().any(|msg| msg == &recv_msg_name) {
@@ -1288,15 +1256,12 @@ impl<'a> GlueMessage<'a> {
 
         let response_schemas = match msg_ty {
             MsgType::Query => {
-                #[cfg(not(tarpaulin_include))]
-                {
-                    quote! {
-                        #[cfg(not(target_arch = "wasm32"))]
-                        impl #bracketed_wrapper_generics #sylvia ::cw_schema::QueryResponses for #contract_enum_name #bracketed_wrapper_generics #wrapper_where_clause {
-                            fn response_schemas_impl() -> std::collections::BTreeMap<String, #sylvia ::schemars::schema::RootSchema> {
-                                let responses = [#(#response_schemas_calls),*];
-                                responses.into_iter().flatten().collect()
-                            }
+                quote! {
+                    #[cfg(not(target_arch = "wasm32"))]
+                    impl #bracketed_wrapper_generics #sylvia ::cw_schema::QueryResponses for #contract_enum_name #bracketed_wrapper_generics #wrapper_where_clause {
+                        fn response_schemas_impl() -> std::collections::BTreeMap<String, #sylvia ::schemars::schema::RootSchema> {
+                            let responses = [#(#response_schemas_calls),*];
+                            responses.into_iter().flatten().collect()
                         }
                     }
                 }
@@ -1306,73 +1271,70 @@ impl<'a> GlueMessage<'a> {
             }
         };
 
-        #[cfg(not(tarpaulin_include))]
-        {
-            quote! {
-                #[allow(clippy::derive_partial_eq_without_eq)]
-                #[derive(#sylvia ::serde::Serialize, Clone, Debug, PartialEq, #sylvia ::schemars::JsonSchema)]
-                #[serde(rename_all="snake_case", untagged)]
-                pub enum #contract_enum_name #bracketed_wrapper_generics #wrapper_where_clause {
-                    #(#variants,)*
-                    #contract_variant
-                }
+        quote! {
+            #[allow(clippy::derive_partial_eq_without_eq)]
+            #[derive(#sylvia ::serde::Serialize, Clone, Debug, PartialEq, #sylvia ::schemars::JsonSchema)]
+            #[serde(rename_all="snake_case", untagged)]
+            pub enum #contract_enum_name #bracketed_wrapper_generics #wrapper_where_clause {
+                #(#variants,)*
+                #contract_variant
+            }
 
-                impl #bracketed_wrapper_generics #contract_enum_name #bracketed_wrapper_generics #wrapper_where_clause {
-                    pub fn dispatch #unused_generics (
-                        self,
-                        contract: &#contract,
-                        ctx: #ctx_type,
-                    ) -> #ret_type #full_where_clause {
-                        const _: () = {
-                            let msgs: [&[&str]; #variants_cnt] = [#(#messages_call),*];
-                            #sylvia ::utils::assert_no_intersection(msgs);
-                        };
-
-                        match self {
-                            #(#dispatch_arms,)*
-                            #dispatch_arm
-                        }
+            impl #bracketed_wrapper_generics #contract_enum_name #bracketed_wrapper_generics #wrapper_where_clause {
+                pub fn dispatch #unused_generics (
+                    self,
+                    contract: &#contract,
+                    ctx: #ctx_type,
+                ) -> #ret_type #full_where_clause {
+                    const _: () = {
+                        let msgs: [&[&str]; #variants_cnt] = [#(#messages_call),*];
+                        #sylvia ::utils::assert_no_intersection(msgs);
+                    };
+
+                    match self {
+                        #(#dispatch_arms,)*
+                        #dispatch_arm
                     }
                 }
+            }
 
-                #response_schemas
-
-                impl<'de, #(#wrapper_generics,)* > serde::Deserialize<'de> for #contract_enum_name #bracketed_wrapper_generics #wrapper_where_clause {
-                    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-                        where D: serde::Deserializer<'de>,
-                    {
-                        use serde::de::Error;
-
-                        let val = #sylvia ::serde_value::Value::deserialize(deserializer)?;
-                        let map = match &val {
-                            #sylvia ::serde_value::Value::Map(map) => map,
-                            _ => return Err(D::Error::custom("Wrong message format!"))
-                        };
-                        if map.len() != 1 {
-                            return Err(D::Error::custom(format!("Expected exactly one message. Received {}", map.len())))
-                        }
+            #response_schemas
 
-                        // Due to earlier size check of map this unwrap is safe
-                        let recv_msg_name = map.into_iter().next().unwrap();
+            impl<'de, #(#wrapper_generics,)* > serde::Deserialize<'de> for #contract_enum_name #bracketed_wrapper_generics #wrapper_where_clause {
+                fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+                    where D: serde::Deserializer<'de>,
+                {
+                    use serde::de::Error;
+
+                    let val = #sylvia ::serde_value::Value::deserialize(deserializer)?;
+                    let map = match &val {
+                        #sylvia ::serde_value::Value::Map(map) => map,
+                        _ => return Err(D::Error::custom("Wrong message format!"))
+                    };
+                    if map.len() != 1 {
+                        return Err(D::Error::custom(format!("Expected exactly one message. Received {}", map.len())))
+                    }
 
-                        if let #sylvia ::serde_value::Value::String(recv_msg_name) = &recv_msg_name .0 {
-                            #(#interfaces_deserialization_attempts)*
-                            #contract_deserialization_attempt
-                        }
+                    // Due to earlier size check of map this unwrap is safe
+                    let recv_msg_name = map.into_iter().next().unwrap();
 
-                        let msgs: [&[&str]; #variants_cnt] = [#(#messages_call),*];
-                        let mut err_msg = msgs.into_iter().flatten().fold(
-                            // It might be better to forward the error or serialization, but we just
-                            // deserialized it from JSON, not reason to expect failure here.
-                            format!(
-                                "Unsupported message received: {}. Messages supported by this contract: ",
-                                #sylvia ::serde_json::to_string(&val).unwrap_or_else(|_| String::new())
-                            ),
-                            |mut acc, message| acc + message + ", ",
-                        );
-                        err_msg.truncate(err_msg.len() - 2);
-                        Err(D::Error::custom(err_msg))
+                    if let #sylvia ::serde_value::Value::String(recv_msg_name) = &recv_msg_name .0 {
+                        #(#interfaces_deserialization_attempts)*
+                        #contract_deserialization_attempt
                     }
+
+                    let msgs: [&[&str]; #variants_cnt] = [#(#messages_call),*];
+                    let mut err_msg = msgs.into_iter().flatten().fold(
+                        // It might be better to forward the error or serialization, but we just
+                        // deserialized it from JSON, not reason to expect failure here.
+                        format!(
+                            "Unsupported message received: {}. Messages supported by this contract: ",
+                            #sylvia ::serde_json::to_string(&val).unwrap_or_else(|_| String::new())
+                        ),
+                        |mut acc, message| acc + message + ", ",
+                    );
+                    err_msg.truncate(err_msg.len() - 2);
+                    Err(D::Error::custom(err_msg))
                 }
             }
         }
@@ -1689,7 +1651,6 @@ impl<'a> EntryPoints<'a> {
             None => quote! {},
         };
 
-        #[cfg(not(tarpaulin_include))]
         {
             let entry_points = [
                 instantiate_variants,
diff --git a/sylvia-derive/src/message_type.rs b/sylvia-derive/src/message_type.rs
index 30b9307..0053887 100644
--- a/sylvia-derive/src/message_type.rs
+++ b/sylvia-derive/src/message_type.rs
@@ -39,7 +39,6 @@ impl MsgType {
         }
     }
 
-    #[cfg(not(tarpaulin_include))]
     pub fn emit_ctx_params(self, query_type: &Type) -> TokenStream {
         use MsgType::*;
 
@@ -58,7 +57,6 @@ impl MsgType {
         }
     }
 
-    #[cfg(not(tarpaulin_include))]
     pub fn emit_ep_name(self) -> Ident {
         match self {
             Self::Exec => parse_quote! { execute },
diff --git a/sylvia-derive/src/parser/attributes/custom.rs b/sylvia-derive/src/parser/attributes/custom.rs
index a809c87..647d228 100644
--- a/sylvia-derive/src/parser/attributes/custom.rs
+++ b/sylvia-derive/src/parser/attributes/custom.rs
@@ -44,7 +44,6 @@ impl Custom {
     }
 }
 
-#[cfg(not(tarpaulin_include))]
 // False negative. It is being called in closure
 impl Parse for Custom {
     fn parse(input: ParseStream) -> Result<Self> {
diff --git a/sylvia-derive/src/parser/attributes/error.rs b/sylvia-derive/src/parser/attributes/error.rs
index a45ad01..960fe36 100644
--- a/sylvia-derive/src/parser/attributes/error.rs
+++ b/sylvia-derive/src/parser/attributes/error.rs
@@ -31,8 +31,6 @@ impl ContractErrorAttr {
     }
 }
 
-#[cfg(not(tarpaulin_include))]
-// False negative. It is being called in closure
 impl Parse for ContractErrorAttr {
     fn parse(input: ParseStream) -> Result<Self> {
         input.parse().map(|error| Self { error })
diff --git a/sylvia-derive/src/parser/attributes/messages.rs b/sylvia-derive/src/parser/attributes/messages.rs
index fe0b066..455cbc7 100644
--- a/sylvia-derive/src/parser/attributes/messages.rs
+++ b/sylvia-derive/src/parser/attributes/messages.rs
@@ -76,7 +76,6 @@ fn interface_has_custom(content: ParseStream) -> Result<Customs> {
     Ok(customs)
 }
 
-#[cfg(not(tarpaulin_include))]
 // False negative. It is being called in closure
 impl Parse for ContractMessageAttr {
     fn parse(input: ParseStream) -> Result<Self> {
diff --git a/sylvia-derive/src/parser/attributes/override_entry_point.rs b/sylvia-derive/src/parser/attributes/override_entry_point.rs
index 7046837..c44752c 100644
--- a/sylvia-derive/src/parser/attributes/override_entry_point.rs
+++ b/sylvia-derive/src/parser/attributes/override_entry_point.rs
@@ -60,7 +60,6 @@ impl FilteredOverrideEntryPoints for &Vec<OverrideEntryPoint> {
     }
 }
 
-#[cfg(not(tarpaulin_include))]
 // False negative. It is being called in closure
 impl Parse for OverrideEntryPoint {
     fn parse(input: ParseStream) -> Result<Self> {
diff --git a/sylvia-derive/src/querier.rs b/sylvia-derive/src/querier.rs
index d70f5d7..efde2aa 100644
--- a/sylvia-derive/src/querier.rs
+++ b/sylvia-derive/src/querier.rs
@@ -55,40 +55,37 @@ where
         let types_definition = associated_types.emit_types_definition();
         let where_clause = associated_types.as_where_clause();
 
-        #[cfg(not(tarpaulin_include))]
-        {
-            quote! {
-                pub struct BoundQuerier<'a, C: #sylvia ::cw_std::CustomQuery, #(#generics,)* > {
-                    contract: &'a #sylvia ::cw_std::Addr,
-                    querier: &'a #sylvia ::cw_std::QuerierWrapper<'a, C>,
-                    _phantom: std::marker::PhantomData<( #(#generics,)* )>,
-                }
+        quote! {
+            pub struct BoundQuerier<'a, C: #sylvia ::cw_std::CustomQuery, #(#generics,)* > {
+                contract: &'a #sylvia ::cw_std::Addr,
+                querier: &'a #sylvia ::cw_std::QuerierWrapper<'a, C>,
+                _phantom: std::marker::PhantomData<( #(#generics,)* )>,
+            }
 
-                impl<'a, C: #sylvia ::cw_std::CustomQuery, #(#generics,)* > BoundQuerier<'a, C, #(#generics,)* > {
-                    pub fn querier(&self) -> &'a #sylvia ::cw_std::QuerierWrapper<'a, C> {
-                        self.querier
-                    }
+            impl<'a, C: #sylvia ::cw_std::CustomQuery, #(#generics,)* > BoundQuerier<'a, C, #(#generics,)* > {
+                pub fn querier(&self) -> &'a #sylvia ::cw_std::QuerierWrapper<'a, C> {
+                    self.querier
+                }
 
-                    pub fn contract(&self) -> &'a #sylvia ::cw_std::Addr {
-                        self.contract
-                    }
+                pub fn contract(&self) -> &'a #sylvia ::cw_std::Addr {
+                    self.contract
+                }
 
-                    pub fn borrowed(contract: &'a #sylvia ::cw_std::Addr, querier: &'a #sylvia ::cw_std::QuerierWrapper<'a, C>) -> Self {
-                        Self { contract, querier, _phantom: std::marker::PhantomData }
-                    }
+                pub fn borrowed(contract: &'a #sylvia ::cw_std::Addr, querier: &'a #sylvia ::cw_std::QuerierWrapper<'a, C>) -> Self {
+                    Self { contract, querier, _phantom: std::marker::PhantomData }
                 }
+            }
 
-                impl <'a, C: #sylvia ::cw_std::CustomQuery, #(#generics,)* > Querier for BoundQuerier<'a, C, #(#generics,)* > #where_clause {
-                    #(#types_definition)*
+            impl <'a, C: #sylvia ::cw_std::CustomQuery, #(#generics,)* > Querier for BoundQuerier<'a, C, #(#generics,)* > #where_clause {
+                #(#types_definition)*
 
-                    #(#methods_impl)*
-                }
+                #(#methods_impl)*
+            }
 
-                pub trait Querier {
-                    #(#types_declaration)*
+            pub trait Querier {
+                #(#types_declaration)*
 
-                    #(#methods_declaration)*
-                }
+                #(#methods_declaration)*
             }
         }
     }
@@ -162,14 +159,11 @@ where
 
         let types_definition = associated_types.as_item_types();
 
-        #[cfg(not(tarpaulin_include))]
-        {
-            quote! {
-                impl <'a, C: #sylvia ::cw_std::CustomQuery, #generic_params > #querier for #bound_querier<'a, C, #generic_params > #where_clause {
-                    #(#types_definition)*
+        quote! {
+            impl <'a, C: #sylvia ::cw_std::CustomQuery, #generic_params > #querier for #bound_querier<'a, C, #generic_params > #where_clause {
+                #(#types_definition)*
 
-                    #(#methods_impl)*
-                }
+                #(#methods_impl)*
             }
         }
     }
@@ -226,43 +220,40 @@ impl<'a> ContractQuerier<'a> {
             .unwrap_or(vec![]);
         let from_implementations = interfaces.emit_querier_from_impl(&generics);
 
-        #[cfg(not(tarpaulin_include))]
-        {
-            quote! {
-                pub struct BoundQuerier<'a, C: #sylvia ::cw_std::CustomQuery, #(#generics,)* > {
-                    contract: &'a #sylvia ::cw_std::Addr,
-                    querier: &'a #sylvia ::cw_std::QuerierWrapper<'a, C>,
-                    _phantom: std::marker::PhantomData<( #(#generics,)* )>,
-                }
-
-                impl<'a, C: #sylvia ::cw_std::CustomQuery, #(#generics,)* > BoundQuerier<'a, C, #(#generics,)* > {
-                    pub fn querier(&self) -> &'a #sylvia ::cw_std::QuerierWrapper<'a, C> {
-                        self.querier
-                    }
-
-                    pub fn contract(&self) -> &'a #sylvia ::cw_std::Addr {
-                        self.contract
-                    }
+        quote! {
+            pub struct BoundQuerier<'a, C: #sylvia ::cw_std::CustomQuery, #(#generics,)* > {
+                contract: &'a #sylvia ::cw_std::Addr,
+                querier: &'a #sylvia ::cw_std::QuerierWrapper<'a, C>,
+                _phantom: std::marker::PhantomData<( #(#generics,)* )>,
+            }
 
-                    pub fn borrowed(contract: &'a #sylvia ::cw_std::Addr, querier: &'a #sylvia ::cw_std::QuerierWrapper<'a, C>) -> Self {
-                        Self {contract, querier, _phantom: std::marker::PhantomData}
-                    }
+            impl<'a, C: #sylvia ::cw_std::CustomQuery, #(#generics,)* > BoundQuerier<'a, C, #(#generics,)* > {
+                pub fn querier(&self) -> &'a #sylvia ::cw_std::QuerierWrapper<'a, C> {
+                    self.querier
                 }
 
-                impl <'a, C: #sylvia ::cw_std::CustomQuery, #(#generics,)* > Querier for BoundQuerier<'a, C, #(#generics,)* > #where_clause {
-                    #(#types_implementation)*
+                pub fn contract(&self) -> &'a #sylvia ::cw_std::Addr {
+                    self.contract
+                }
 
-                    #(#methods_impl)*
+                pub fn borrowed(contract: &'a #sylvia ::cw_std::Addr, querier: &'a #sylvia ::cw_std::QuerierWrapper<'a, C>) -> Self {
+                    Self {contract, querier, _phantom: std::marker::PhantomData}
                 }
+            }
 
-                pub trait Querier {
-                    #(#types_declaration)*
+            impl <'a, C: #sylvia ::cw_std::CustomQuery, #(#generics,)* > Querier for BoundQuerier<'a, C, #(#generics,)* > #where_clause {
+                #(#types_implementation)*
 
-                    #(#methods_declaration)*
-                }
+                #(#methods_impl)*
+            }
 
-                #(#from_implementations)*
+            pub trait Querier {
+                #(#types_declaration)*
+
+                #(#methods_declaration)*
             }
+
+            #(#from_implementations)*
         }
     }
 }
diff --git a/sylvia-derive/src/utils.rs b/sylvia-derive/src/utils.rs
index 27132c0..ffe3e6a 100644
--- a/sylvia-derive/src/utils.rs
+++ b/sylvia-derive/src/utils.rs
@@ -11,7 +11,6 @@ use syn::{
 use crate::check_generics::{CheckGenerics, GetPath};
 use crate::message::MsgField;
 
-#[cfg(not(tarpaulin_include))]
 pub fn filter_wheres<'a, Generic: GetPath + PartialEq>(
     clause: &'a Option<WhereClause>,
     generics: &[&Generic],
diff --git a/sylvia/src/into_response.rs b/sylvia/src/into_response.rs
index 06f974f..a2bacfc 100644
--- a/sylvia/src/into_response.rs
+++ b/sylvia/src/into_response.rs
@@ -8,7 +8,6 @@ pub trait IntoMsg<C> {
 /// `SubMsg<Empty>` can be made into any `SubMsg<C>`
 impl<C> IntoMsg<C> for SubMsg<Empty> {
     fn into_msg(self) -> StdResult<SubMsg<C>> {
-        #[cfg(not(tarpaulin_include))]
         let msg = match self.msg {
             CosmosMsg::Wasm(wasm) => CosmosMsg::Wasm(wasm),
             CosmosMsg::Bank(bank) => CosmosMsg::Bank(bank),
diff --git a/sylvia/src/types.rs b/sylvia/src/types.rs
index dc091e2..3507102 100644
--- a/sylvia/src/types.rs
+++ b/sylvia/src/types.rs
@@ -47,7 +47,6 @@ pub struct SudoCtx<'a, C: cosmwasm_std::CustomQuery = Empty> {
     pub env: Env,
 }
 
-#[cfg(not(tarpaulin_include))]
 impl<C: cosmwasm_std::CustomQuery> ExecCtx<'_, C> {
     pub fn branch(&'_ mut self) -> ExecCtx<'_, C> {
         ExecCtx {
@@ -58,7 +57,6 @@ impl<C: cosmwasm_std::CustomQuery> ExecCtx<'_, C> {
     }
 }
 
-#[cfg(not(tarpaulin_include))]
 impl<C: cosmwasm_std::CustomQuery> InstantiateCtx<'_, C> {
     pub fn branch(&'_ mut self) -> InstantiateCtx<'_, C> {
         InstantiateCtx {
@@ -69,7 +67,6 @@ impl<C: cosmwasm_std::CustomQuery> InstantiateCtx<'_, C> {
     }
 }
 
-#[cfg(not(tarpaulin_include))]
 impl<C: cosmwasm_std::CustomQuery> SudoCtx<'_, C> {
     pub fn branch(&'_ mut self) -> SudoCtx<'_, C> {
         SudoCtx {


Test patch:
diff --git a/sylvia-derive/src/multitest.rs b/sylvia-derive/src/multitest.rs
index e7393f4..ea571bd 100644
--- a/sylvia-derive/src/multitest.rs
+++ b/sylvia-derive/src/multitest.rs
@@ -158,7 +158,6 @@ impl<'a> ContractMtHelpers<'a> {
         let sylvia = crate_module();
 
         let custom_msg = custom.msg_or_default();
-        #[cfg(not(tarpaulin_include))]
         let mt_app: Type = parse_quote! {
             #sylvia ::cw_multi_test::App<
                 BankT,
@@ -187,60 +186,22 @@ impl<'a> ContractMtHelpers<'a> {
 
         let contract_block = self.generate_contract_helpers();
 
-        #[cfg(not(tarpaulin_include))]
-        {
-            quote! {
-                pub mod multitest_utils {
-                    use super::*;
-                    use #sylvia ::cw_multi_test::Executor;
-                    use #sylvia ::derivative::Derivative;
-
-                    #[derive(Derivative)]
-                    #[derivative(Debug)]
-                    pub struct #proxy_name <'app, MtApp, #(#generic_params,)* > {
-                        pub contract_addr: #sylvia ::cw_std::Addr,
-                        #[derivative(Debug="ignore")]
-                        pub app: &'app #sylvia ::multitest::App<MtApp>,
-                        _phantom: std::marker::PhantomData<( #(#generic_params,)* )>,
-                    }
-
-                    impl<'app, BankT, ApiT, StorageT, CustomT, WasmT, StakingT, DistrT, IbcT, GovT, #(#generic_params,)* > #proxy_name <'app, #mt_app, #(#generic_params,)* >
-                        where
-                            CustomT: #sylvia ::cw_multi_test::Module,
-                            CustomT::ExecT: std::fmt::Debug
-                                + PartialEq
-                                + Clone
-                                + #sylvia ::schemars::JsonSchema
-                                + #sylvia ::serde::de::DeserializeOwned
-                                + 'static,
-                            CustomT::QueryT: #sylvia ::cw_std::CustomQuery + #sylvia ::serde::de::DeserializeOwned + 'static,
-                            WasmT: #sylvia ::cw_multi_test::Wasm<CustomT::ExecT, CustomT::QueryT>,
-                            BankT: #sylvia ::cw_multi_test::Bank,
-                            ApiT: #sylvia ::cw_std::Api,
-                            StorageT: #sylvia ::cw_std::Storage,
-                            StakingT: #sylvia ::cw_multi_test::Staking,
-                            DistrT: #sylvia ::cw_multi_test::Distribution,
-                            IbcT: #sylvia ::cw_multi_test::Ibc,
-                            GovT: #sylvia ::cw_multi_test::Gov,
-                            #mt_app : Executor< #custom_msg >,
-                            #where_predicates
-                    {
-                        pub fn new(contract_addr: #sylvia ::cw_std::Addr, app: &'app #sylvia ::multitest::App< #mt_app >) -> Self {
-                            #proxy_name { contract_addr, app, _phantom: std::marker::PhantomData::default() }
-                        }
-
-                        #( #exec_methods )*
-                        #( #migrate_methods )*
-                        #( #query_methods )*
-                        #( #sudo_methods )*
-                    }
+        quote! {
+            pub mod multitest_utils {
+                use super::*;
+                use #sylvia ::cw_multi_test::Executor;
+                use #sylvia ::derivative::Derivative;
+
+                #[derive(Derivative)]
+                #[derivative(Debug)]
+                pub struct #proxy_name <'app, MtApp, #(#generic_params,)* > {
+                    pub contract_addr: #sylvia ::cw_std::Addr,
+                    #[derivative(Debug="ignore")]
+                    pub app: &'app #sylvia ::multitest::App<MtApp>,
+                    _phantom: std::marker::PhantomData<( #(#generic_params,)* )>,
+                }
 
-                    impl<'app, BankT, ApiT, StorageT, CustomT, WasmT, StakingT, DistrT, IbcT, GovT, #(#generic_params,)* >
-                        From<(
-                            #sylvia ::cw_std::Addr,
-                            &'app #sylvia ::multitest::App<#mt_app>,
-                        )>
-                        for #proxy_name <'app, #mt_app, #(#generic_params,)* >
+                impl<'app, BankT, ApiT, StorageT, CustomT, WasmT, StakingT, DistrT, IbcT, GovT, #(#generic_params,)* > #proxy_name <'app, #mt_app, #(#generic_params,)* >
                     where
                         CustomT: #sylvia ::cw_multi_test::Module,
                         CustomT::ExecT: std::fmt::Debug
@@ -260,15 +221,50 @@ impl<'a> ContractMtHelpers<'a> {
                         GovT: #sylvia ::cw_multi_test::Gov,
                         #mt_app : Executor< #custom_msg >,
                         #where_predicates
-                    {
-                        fn from(input: (#sylvia ::cw_std::Addr, &'app #sylvia ::multitest::App< #mt_app >))
-                            -> #proxy_name<'app, #mt_app, #(#generic_params,)* > {
-                            #proxy_name::new(input.0, input.1)
-                        }
+                {
+                    pub fn new(contract_addr: #sylvia ::cw_std::Addr, app: &'app #sylvia ::multitest::App< #mt_app >) -> Self {
+                        #proxy_name { contract_addr, app, _phantom: std::marker::PhantomData::default() }
                     }
 
-                    #contract_block
+                    #( #exec_methods )*
+                    #( #migrate_methods )*
+                    #( #query_methods )*
+                    #( #sudo_methods )*
+                }
+
+                impl<'app, BankT, ApiT, StorageT, CustomT, WasmT, StakingT, DistrT, IbcT, GovT, #(#generic_params,)* >
+                    From<(
+                        #sylvia ::cw_std::Addr,
+                        &'app #sylvia ::multitest::App<#mt_app>,
+                    )>
+                    for #proxy_name <'app, #mt_app, #(#generic_params,)* >
+                where
+                    CustomT: #sylvia ::cw_multi_test::Module,
+                    CustomT::ExecT: std::fmt::Debug
+                        + PartialEq
+                        + Clone
+                        + #sylvia ::schemars::JsonSchema
+                        + #sylvia ::serde::de::DeserializeOwned
+                        + 'static,
+                    CustomT::QueryT: #sylvia ::cw_std::CustomQuery + #sylvia ::serde::de::DeserializeOwned + 'static,
+                    WasmT: #sylvia ::cw_multi_test::Wasm<CustomT::ExecT, CustomT::QueryT>,
+                    BankT: #sylvia ::cw_multi_test::Bank,
+                    ApiT: #sylvia ::cw_std::Api,
+                    StorageT: #sylvia ::cw_std::Storage,
+                    StakingT: #sylvia ::cw_multi_test::Staking,
+                    DistrT: #sylvia ::cw_multi_test::Distribution,
+                    IbcT: #sylvia ::cw_multi_test::Ibc,
+                    GovT: #sylvia ::cw_multi_test::Gov,
+                    #mt_app : Executor< #custom_msg >,
+                    #where_predicates
+                {
+                    fn from(input: (#sylvia ::cw_std::Addr, &'app #sylvia ::multitest::App< #mt_app >))
+                        -> #proxy_name<'app, #mt_app, #(#generic_params,)* > {
+                        #proxy_name::new(input.0, input.1)
+                    }
                 }
+
+                #contract_block
             }
         }
     }
@@ -318,7 +314,6 @@ impl<'a> ContractMtHelpers<'a> {
         let custom_msg = self.custom.msg_or_default();
         let custom_query = self.custom.query_or_default();
 
-        #[cfg(not(tarpaulin_include))]
         let mt_app = quote! {
             #sylvia ::cw_multi_test::App<
                 BankT,
@@ -334,48 +329,41 @@ impl<'a> ContractMtHelpers<'a> {
         };
 
         let instantiate2 = if cfg!(feature = "cosmwasm_1_2") {
-            #[cfg(not(tarpaulin_include))]
-            {
-                quote! {
-                    let msg = #sylvia ::cw_std::to_json_binary(&msg)
-                        .map_err(Into::< #error_type >::into)?;
-                    let sender = #sylvia ::cw_std::Addr::unchecked(sender);
-
-                    let msg = #sylvia ::cw_std::WasmMsg::Instantiate2 {
-                        admin,
-                        code_id: code_id.code_id,
-                        msg,
-                        funds: funds.to_owned(),
-                        label: label.to_owned(),
-                        salt: salt.into(),
-                    };
-                    let app_response = (*code_id.app)
-                        .app_mut()
-                        .execute(sender.clone(), msg.into())
-                        .map_err(|err| err.downcast::< #error_type >().unwrap())?;
-
-                    #sylvia:: cw_utils::parse_instantiate_response_data(app_response.data.unwrap().as_slice())
-                        .map_err(|err| Into::into( #sylvia ::cw_std::StdError::generic_err(err.to_string())))
-                        .map(|data| #proxy_name {
-                            contract_addr: #sylvia ::cw_std::Addr::unchecked(data.contract_address),
-                            app: code_id.app,
-                            _phantom: std::marker::PhantomData::default(),
-                        })
-                }
+            quote! {
+                let msg = #sylvia ::cw_std::to_json_binary(&msg)
+                    .map_err(Into::< #error_type >::into)?;
+                let sender = #sylvia ::cw_std::Addr::unchecked(sender);
+
+                let msg = #sylvia ::cw_std::WasmMsg::Instantiate2 {
+                    admin,
+                    code_id: code_id.code_id,
+                    msg,
+                    funds: funds.to_owned(),
+                    label: label.to_owned(),
+                    salt: salt.into(),
+                };
+                let app_response = (*code_id.app)
+                    .app_mut()
+                    .execute(sender.clone(), msg.into())
+                    .map_err(|err| err.downcast::< #error_type >().unwrap())?;
+
+                #sylvia:: cw_utils::parse_instantiate_response_data(app_response.data.unwrap().as_slice())
+                    .map_err(|err| Into::into( #sylvia ::cw_std::StdError::generic_err(err.to_string())))
+                    .map(|data| #proxy_name {
+                        contract_addr: #sylvia ::cw_std::Addr::unchecked(data.contract_address),
+                        app: code_id.app,
+                        _phantom: std::marker::PhantomData::default(),
+                    })
             }
         } else {
-            #[cfg(not(tarpaulin_include))]
-            {
-                quote! {
-                    let err = #sylvia ::cw_std::StdError::generic_err(
-                        "`with_salt` was called, but it requires `cosmwasm_1_2` feature enabled. Consider removing `with_salt` or adding the `cosmwasm_1_2` feature."
-                    );
-                    Err(Into::into(err))
-                }
+            quote! {
+                let err = #sylvia ::cw_std::StdError::generic_err(
+                    "`with_salt` was called, but it requires `cosmwasm_1_2` feature enabled. Consider removing `with_salt` or adding the `cosmwasm_1_2` feature."
+                );
+                Err(Into::into(err))
             }
         };
 
-        #[cfg(not(tarpaulin_include))]
         let code_info = if cfg!(feature = "cosmwasm_1_2") {
             quote! {
                 pub fn code_info(&self) -> #sylvia ::cw_std::StdResult< #sylvia ::cw_std::CodeInfoResponse> {
@@ -386,115 +374,112 @@ impl<'a> ContractMtHelpers<'a> {
             quote! {}
         };
 
-        #[cfg(not(tarpaulin_include))]
-        {
-            quote! {
-                #impl_contract
+        quote! {
+            #impl_contract
 
-                pub struct CodeId<'app, #(#generic_params,)* MtApp> {
-                    code_id: u64,
-                    app: &'app #sylvia ::multitest::App<MtApp>,
-                    _phantom: std::marker::PhantomData<( #(#generic_params,)* )>,
+            pub struct CodeId<'app, #(#generic_params,)* MtApp> {
+                code_id: u64,
+                app: &'app #sylvia ::multitest::App<MtApp>,
+                _phantom: std::marker::PhantomData<( #(#generic_params,)* )>,
 
-                }
+            }
 
-                impl<'app, BankT, ApiT, StorageT, CustomT, StakingT, DistrT, IbcT, GovT, #(#generic_params,)* > CodeId<'app, #(#generic_params,)* #mt_app >
-                    where
-                        BankT: #sylvia ::cw_multi_test::Bank,
-                        ApiT: #sylvia ::cw_std::Api,
-                        StorageT: #sylvia ::cw_std::Storage,
-                        CustomT: #sylvia ::cw_multi_test::Module<ExecT = #custom_msg, QueryT = #custom_query >,
-                        StakingT: #sylvia ::cw_multi_test::Staking,
-                        DistrT: #sylvia ::cw_multi_test::Distribution,
-                        IbcT: #sylvia ::cw_multi_test::Ibc,
-                        GovT: #sylvia ::cw_multi_test::Gov,
-                        #where_predicates
-                {
-                    pub fn store_code(app: &'app #sylvia ::multitest::App< #mt_app >) -> Self {
-                        let code_id = app
-                            .app_mut()
-                            .store_code(Box::new(#contract ::new()));
-                        Self { code_id, app, _phantom: std::marker::PhantomData::default() }
-                    }
+            impl<'app, BankT, ApiT, StorageT, CustomT, StakingT, DistrT, IbcT, GovT, #(#generic_params,)* > CodeId<'app, #(#generic_params,)* #mt_app >
+                where
+                    BankT: #sylvia ::cw_multi_test::Bank,
+                    ApiT: #sylvia ::cw_std::Api,
+                    StorageT: #sylvia ::cw_std::Storage,
+                    CustomT: #sylvia ::cw_multi_test::Module<ExecT = #custom_msg, QueryT = #custom_query >,
+                    StakingT: #sylvia ::cw_multi_test::Staking,
+                    DistrT: #sylvia ::cw_multi_test::Distribution,
+                    IbcT: #sylvia ::cw_multi_test::Ibc,
+                    GovT: #sylvia ::cw_multi_test::Gov,
+                    #where_predicates
+            {
+                pub fn store_code(app: &'app #sylvia ::multitest::App< #mt_app >) -> Self {
+                    let code_id = app
+                        .app_mut()
+                        .store_code(Box::new(#contract ::new()));
+                    Self { code_id, app, _phantom: std::marker::PhantomData::default() }
+                }
 
-                    pub fn code_id(&self) -> u64 {
-                        self.code_id
-                    }
+                pub fn code_id(&self) -> u64 {
+                    self.code_id
+                }
 
-                    #code_info
-
-                    pub fn instantiate(
-                        &self, #(#fields,)*
-                    ) -> InstantiateProxy<'_, 'app, #(#generic_params,)* #mt_app > {
-                        let msg = #instantiate_msg {#(#fields_names,)*};
-                        InstantiateProxy::< #(#generic_params,)* _> {
-                            code_id: self,
-                            funds: &[],
-                            label: "Contract",
-                            admin: None,
-                            salt: None,
-                            msg,
-                        }
+                #code_info
+
+                pub fn instantiate(
+                    &self, #(#fields,)*
+                ) -> InstantiateProxy<'_, 'app, #(#generic_params,)* #mt_app > {
+                    let msg = #instantiate_msg {#(#fields_names,)*};
+                    InstantiateProxy::< #(#generic_params,)* _> {
+                        code_id: self,
+                        funds: &[],
+                        label: "Contract",
+                        admin: None,
+                        salt: None,
+                        msg,
                     }
                 }
+            }
+
+            pub struct InstantiateProxy<'proxy, 'app, #(#generic_params,)* MtApp> {
+                code_id: &'proxy CodeId <'app, #(#generic_params,)* MtApp>,
+                funds: &'proxy [#sylvia ::cw_std::Coin],
+                label: &'proxy str,
+                admin: Option<String>,
+                salt: Option<&'proxy [u8]>,
+                msg: InstantiateMsg #bracketed_used_generics,
+            }
 
-                pub struct InstantiateProxy<'proxy, 'app, #(#generic_params,)* MtApp> {
-                    code_id: &'proxy CodeId <'app, #(#generic_params,)* MtApp>,
-                    funds: &'proxy [#sylvia ::cw_std::Coin],
-                    label: &'proxy str,
-                    admin: Option<String>,
-                    salt: Option<&'proxy [u8]>,
-                    msg: InstantiateMsg #bracketed_used_generics,
+            impl<'proxy, 'app, #(#generic_params,)* MtApp> InstantiateProxy<'proxy, 'app, #(#generic_params,)* MtApp>
+                where
+                    MtApp: Executor< #custom_msg >,
+                    #where_predicates
+            {
+                pub fn with_funds(self, funds: &'proxy [#sylvia ::cw_std::Coin]) -> Self {
+                    Self { funds, ..self }
                 }
 
-                impl<'proxy, 'app, #(#generic_params,)* MtApp> InstantiateProxy<'proxy, 'app, #(#generic_params,)* MtApp>
-                    where
-                        MtApp: Executor< #custom_msg >,
-                        #where_predicates
-                {
-                    pub fn with_funds(self, funds: &'proxy [#sylvia ::cw_std::Coin]) -> Self {
-                        Self { funds, ..self }
-                    }
+                pub fn with_label(self, label: &'proxy str) -> Self {
+                    Self { label, ..self }
+                }
 
-                    pub fn with_label(self, label: &'proxy str) -> Self {
-                        Self { label, ..self }
-                    }
+                pub fn with_admin<'s>(self, admin: impl Into<Option<&'s str>>) -> Self {
+                    let admin = admin.into().map(str::to_owned);
+                    Self { admin, ..self }
+                }
 
-                    pub fn with_admin<'s>(self, admin: impl Into<Option<&'s str>>) -> Self {
-                        let admin = admin.into().map(str::to_owned);
-                        Self { admin, ..self }
-                    }
+                pub fn with_salt(self, salt: impl Into<Option<&'proxy [u8]>>) -> Self {
+                    let salt = salt.into();
+                    Self { salt, ..self }
+                }
 
-                    pub fn with_salt(self, salt: impl Into<Option<&'proxy [u8]>>) -> Self {
-                        let salt = salt.into();
-                        Self { salt, ..self }
-                    }
+                #[track_caller]
+                pub fn call(self, sender: &str) -> Result<#proxy_name<'app, MtApp, #(#generic_params,)* >, #error_type> {
+                    let Self {code_id, funds, label, admin, salt, msg} = self;
 
-                    #[track_caller]
-                    pub fn call(self, sender: &str) -> Result<#proxy_name<'app, MtApp, #(#generic_params,)* >, #error_type> {
-                        let Self {code_id, funds, label, admin, salt, msg} = self;
-
-                        match salt {
-                            Some(salt) => {
-                                #instantiate2
-                            },
-                            None => (*code_id.app)
-                                .app_mut()
-                                .instantiate_contract(
-                                    code_id.code_id,
-                                    #sylvia ::cw_std::Addr::unchecked(sender),
-                                    &msg,
-                                    funds,
-                                    label,
-                                    admin,
-                                )
-                                .map_err(|err| err.downcast().unwrap())
-                                .map(|addr| #proxy_name {
-                                    contract_addr: addr,
-                                    app: code_id.app,
-                                    _phantom: std::marker::PhantomData::default(),
-                                }),
-                        }
+                    match salt {
+                        Some(salt) => {
+                            #instantiate2
+                        },
+                        None => (*code_id.app)
+                            .app_mut()
+                            .instantiate_contract(
+                                code_id.code_id,
+                                #sylvia ::cw_std::Addr::unchecked(sender),
+                                &msg,
+                                funds,
+                                label,
+                                admin,
+                            )
+                            .map_err(|err| err.downcast().unwrap())
+                            .map(|addr| #proxy_name {
+                                contract_addr: addr,
+                                app: code_id.app,
+                                _phantom: std::marker::PhantomData::default(),
+                            }),
                     }
                 }
             }
@@ -570,65 +555,62 @@ impl<'a> ContractMtHelpers<'a> {
         let custom_msg = custom.msg_or_default();
         let custom_query = custom.query_or_default();
 
-        #[cfg(not(tarpaulin_include))]
-        {
-            quote! {
-                impl #bracketed_generics #sylvia ::cw_multi_test::Contract<#custom_msg, #custom_query> for #contract #full_where_clause {
-                    fn execute(
-                        &self,
-                        deps: #sylvia ::cw_std::DepsMut< #custom_query >,
-                        env: #sylvia ::cw_std::Env,
-                        info: #sylvia ::cw_std::MessageInfo,
-                        msg: Vec<u8>,
-                    ) -> #sylvia ::anyhow::Result<#sylvia ::cw_std::Response<#custom_msg>> {
-                        #exec_body
-                    }
+        quote! {
+            impl #bracketed_generics #sylvia ::cw_multi_test::Contract<#custom_msg, #custom_query> for #contract #full_where_clause {
+                fn execute(
+                    &self,
+                    deps: #sylvia ::cw_std::DepsMut< #custom_query >,
+                    env: #sylvia ::cw_std::Env,
+                    info: #sylvia ::cw_std::MessageInfo,
+                    msg: Vec<u8>,
+                ) -> #sylvia ::anyhow::Result<#sylvia ::cw_std::Response<#custom_msg>> {
+                    #exec_body
+                }
 
-                    fn instantiate(
-                        &self,
-                        deps: #sylvia ::cw_std::DepsMut<#custom_query>,
-                        env: #sylvia ::cw_std::Env,
-                        info: #sylvia ::cw_std::MessageInfo,
-                        msg: Vec<u8>,
-                    ) -> #sylvia ::anyhow::Result<#sylvia ::cw_std::Response<#custom_msg>> {
-                        #instantiate_body
-                    }
+                fn instantiate(
+                    &self,
+                    deps: #sylvia ::cw_std::DepsMut<#custom_query>,
+                    env: #sylvia ::cw_std::Env,
+                    info: #sylvia ::cw_std::MessageInfo,
+                    msg: Vec<u8>,
+                ) -> #sylvia ::anyhow::Result<#sylvia ::cw_std::Response<#custom_msg>> {
+                    #instantiate_body
+                }
 
-                    fn query(
-                        &self,
-                        deps: #sylvia ::cw_std::Deps<#custom_query>,
-                        env: #sylvia ::cw_std::Env,
-                        msg: Vec<u8>,
-                    ) -> #sylvia ::anyhow::Result<#sylvia ::cw_std::Binary> {
-                        #query_body
-                    }
+                fn query(
+                    &self,
+                    deps: #sylvia ::cw_std::Deps<#custom_query>,
+                    env: #sylvia ::cw_std::Env,
+                    msg: Vec<u8>,
+                ) -> #sylvia ::anyhow::Result<#sylvia ::cw_std::Binary> {
+                    #query_body
+                }
 
-                    fn sudo(
-                        &self,
-                        deps: #sylvia ::cw_std::DepsMut<#custom_query>,
-                        env: #sylvia ::cw_std::Env,
-                        msg: Vec<u8>,
-                    ) -> #sylvia ::anyhow::Result<#sylvia ::cw_std::Response<#custom_msg>> {
-                        #sudo_body
-                    }
+                fn sudo(
+                    &self,
+                    deps: #sylvia ::cw_std::DepsMut<#custom_query>,
+                    env: #sylvia ::cw_std::Env,
+                    msg: Vec<u8>,
+                ) -> #sylvia ::anyhow::Result<#sylvia ::cw_std::Response<#custom_msg>> {
+                    #sudo_body
+                }
 
-                    fn reply(
-                        &self,
-                        deps: #sylvia ::cw_std::DepsMut<#custom_query>,
-                        env: #sylvia ::cw_std::Env,
-                        msg: #sylvia ::cw_std::Reply,
-                    ) -> #sylvia ::anyhow::Result<#sylvia ::cw_std::Response<#custom_msg>> {
-                        #reply_body
-                    }
+                fn reply(
+                    &self,
+                    deps: #sylvia ::cw_std::DepsMut<#custom_query>,
+                    env: #sylvia ::cw_std::Env,
+                    msg: #sylvia ::cw_std::Reply,
+                ) -> #sylvia ::anyhow::Result<#sylvia ::cw_std::Response<#custom_msg>> {
+                    #reply_body
+                }
 
-                    fn migrate(
-                        &self,
-                        deps: #sylvia ::cw_std::DepsMut<#custom_query>,
-                        env: #sylvia ::cw_std::Env,
-                        msg: Vec<u8>,
-                    ) -> #sylvia ::anyhow::Result<#sylvia ::cw_std::Response<#custom_msg>> {
-                        #migrate_body
-                    }
+                fn migrate(
+                    &self,
+                    deps: #sylvia ::cw_std::DepsMut<#custom_query>,
+                    env: #sylvia ::cw_std::Env,
+                    msg: Vec<u8>,
+                ) -> #sylvia ::anyhow::Result<#sylvia ::cw_std::Response<#custom_msg>> {
+                    #migrate_body
                 }
             }
         }
@@ -739,7 +721,6 @@ impl<'a> ImplMtHelpers<'a> {
             .or(associated_msg.cloned())
             .unwrap_or(Custom::default_type());
 
-        #[cfg(not(tarpaulin_include))]
         let mt_app = parse_quote! {
             #sylvia ::cw_multi_test::App<
                 BankT,
@@ -811,44 +792,41 @@ impl<'a> ImplMtHelpers<'a> {
             .as_ref()
             .map(|where_clause| &where_clause.predicates);
 
-        #[cfg(not(tarpaulin_include))]
-        {
-            quote! {
-                pub mod test_utils {
-                    use super::*;
+        quote! {
+            pub mod test_utils {
+                use super::*;
 
-                    pub trait #trait_name<MtApp, #(#generic_params,)* > #where_clause {
-                        #(#query_methods_declarations)*
-                        #(#exec_methods_declarations)*
-                        #(#sudo_methods_declarations)*
-                    }
+                pub trait #trait_name<MtApp, #(#generic_params,)* > #where_clause {
+                    #(#query_methods_declarations)*
+                    #(#exec_methods_declarations)*
+                    #(#sudo_methods_declarations)*
+                }
 
-                    impl<BankT, ApiT, StorageT, CustomT, WasmT, StakingT, DistrT, IbcT, GovT, #(#generic_params,)* > #trait_name< #mt_app, #(#generic_params,)* > for #contract_module sv::multitest_utils:: #contract_proxy <'_, #mt_app, #(#generic_params,)* >
-                    where
-                        CustomT: #sylvia ::cw_multi_test::Module,
-                        WasmT: #sylvia ::cw_multi_test::Wasm<CustomT::ExecT, CustomT::QueryT>,
-                        BankT: #sylvia ::cw_multi_test::Bank,
-                        ApiT: #sylvia ::cw_std::Api,
-                        StorageT: #sylvia ::cw_std::Storage,
-                        CustomT: #sylvia ::cw_multi_test::Module,
-                        StakingT: #sylvia ::cw_multi_test::Staking,
-                        DistrT: #sylvia ::cw_multi_test::Distribution,
-                        IbcT: #sylvia ::cw_multi_test::Ibc,
-                        GovT: #sylvia ::cw_multi_test::Gov,
-                        CustomT::ExecT: Clone
-                            + std::fmt::Debug
-                            + PartialEq
-                            + #sylvia ::schemars::JsonSchema
-                            + #sylvia ::serde::de::DeserializeOwned
-                            + 'static,
-                        CustomT::QueryT: #sylvia:: cw_std::CustomQuery + #sylvia ::serde::de::DeserializeOwned + 'static,
-                        #mt_app : #sylvia ::cw_multi_test::Executor< #custom_msg >,
-                        #where_predicates
-                    {
-                        #(#query_methods)*
-                        #(#exec_methods)*
-                        #(#sudo_methods)*
-                    }
+                impl<BankT, ApiT, StorageT, CustomT, WasmT, StakingT, DistrT, IbcT, GovT, #(#generic_params,)* > #trait_name< #mt_app, #(#generic_params,)* > for #contract_module sv::multitest_utils:: #contract_proxy <'_, #mt_app, #(#generic_params,)* >
+                where
+                    CustomT: #sylvia ::cw_multi_test::Module,
+                    WasmT: #sylvia ::cw_multi_test::Wasm<CustomT::ExecT, CustomT::QueryT>,
+                    BankT: #sylvia ::cw_multi_test::Bank,
+                    ApiT: #sylvia ::cw_std::Api,
+                    StorageT: #sylvia ::cw_std::Storage,
+                    CustomT: #sylvia ::cw_multi_test::Module,
+                    StakingT: #sylvia ::cw_multi_test::Staking,
+                    DistrT: #sylvia ::cw_multi_test::Distribution,
+                    IbcT: #sylvia ::cw_multi_test::Ibc,
+                    GovT: #sylvia ::cw_multi_test::Gov,
+                    CustomT::ExecT: Clone
+                        + std::fmt::Debug
+                        + PartialEq
+                        + #sylvia ::schemars::JsonSchema
+                        + #sylvia ::serde::de::DeserializeOwned
+                        + 'static,
+                    CustomT::QueryT: #sylvia:: cw_std::CustomQuery + #sylvia ::serde::de::DeserializeOwned + 'static,
+                    #mt_app : #sylvia ::cw_multi_test::Executor< #custom_msg >,
+                    #where_predicates
+                {
+                    #(#query_methods)*
+                    #(#exec_methods)*
+                    #(#sudo_methods)*
                 }
             }
         }
diff --git a/sylvia/tests/custom_msg.rs b/sylvia/tests/custom_msg.rs
index 5615a89..b6c73c9 100644
--- a/sylvia/tests/custom_msg.rs
+++ b/sylvia/tests/custom_msg.rs
@@ -31,15 +31,12 @@ mod some_interface {
     pub trait SomeInterface {
         type Error: From<StdError>;
 
-        #[cfg(not(tarpaulin_include))]
         #[sv::msg(query)]
         fn interface_query(&self, ctx: QueryCtx) -> StdResult<SomeResponse>;
 
-        #[cfg(not(tarpaulin_include))]
         #[sv::msg(exec)]
         fn interface_exec(&self, ctx: ExecCtx) -> StdResult<Response<MyMsg>>;
 
-        #[cfg(not(tarpaulin_include))]
         #[sv::msg(sudo)]
         fn interface_sudo(&self, ctx: SudoCtx) -> StdResult<Response<MyMsg>>;
     }
@@ -89,15 +86,12 @@ mod interface {
         type Error: From<StdError>;
         type ExecC: CustomMsg;
 
-        #[cfg(not(tarpaulin_include))]
         #[sv::msg(exec)]
         fn exec(&self, ctx: ExecCtx) -> StdResult<Response<MyMsg>>;
 
-        #[cfg(not(tarpaulin_include))]
         #[sv::msg(query)]
         fn query(&self, ctx: QueryCtx) -> StdResult<Response<MyMsg>>;
 
-        #[cfg(not(tarpaulin_include))]
         #[sv::msg(sudo)]
         fn sudo(&self, ctx: SudoCtx) -> StdResult<Response<MyMsg>>;
     }
@@ -126,7 +120,6 @@ mod impl_interface {
             Ok(Response::new())
         }
 
-        #[cfg(not(tarpaulin_include))]
         #[sv::msg(sudo)]
         fn sudo(&self, _ctx: SudoCtx) -> StdResult<Response<MyMsg>> {
             Ok(Response::new())
@@ -143,15 +136,12 @@ mod other_interface {
     pub trait OtherInterface {
         type Error: From<StdError>;
 
-        #[cfg(not(tarpaulin_include))]
         #[sv::msg(exec)]
         fn other_interface_exec(&self, ctx: ExecCtx) -> StdResult<Response>;
 
-        #[cfg(not(tarpaulin_include))]
         #[sv::msg(sudo)]
         fn other_interface_sudo(&self, ctx: SudoCtx) -> StdResult<Response>;
 
-        #[cfg(not(tarpaulin_include))]
         #[sv::msg(query)]
         fn other_interface_query(&self, ctx: QueryCtx) -> StdResult<Response>;
     }
@@ -173,13 +163,11 @@ mod impl_other_interface {
             Ok(Response::default())
         }
 
-        #[cfg(not(tarpaulin_include))]
         #[sv::msg(sudo)]
         fn other_interface_sudo(&self, _ctx: SudoCtx) -> StdResult<Response> {
             Ok(Response::new())
         }
 
-        #[cfg(not(tarpaulin_include))]
         #[sv::msg(query)]
         fn other_interface_query(&self, _ctx: QueryCtx) -> StdResult<Response> {
             Ok(Response::new())
@@ -198,15 +186,12 @@ mod associated_interface {
         type Error: From<StdError>;
         type ExecC: CustomMsg;
 
-        #[cfg(not(tarpaulin_include))]
         #[sv::msg(exec)]
         fn associated_exec(&self, ctx: ExecCtx) -> StdResult<Response<Self::ExecC>>;
 
-        #[cfg(not(tarpaulin_include))]
         #[sv::msg(sudo)]
         fn associated_sudo(&self, ctx: SudoCtx) -> StdResult<Response<Self::ExecC>>;
 
-        #[cfg(not(tarpaulin_include))]
         #[sv::msg(query)]
         fn associated_query(&self, ctx: QueryCtx) -> StdResult<SomeResponse>;
     }
@@ -269,13 +254,11 @@ impl MyContract {
         Ok(SomeResponse)
     }
 
-    #[cfg(not(tarpaulin_include))]
     #[sv::msg(migrate)]
     pub fn some_migrate(&self, _ctx: MigrateCtx) -> StdResult<Response<MyMsg>> {
         Ok(Response::default())
     }
 
-    #[cfg(not(tarpaulin_include))]
     #[sv::msg(sudo)]
     pub fn some_sudo(&self, _ctx: SudoCtx) -> StdResult<Response<MyMsg>> {
         Ok(Response::default())
diff --git a/sylvia/tests/custom_query.rs b/sylvia/tests/custom_query.rs
index c2a3a12..e4302da 100644
--- a/sylvia/tests/custom_query.rs
+++ b/sylvia/tests/custom_query.rs
@@ -31,15 +31,12 @@ mod interface {
         type Error: From<StdError>;
         type QueryC: CustomQuery;
 
-        #[cfg(not(tarpaulin_include))]
         #[sv::msg(query)]
         fn interface_query(&self, ctx: QueryCtx<MyQuery>) -> StdResult<SomeResponse>;
 
-        #[cfg(not(tarpaulin_include))]
         #[sv::msg(exec)]
         fn interface_exec(&self, ctx: ExecCtx<MyQuery>) -> StdResult<Response>;
 
-        #[cfg(not(tarpaulin_include))]
         #[sv::msg(sudo)]
         fn interface_sudo(&self, ctx: SudoCtx<MyQuery>) -> StdResult<Response>;
     }
@@ -88,15 +85,12 @@ mod some_interface {
     pub trait SomeInterface {
         type Error: From<StdError>;
 
-        #[cfg(not(tarpaulin_include))]
         #[sv::msg(query)]
         fn some_interface_query(&self, ctx: QueryCtx<MyQuery>) -> StdResult<SomeResponse>;
 
-        #[cfg(not(tarpaulin_include))]
         #[sv::msg(exec)]
         fn some_interface_exec(&self, ctx: ExecCtx<MyQuery>) -> StdResult<Response>;
 
-        #[cfg(not(tarpaulin_include))]
         #[sv::msg(sudo)]
         fn some_interface_sudo(&self, ctx: SudoCtx<MyQuery>) -> StdResult<Response>;
     }
@@ -144,15 +138,12 @@ mod associated_type_interface {
         type Error: From<StdError>;
         type QueryC: CustomQuery;
 
-        #[cfg(not(tarpaulin_include))]
         #[sv::msg(query)]
         fn associated_query(&self, ctx: QueryCtx<Self::QueryC>) -> StdResult<SomeResponse>;
 
-        #[cfg(not(tarpaulin_include))]
         #[sv::msg(exec)]
         fn associated_exec(&self, ctx: ExecCtx<Self::QueryC>) -> StdResult<Response>;
 
-        #[cfg(not(tarpaulin_include))]
         #[sv::msg(sudo)]
         fn associated_sudo(&self, ctx: SudoCtx<Self::QueryC>) -> StdResult<Response>;
     }
@@ -199,15 +190,12 @@ mod default_query_interface {
     pub trait DefaultQueryInterface {
         type Error: From<StdError>;
 
-        #[cfg(not(tarpaulin_include))]
         #[sv::msg(query)]
         fn default_query(&self, ctx: QueryCtx) -> StdResult<SomeResponse>;
 
-        #[cfg(not(tarpaulin_include))]
         #[sv::msg(exec)]
         fn default_exec(&self, ctx: ExecCtx) -> StdResult<Response>;
 
-        #[cfg(not(tarpaulin_include))]
         #[sv::msg(sudo)]
         fn default_sudo(&self, ctx: SudoCtx) -> StdResult<Response>;
     }
diff --git a/sylvia/tests/dispatching.rs b/sylvia/tests/dispatching.rs
index 2f12750..1624d2a 100644
--- a/sylvia/tests/dispatching.rs
+++ b/sylvia/tests/dispatching.rs
@@ -149,7 +149,6 @@ mod contract {
 
     #[entry_points]
     #[allow(dead_code)]
-    #[cfg(not(tarpaulin_include))]
     #[contract]
     #[sv::messages(crate::interface)]
     impl Contract {
diff --git a/sylvia/tests/entry_points.rs b/sylvia/tests/entry_points.rs
index 1ba076d..81fcef5 100644
--- a/sylvia/tests/entry_points.rs
+++ b/sylvia/tests/entry_points.rs
@@ -146,7 +146,6 @@ mod contract {
         pub(crate) migrates: Item<'static, u32>,
     }
 
-    #[cfg(not(tarpaulin_include))]
     #[contract]
     #[sv::override_entry_point(sudo=crate::entry_points::sudo(crate::sudo::SudoWrapperMsg))]
     #[sv::override_entry_point(migrate=crate::entry_points::migrate(crate::migrate::MigrateMsg))]
diff --git a/sylvia/tests/messages_generation.rs b/sylvia/tests/messages_generation.rs
index 35e74d9..d76b485 100644
--- a/sylvia/tests/messages_generation.rs
+++ b/sylvia/tests/messages_generation.rs
@@ -59,7 +59,6 @@ mod contract {
 
     pub struct Contract {}
 
-    #[cfg(not(tarpaulin_include))]
     #[entry_points]
     #[contract]
     #[allow(dead_code)]
diff --git a/sylvia/tests/replies.rs b/sylvia/tests/replies.rs
index ddeb85a..4f75b3d 100644
--- a/sylvia/tests/replies.rs
+++ b/sylvia/tests/replies.rs
@@ -10,7 +10,6 @@ mod noop_contract {
 
     pub struct NoopContract;
 
-    #[cfg(not(tarpaulin_include))]
     #[contract]
     impl NoopContract {
         pub const fn new() -> Self {
@@ -40,7 +39,6 @@ mod reply_contract {
     pub struct ReplyContract;
 
     #[allow(dead_code)]
-    #[cfg(not(tarpaulin_include))]
     #[entry_points]
     #[contract]
     impl ReplyContract {