//! > Test expansion of a contract with imported Event.

//! > test_runner_name
ExpandContractTestRunner(expect_diagnostics: false)

//! > cairo_code
#[derive(Drop, starknet::Event)]
enum Event {
    AwesomeEvent: AwesomeEvent,
    BestEventEver: BestEventEver,
}
#[derive(Drop, starknet::Event)]
struct AwesomeEvent {}
#[derive(Drop, starknet::Event)]
struct BestEventEver {}

#[starknet::contract]
mod test_contract {
    #[event]
    use super::Event;

    #[storage]
    struct Storage {}

    fn emit_event(ref self: ContractState) {
        self.emit(Event::AwesomeEvent(super::AwesomeEvent {}));
    }
}

//! > generated_cairo_code
lib.cairo:

#[derive(Drop, starknet::Event)]
enum Event {
    AwesomeEvent: AwesomeEvent,
    BestEventEver: BestEventEver,
}
#[derive(Drop, starknet::Event)]
struct AwesomeEvent {}
#[derive(Drop, starknet::Event)]
struct BestEventEver {}

#[starknet::contract]
mod test_contract {
    #[event]
    use super::Event;

    #[storage]
    struct Storage {}

    fn emit_event(ref self: ContractState) {
        self.emit(Event::AwesomeEvent(super::AwesomeEvent {}));
    }
}

lib.cairo:1:10
#[derive(Drop, starknet::Event)]
         ^^^^
impls:

impl EventDrop<> of core::traits::Drop::<Event>;


lib.cairo:1:16
#[derive(Drop, starknet::Event)]
               ^^^^^^^^^^^^^^^
starknet_derive:

impl EventIsEvent of starknet::Event<Event> {
    fn append_keys_and_data(
        self: @Event, ref keys: Array<felt252>, ref data: Array<felt252>
    ) {
        match self {
            Event::AwesomeEvent(val) => {
                core::array::ArrayTrait::append(ref keys, selector!("AwesomeEvent"));
                starknet::Event::append_keys_and_data(
                    val, ref keys, ref data
                );
            },
            Event::BestEventEver(val) => {
                core::array::ArrayTrait::append(ref keys, selector!("BestEventEver"));
                starknet::Event::append_keys_and_data(
                    val, ref keys, ref data
                );
            },
        }
    }
    fn deserialize(
        ref keys: Span<felt252>, ref data: Span<felt252>,
    ) -> Option<Event> {
        let __selector__ = *core::array::SpanTrait::pop_front(ref keys)?;
        if __selector__ == selector!("AwesomeEvent") {
                let val = starknet::Event::deserialize(
                    ref keys, ref data
                )?;
                return Option::Some(Event::AwesomeEvent(val));
        }
        if __selector__ == selector!("BestEventEver") {
                let val = starknet::Event::deserialize(
                    ref keys, ref data
                )?;
                return Option::Some(Event::BestEventEver(val));
        }
        Option::None
    }
}
impl EventAwesomeEventIntoEvent of Into<AwesomeEvent, Event> {
    fn into(self: AwesomeEvent) -> Event {
        Event::AwesomeEvent(self)
    }
}
impl EventBestEventEverIntoEvent of Into<BestEventEver, Event> {
    fn into(self: BestEventEver) -> Event {
        Event::BestEventEver(self)
    }
}



lib.cairo:6:10
#[derive(Drop, starknet::Event)]
         ^^^^
impls:

impl AwesomeEventDrop<> of core::traits::Drop::<AwesomeEvent>;


lib.cairo:6:16
#[derive(Drop, starknet::Event)]
               ^^^^^^^^^^^^^^^
starknet_derive:

impl AwesomeEventIsEvent of starknet::Event<AwesomeEvent> {
    fn append_keys_and_data(
        self: @AwesomeEvent, ref keys: Array<felt252>, ref data: Array<felt252>
    ) {
    }
    fn deserialize(
        ref keys: Span<felt252>, ref data: Span<felt252>,
    ) -> Option<AwesomeEvent> {
        Option::Some(AwesomeEvent {})
    }
}


lib.cairo:8:10
#[derive(Drop, starknet::Event)]
         ^^^^
impls:

impl BestEventEverDrop<> of core::traits::Drop::<BestEventEver>;


lib.cairo:8:16
#[derive(Drop, starknet::Event)]
               ^^^^^^^^^^^^^^^
starknet_derive:

impl BestEventEverIsEvent of starknet::Event<BestEventEver> {
    fn append_keys_and_data(
        self: @BestEventEver, ref keys: Array<felt252>, ref data: Array<felt252>
    ) {
    }
    fn deserialize(
        ref keys: Span<felt252>, ref data: Span<felt252>,
    ) -> Option<BestEventEver> {
        Option::Some(BestEventEver {})
    }
}


lib.cairo:11:1
#[starknet::contract]
^^^^^^^^^^^^^^^^^^^^^
contract:



#[phantom]
pub struct Storage {
}

#[derive(Drop, Copy)]
#[doc(hidden)]
pub struct StorageStorageBase {
}
#[doc(hidden)]
impl StorageStorageImpl of starknet::storage::StorageTrait<Storage> {
    type BaseType = StorageStorageBase;
    fn storage(self: starknet::storage::FlattenedStorage<Storage>) -> StorageStorageBase {
        StorageStorageBase {
        }
    }
}
#[derive(Drop, Copy)]
#[doc(hidden)]
pub struct StorageStorageBaseMut {
}
#[doc(hidden)]
impl StorageStorageMutImpl of starknet::storage::StorageTraitMut<Storage> {
    type BaseType = StorageStorageBaseMut;
    fn storage_mut(self: starknet::storage::FlattenedStorage<starknet::storage::Mutable::<Storage>>) -> StorageStorageBaseMut {
        StorageStorageBaseMut {
        }
    }
}

pub struct ContractState {
}

impl ContractStateDrop of Drop<ContractState> {}

impl ContractStateDeref of core::ops::Deref<@ContractState> {
    type Target = starknet::storage::FlattenedStorage<Storage>;
    fn deref(self: @ContractState) -> starknet::storage::FlattenedStorage<Storage> {
        starknet::storage::FlattenedStorage {}
    }
}
impl ContractStateDerefMut of core::ops::DerefMut<ContractState> {
    type Target = starknet::storage::FlattenedStorage<starknet::storage::Mutable<Storage>> ;
    fn deref_mut(ref self: ContractState) -> starknet::storage::FlattenedStorage<starknet::storage::Mutable<Storage>> {
        starknet::storage::FlattenedStorage {}
    }
}
pub fn unsafe_new_contract_state() -> ContractState {
    ContractState {
    }
}
#[cfg(target: 'test')]
#[inline(always)]
pub fn contract_state_for_testing() -> ContractState {
    unsafe_new_contract_state()
}

// TODO(Gil): This generates duplicate diagnostics because of the plugin system, squash the duplicates into one.
#[deprecated(
    feature: "deprecated_legacy_map",
    note: "Use `starknet::storage::Map` instead."
)]
#[allow(unused_imports)]
use starknet::storage::Map as LegacyMap;
#[cfg(target: 'test')]
pub const TEST_CLASS_HASH: starknet::ClassHash = 0x32ff02b6abf104297a08971d16f6970b6530be8e49a83bde923ea117b47a37e.try_into().unwrap();


#[doc(hidden)]
pub mod __external {
}
#[doc(hidden)]
pub mod __l1_handler {
}
#[doc(hidden)]
pub mod __constructor {
}
    impl ContractStateEventEmitter of starknet::event::EventEmitter<
        ContractState, Event
    > {
        fn emit<S, impl IntoImp: core::traits::Into<S, Event>>(
            ref self: ContractState, event: S
        ) {
            let event: Event = core::traits::Into::into(event);
            let mut keys = Default::<core::array::Array>::default();
            let mut data = Default::<core::array::Array>::default();
            starknet::Event::append_keys_and_data(@event, ref keys, ref data);
            starknet::SyscallResultTrait::unwrap_syscall(
                starknet::syscalls::emit_event_syscall(
                    core::array::ArrayTrait::span(@keys),
                    core::array::ArrayTrait::span(@data),
                )
            )
        }
    }



lib.cairo:16:5
    #[storage]
    ^^^^^^^^^^
impls:

#[doc(hidden)]
impl StorageStorageBaseDrop<> of core::traits::Drop::<StorageStorageBase>;
#[doc(hidden)]
impl StorageStorageBaseCopy<> of core::traits::Copy::<StorageStorageBase>;


lib.cairo:16:5
    #[storage]
    ^^^^^^^^^^
impls:

#[doc(hidden)]
impl StorageStorageBaseMutDrop<> of core::traits::Drop::<StorageStorageBaseMut>;
#[doc(hidden)]
impl StorageStorageBaseMutCopy<> of core::traits::Copy::<StorageStorageBaseMut>;

//! > expected_diagnostics
