Make generated contracts testable if #[cfg(test)] is set about ink HOT 4 CLOSED

#[doc(hidden)]
mod hidden {
    fn instantiate_impl() -> impl TestableContract<DeployArgs = u32> {
        ContractDecl::using::<Adder>()
            .on_deploy(|env, init_val| {
                env.state.val.set(init_val)
            })
            .on_msg_mut::<Inc>(|env, by| {
                env.state.val += by
            })
            .on_msg::<Get>(|env, _| {
                *env.state.val
            })
            .instantiate()
    }
}

#[cfg(not(test))]
fn instantiate() -> impl Contract {
    hidden::instantiate_impl()
}

#[cfg(test)]
fn instantiate() -> impl TestableContract<DeployArgs = u32> {
    hidden::instantiate_impl()
}

#![no_std]

use pdsl_core::storage;
use pdsl_lang::contract;

contract! {
    /// This simple dummy contract has a `bool` value that can
    /// alter between `true` and `false` using the `flip` message.
    /// Users can retrieve its current state using the `get` message.
    struct Flipper {
        /// The current state of our flag.
        value: storage::Value<bool>,
    }

    impl Deploy for Flipper {
        /// Initializes our state to `false` upon deploying our smart contract.
        fn deploy(&mut self) {
            self.value.set(false)
        }
    }

    impl Flipper {
        /// Flips the current state of our smart contract.
        pub(external) fn flip(&mut self) {
            if *self.value {
                self.value.set(false)
            } else {
                self.value.set(true)
            }
        }

        /// Returns the current state.
        pub(external) fn get(&self) -> bool {
            *self.value
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn it_works() {
        let mut flipper = Flipper::instantiate();
        assert_eq!(flipper.get(), false);
        flipper.flip();
        assert_eq!(flipper.get(), true);
    }
}

pdsl_model::state! {
    /// This simple dummy contract has a `bool` value that can
    /// alter between `true` and `false` using the `flip` message.
    /// Users can retrieve its current state using the `get` message.
    struct Flipper {
        /// The current state of our flag.
        value: storage::Value<bool>,
    }
}

use pdsl_model::messages;

pdsl_model::messages! {
        /// Flips the current state of our smart contract.
    0 => Flip();
        /// Returns the current state.
    1 => Get() -> bool;
}

#[cfg(test)]
impl Flipper {
    /// Returns a testable version of the contract.
    pub fn instantiate() -> TestableFlipper {
        TestableFlipper::instantiate()
    }
}

impl Flipper {
    /// Initializes our state to `false` upon deploying our smart contract.
    pub fn deploy(&mut self, env: &mut pdsl_model::EnvHandler) {
        self.value.set(false)
    }

    /// Flips the current state of our smart contract.
    pub fn flip(&mut self, env: &mut pdsl_model::EnvHandler) {
        if *self.value {
            *self.value = false
        } else {
            *self.value = true
        }
    }

    /// Returns the current state.
    pub fn get(&self, env: &pdsl_model::EnvHandler) -> bool {
        *self.value
    }
}

impl Flipper {}

use pdsl_model::Contract;

#[cfg(test)]
struct TestableFlipper {
    env: pdsl_model::ExecutionEnv<Flipper>,
}

#[cfg(test)]
impl TestableFlipper {
    pub fn instantiate() -> Self {
        Self {
            env: unsafe {
                let mut alloc = BumpAlloc::from_raw_parts(Key([0x0; 32]));
                AllocateUsing::allocate_using(&mut alloc)
            }
        }
    }
}

#[cfg(test)]
impl TestableFlipper {
    /// Automatically called when the contract is deployed.
    pub fn deploy(&mut self, init_value: u32) {
        let (handler, state) = self.env.split_mut();
        state.deploy(handler, init_value)
    }
}

#[cfg(test)]
impl TestableFlipper {
    /// Flips the current state of our smart contract.
    pub fn flip(&mut self) {
        let (handler, state) = self.env.split_mut();
        state.flip(handler, by)
    }

    /// Returns the current state.
    pub fn get(&self) -> bool {
        let (handler, state) = self.env.split();
        state.get(handler,)
    }
}

#[cfg(not(test))]
fn instantiate() -> impl pdsl_model::Contract {
    pdsl_model::ContractDecl::using::<Flipper>()
        .on_deploy(|env| {
            let (handler, state) = env.split_mut();
            state.deploy(handler, init_value)
        })
        .on_msg_mut::<Flip>(|env, _| {
            let (handler, state) = env.split_mut();
            state.flip(handler, by)
        })
        .on_msg::<Get>(|env, _| {
            let (handler, state) = env.split();
            state.get(handler,)
        })
        .instantiate()
}

#[cfg(not(test))] #[no_mangle] fn deploy() { instantiate().deploy() }
#[cfg(not(test))] #[no_mangle] fn call() { instantiate().dispatch() }