#[public]
pub fn init(_: Context, _addr: Address) {
    //
}

#[public]
pub fn init2(_: Context) {
    //
}

    #[test]
    fn init_program() {
        let simulator = simulator::Client::new();

        let owner_key = String::from("owner");
        let [alice_key, bob_key] = ["alice", "bob"]
            .map(String::from)
            .map(Key::Ed25519)
            .map(Param::Key);

        let mut plan = Plan::new(owner_key.clone());

        plan.add_step(Step::create_key(Key::Ed25519(owner_key)));

        let program_id = plan.add_step(Step {
            endpoint: Endpoint::Execute,
            method: "program_create".into(),
            max_units: 1000000,
            params: vec![Param::String(PROGRAM_PATH.into())],
            require: None,
        });

        plan.add_step(Step {
            endpoint: Endpoint::Execute,
            method: "init2".into(),
            max_units: 10000000000,
            params: vec![program_id.into()],
            require: None,
        });

        plan.add_step(Step {
            endpoint: Endpoint::Execute,
            method: "init".into(),
            max_units: 10000000000,
            params: vec![program_id.into(), alice_key.clone()],
            require: None,
        });

        // run plan
        let plan_responses = simulator.run_plan(&plan).unwrap();

        // ensure no errors
        assert!(
            plan_responses.iter().all(|resp| resp.error.is_none()),
            "error: {:?}",
            plan_responses
                .iter()
                .filter_map(|resp| resp.error.as_ref())
                .next()
        );
    }

        plan.add_step(Step {
            endpoint: Endpoint::Key,
            method: "key_create".into(),
            params: vec![alice_key.clone()],
            max_units: 0,
            require: None,
        });