loaders unit tests

src/loaders.rs

@@ -276,6 +276,7 @@ pub fn load_uninitialized_account<'a, 'info>(
     if !info.is_writable {
         return Err(ProgramError::InvalidAccountData);
     }
+
     Ok(())
 }
 
@@ -329,3 +330,942 @@ pub fn load_program<'a, 'info>(
 
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use solana_program::{
+        account_info::AccountInfo, keccak::Hash as KeccakHash, program_option::COption,
+        program_pack::Pack, pubkey::Pubkey, system_program,
+    };
+    use spl_token::state::{AccountState, Mint};
+
+    use crate::{
+        loaders::{
+            load_account, load_any_bus, load_bus, load_mint, load_proof, load_signer, load_sysvar,
+            load_token_account, load_treasury, load_uninitialized_account, load_uninitialized_pda,
+        },
+        state::{Bus, Proof, Treasury},
+        utils::Discriminator,
+        BUS, BUS_ADDRESSES, BUS_COUNT, MINT_ADDRESS, PROOF, TOKEN_DECIMALS, TREASURY,
+        TREASURY_ADDRESS,
+    };
+
+    use super::load_program;
+
+    #[test]
+    pub fn test_signer_not_signer() {
+        let key = Pubkey::new_unique();
+        let mut lamports = 1_000_000_000;
+        let mut data = [];
+        let owner = system_program::id();
+        let info = AccountInfo::new(
+            &key,
+            false,
+            false,
+            &mut lamports,
+            &mut data,
+            &owner,
+            false,
+            0,
+        );
+        assert!(load_signer(&info).is_err());
+    }
+
+    #[test]
+    pub fn test_load_bus_bad_account_owner() {
+        let key = BUS_ADDRESSES[0];
+        let mut lamports = 1_000_000_000;
+        let mut data = [];
+        let owner = system_program::id();
+        let info = AccountInfo::new(
+            &key,
+            false,
+            true,
+            &mut lamports,
+            &mut data,
+            &owner,
+            false,
+            0,
+        );
+        assert!(load_bus(&info, 0, true).is_err());
+    }
+
+    #[test]
+    pub fn test_load_bus_bad_key() {
+        let key = Pubkey::new_unique();
+        let mut lamports = 1_000_000_000;
+        let mut data = [];
+        let owner = crate::id();
+        let info = AccountInfo::new(
+            &key,
+            false,
+            true,
+            &mut lamports,
+            &mut data,
+            &owner,
+            false,
+            0,
+        );
+        assert!(load_bus(&info, 0, true).is_err());
+    }
+
+    #[test]
+    pub fn test_load_bus_empty_data() {
+        let key = BUS_ADDRESSES[0];
+        let mut lamports = 1_000_000_000;
+        let mut data = [];
+        let owner = crate::id();
+        let info = AccountInfo::new(
+            &key,
+            false,
+            true,
+            &mut lamports,
+            &mut data,
+            &owner,
+            false,
+            0,
+        );
+        assert!(load_bus(&info, 0, true).is_err());
+    }
+
+    #[test]
+    pub fn test_load_bus_bad_data() {
+        let key = BUS_ADDRESSES[0];
+        let mut lamports = 1_000_000_000;
+        let mut data = [
+            &(Treasury::discriminator() as u64).to_le_bytes(), // Bus discriminator
+            Bus { id: 0, rewards: 0 }.to_bytes(),
+        ]
+        .concat();
+        let owner = crate::id();
+        let info = AccountInfo::new(
+            &key,
+            false,
+            true,
+            &mut lamports,
+            &mut data,
+            &owner,
+            false,
+            0,
+        );
+        assert!(load_bus(&info, 0, true).is_err());
+    }
+
+    #[test]
+    pub fn test_load_bus_bad_id() {
+        let key = BUS_ADDRESSES[0];
+        let mut lamports = 1_000_000_000;
+        let mut data = [
+            &(Bus::discriminator() as u64).to_le_bytes(), // Bus discriminator
+            Bus { id: 1, rewards: 0 }.to_bytes(),
+        ]
+        .concat();
+        let owner = crate::id();
+        let info = AccountInfo::new(
+            &key,
+            false,
+            true,
+            &mut lamports,
+            &mut data,
+            &owner,
+            false,
+            0,
+        );
+        assert!(load_bus(&info, 0, true).is_err());
+    }
+
+    #[test]
+    pub fn test_load_bus_not_writeable() {
+        let key = BUS_ADDRESSES[0];
+        let mut lamports = 1_000_000_000;
+        let mut data = [
+            &(Bus::discriminator() as u64).to_le_bytes(),
+            Bus { id: 0, rewards: 0 }.to_bytes(),
+        ]
+        .concat();
+        let owner = crate::id();
+        let info = AccountInfo::new(
+            &key,
+            false,
+            false,
+            &mut lamports,
+            &mut data,
+            &owner,
+            false,
+            0,
+        );
+        assert!(load_bus(&info, 0, true).is_err());
+    }
+
+    #[test]
+    pub fn test_load_any_bus_bad_account_owner() {
+        let key = BUS_ADDRESSES[0];
+        let mut lamports = 1_000_000_000;
+        let mut data = [];
+        let owner = system_program::id();
+        let info = AccountInfo::new(
+            &key,
+            false,
+            true,
+            &mut lamports,
+            &mut data,
+            &owner,
+            false,
+            0,
+        );
+        assert!(load_any_bus(&info, true).is_err());
+    }
+
+    #[test]
+    pub fn test_load_any_bus_bad_key() {
+        let key = Pubkey::new_unique();
+        let mut lamports = 1_000_000_000;
+        let mut data = [];
+        let owner = crate::id();
+        let info = AccountInfo::new(
+            &key,
+            false,
+            true,
+            &mut lamports,
+            &mut data,
+            &owner,
+            false,
+            0,
+        );
+        assert!(load_any_bus(&info, true).is_err());
+    }
+
+    #[test]
+    pub fn test_load_any_bus_empty_data() {
+        let key = BUS_ADDRESSES[0];
+        let mut lamports = 1_000_000_000;
+        let mut data = [];
+        let owner = crate::id();
+        let info = AccountInfo::new(
+            &key,
+            false,
+            true,
+            &mut lamports,
+            &mut data,
+            &owner,
+            false,
+            0,
+        );
+        assert!(load_any_bus(&info, true).is_err());
+    }
+
+    #[test]
+    pub fn test_load_any_bus_bad_data() {
+        let key = BUS_ADDRESSES[0];
+        let mut lamports = 1_000_000_000;
+        let mut data = [
+            &(Treasury::discriminator() as u64).to_le_bytes(), // Treasury discriminator
+            Bus { id: 0, rewards: 0 }.to_bytes(),
+        ]
+        .concat();
+        let owner = crate::id();
+        let info = AccountInfo::new(
+            &key,
+            false,
+            true,
+            &mut lamports,
+            &mut data,
+            &owner,
+            false,
+            0,
+        );
+        assert!(load_any_bus(&info, true).is_err());
+    }
+
+    #[test]
+    pub fn test_load_any_bus_bad_id() {
+        let key = BUS_ADDRESSES[0];
+        let mut lamports = 1_000_000_000;
+        let mut data = [
+            &(Bus::discriminator() as u64).to_le_bytes(),
+            Bus {
+                id: (BUS_COUNT + 1) as u64,
+                rewards: 0,
+            }
+            .to_bytes(),
+        ]
+        .concat();
+        let owner = crate::id();
+        let info = AccountInfo::new(
+            &key,
+            false,
+            true,
+            &mut lamports,
+            &mut data,
+            &owner,
+            false,
+            0,
+        );
+        assert!(load_any_bus(&info, true).is_err());
+    }
+
+    #[test]
+    pub fn test_load_any_bus_mismatch_id() {
+        let key = BUS_ADDRESSES[0];
+        let mut lamports = 1_000_000_000;
+        let mut data = [
+            &(Bus::discriminator() as u64).to_le_bytes(),
+            Bus {
+                id: 1 as u64,
+                rewards: 0,
+            }
+            .to_bytes(),
+        ]
+        .concat();
+        let owner = crate::id();
+        let info = AccountInfo::new(
+            &key,
+            false,
+            true,
+            &mut lamports,
+            &mut data,
+            &owner,
+            false,
+            0,
+        );
+        assert!(load_any_bus(&info, true).is_err());
+    }
+
+    #[test]
+    pub fn test_load_any_bus_not_writeable() {
+        let key = BUS_ADDRESSES[0];
+        let mut lamports = 1_000_000_000;
+        let mut data = [
+            &(Bus::discriminator() as u64).to_le_bytes(),
+            Bus { id: 0, rewards: 0 }.to_bytes(),
+        ]
+        .concat();
+        let owner = crate::id();
+        let info = AccountInfo::new(
+            &key,
+            false,
+            false,
+            &mut lamports,
+            &mut data,
+            &owner,
+            false,
+            0,
+        );
+        assert!(load_any_bus(&info, true).is_err());
+    }
+
+    #[test]
+    pub fn test_load_proof_bad_account_owner() {
+        let authority = Pubkey::new_unique();
+        let pda = Pubkey::find_program_address(&[PROOF, authority.as_ref()], &crate::id());
+        let mut lamports = 1_000_000_000;
+        let mut data = [];
+        let owner = system_program::id();
+        let info = AccountInfo::new(
+            &pda.0,
+            false,
+            true,
+            &mut lamports,
+            &mut data,
+            &owner,
+            false,
+            0,
+        );
+        assert!(load_proof(&info, &authority, true).is_err());
+    }
+
+    #[test]
+    pub fn test_load_proof_bad_key() {
+        let key = Pubkey::new_unique();
+        let mut lamports = 1_000_000_000;
+        let mut data = [];
+        let owner = crate::id();
+        let info = AccountInfo::new(
+            &key,
+            false,
+            true,
+            &mut lamports,
+            &mut data,
+            &owner,
+            false,
+            0,
+        );
+        assert!(load_proof(&info, &Pubkey::new_unique(), true).is_err());
+    }
+
+    #[test]
+    pub fn test_load_proof_empty_data() {
+        let authority = Pubkey::new_unique();
+        let pda = Pubkey::find_program_address(&[PROOF, authority.as_ref()], &crate::id());
+        let mut lamports = 1_000_000_000;
+        let mut data = [];
+        let owner = crate::id();
+        let info = AccountInfo::new(
+            &pda.0,
+            false,
+            true,
+            &mut lamports,
+            &mut data,
+            &owner,
+            false,
+            0,
+        );
+        assert!(load_proof(&info, &authority, true).is_err());
+    }
+
+    #[test]
+    pub fn test_load_proof_bad_data() {
+        let authority = Pubkey::new_unique();
+        let pda = Pubkey::find_program_address(&[PROOF, authority.as_ref()], &crate::id());
+        let mut lamports = 1_000_000_000;
+        let mut data = [
+            &(Bus::discriminator() as u64).to_le_bytes(), // Bus discriminator
+            Proof {
+                authority,
+                claimable_rewards: 0,
+                hash: KeccakHash::new_from_array([u8::MAX; 32]).into(),
+                total_hashes: 0,
+                total_rewards: 0,
+            }
+            .to_bytes(),
+        ]
+        .concat();
+        let owner = crate::id();
+        let info = AccountInfo::new(
+            &pda.0,
+            false,
+            true,
+            &mut lamports,
+            &mut data,
+            &owner,
+            false,
+            0,
+        );
+        assert!(load_proof(&info, &authority, true).is_err());
+    }
+
+    #[test]
+    pub fn test_load_proof_not_writeable() {
+        let authority = Pubkey::new_unique();
+        let pda = Pubkey::find_program_address(&[PROOF, authority.as_ref()], &crate::id());
+        let mut lamports = 1_000_000_000;
+        let mut data = [
+            &(Proof::discriminator() as u64).to_le_bytes(),
+            Proof {
+                authority,
+                claimable_rewards: 0,
+                hash: KeccakHash::new_from_array([u8::MAX; 32]).into(),
+                total_hashes: 0,
+                total_rewards: 0,
+            }
+            .to_bytes(),
+        ]
+        .concat();
+        let owner = crate::id();
+        let info = AccountInfo::new(
+            &pda.0,
+            false,
+            false,
+            &mut lamports,
+            &mut data,
+            &owner,
+            false,
+            0,
+        );
+        assert!(load_proof(&info, &authority, true).is_err());
+    }
+
+    #[test]
+    pub fn test_load_treasury_bad_account_owner() {
+        let pda = Pubkey::find_program_address(&[TREASURY], &crate::id());
+        let mut lamports = 1_000_000_000;
+        let mut data = [];
+        let owner = system_program::id();
+        let info = AccountInfo::new(
+            &pda.0,
+            false,
+            true,
+            &mut lamports,
+            &mut data,
+            &owner,
+            false,
+            0,
+        );
+        assert!(load_treasury(&info, true).is_err());
+    }
+
+    #[test]
+    pub fn test_load_treasury_bad_key() {
+        let key = Pubkey::new_unique();
+        let mut lamports = 1_000_000_000;
+        let mut data = [];
+        let owner = crate::id();
+        let info = AccountInfo::new(
+            &key,
+            false,
+            true,
+            &mut lamports,
+            &mut data,
+            &owner,
+            false,
+            0,
+        );
+        assert!(load_treasury(&info, true).is_err());
+    }
+
+    #[test]
+    pub fn test_load_treasury_empty_data() {
+        let key = TREASURY_ADDRESS;
+        let mut lamports = 1_000_000_000;
+        let mut data = [];
+        let owner = crate::id();
+        let info = AccountInfo::new(
+            &key,
+            false,
+            true,
+            &mut lamports,
+            &mut data,
+            &owner,
+            false,
+            0,
+        );
+        assert!(load_treasury(&info, true).is_err());
+    }
+
+    #[test]
+    pub fn test_load_treasury_bad_data() {
+        let pda = Pubkey::find_program_address(&[TREASURY], &crate::id());
+        let mut lamports = 1_000_000_000;
+        let mut data = [
+            &(Bus::discriminator() as u64).to_le_bytes(), // Bus discriminator
+            Treasury {
+                bump: pda.1 as u64,
+                admin: Pubkey::new_unique(),
+                difficulty: KeccakHash::new_from_array([u8::MAX; 32]).into(),
+                last_reset_at: 0,
+                reward_rate: 100,
+                total_claimed_rewards: 0,
+            }
+            .to_bytes(),
+        ]
+        .concat();
+        let owner = crate::id();
+        let info = AccountInfo::new(
+            &pda.0,
+            false,
+            true,
+            &mut lamports,
+            &mut data,
+            &owner,
+            false,
+            0,
+        );
+        assert!(load_treasury(&info, true).is_err());
+    }
+
+    #[test]
+    pub fn test_load_treasury_not_writeable() {
+        let pda = Pubkey::find_program_address(&[TREASURY], &crate::id());
+        let mut lamports = 1_000_000_000;
+        let mut data = [
+            &(Treasury::discriminator() as u64).to_le_bytes(),
+            Treasury {
+                bump: pda.1 as u64,
+                admin: Pubkey::new_unique(),
+                difficulty: KeccakHash::new_from_array([u8::MAX; 32]).into(),
+                last_reset_at: 0,
+                reward_rate: 100,
+                total_claimed_rewards: 0,
+            }
+            .to_bytes(),
+        ]
+        .concat();
+        let owner = crate::id();
+        let info = AccountInfo::new(
+            &pda.0,
+            false,
+            false,
+            &mut lamports,
+            &mut data,
+            &owner,
+            false,
+            0,
+        );
+        assert!(load_treasury(&info, true).is_err());
+    }
+
+    #[test]
+    pub fn test_load_mint_bad_account_owner() {
+        let key = MINT_ADDRESS;
+        let mut lamports = 1_000_000_000;
+        let mut data = [];
+        let owner = system_program::id();
+        let info = AccountInfo::new(
+            &key,
+            false,
+            true,
+            &mut lamports,
+            &mut data,
+            &owner,
+            false,
+            0,
+        );
+        assert!(load_token_account(&info, None, &MINT_ADDRESS, true).is_err());
+    }
+
+    #[test]
+    pub fn test_load_mint_bad_key() {
+        let key = Pubkey::new_unique();
+        let mut lamports = 1_000_000_000;
+        let mut data = [];
+        let owner = spl_token::id();
+        let info = AccountInfo::new(
+            &key,
+            false,
+            true,
+            &mut lamports,
+            &mut data,
+            &owner,
+            false,
+            0,
+        );
+        assert!(load_mint(&info, true).is_err());
+    }
+
+    #[test]
+    pub fn test_load_mint_empty_data() {
+        let key = MINT_ADDRESS;
+        let mut lamports = 1_000_000_000;
+        let mut data = [];
+        let owner = spl_token::id();
+        let info = AccountInfo::new(
+            &key,
+            false,
+            true,
+            &mut lamports,
+            &mut data,
+            &owner,
+            false,
+            0,
+        );
+        assert!(load_mint(&info, true).is_err());
+    }
+
+    #[test]
+    pub fn test_load_mint_bad_data() {
+        let key = MINT_ADDRESS;
+        let mut lamports = 1_000_000_000;
+        let mut data = [1];
+        let owner = spl_token::id();
+        let info = AccountInfo::new(
+            &key,
+            false,
+            true,
+            &mut lamports,
+            &mut data,
+            &owner,
+            false,
+            0,
+        );
+        assert!(load_mint(&info, true).is_err());
+    }
+
+    #[test]
+    pub fn test_load_mint_not_writeable() {
+        let mut data: [u8; Mint::LEN] = [0; Mint::LEN];
+        Mint {
+            mint_authority: COption::Some(TREASURY_ADDRESS),
+            supply: 0,
+            decimals: TOKEN_DECIMALS,
+            is_initialized: true,
+            freeze_authority: COption::None,
+        }
+        .pack_into_slice(&mut data);
+        let key = MINT_ADDRESS;
+        let mut lamports = 1_000_000_000;
+        let owner = spl_token::id();
+        let info = AccountInfo::new(
+            &key,
+            false,
+            false,
+            &mut lamports,
+            &mut data,
+            &owner,
+            false,
+            0,
+        );
+        assert!(load_mint(&info, true).is_err());
+    }
+
+    #[test]
+    pub fn test_load_token_account_bad_account_owner() {
+        let mut data: [u8; spl_token::state::Account::LEN] = [0; spl_token::state::Account::LEN];
+        spl_token::state::Account {
+            mint: MINT_ADDRESS,
+            owner: TREASURY_ADDRESS,
+            amount: 2_000_000_000,
+            delegate: COption::None,
+            state: AccountState::Initialized,
+            is_native: COption::None,
+            delegated_amount: 0,
+            close_authority: COption::None,
+        }
+        .pack_into_slice(&mut data);
+        let key = Pubkey::new_unique();
+        let mut lamports = 1_000_000_000;
+        let owner = system_program::id();
+        let info = AccountInfo::new(
+            &key,
+            false,
+            true,
+            &mut lamports,
+            &mut data,
+            &owner,
+            false,
+            0,
+        );
+        assert!(load_token_account(&info, None, &MINT_ADDRESS, true).is_err());
+    }
+
+    #[test]
+    pub fn test_load_token_account_empty_data() {
+        let key = Pubkey::new_unique();
+        let mut lamports = 1_000_000_000;
+        let mut data = [];
+        let owner = spl_token::id();
+        let info = AccountInfo::new(
+            &key,
+            false,
+            true,
+            &mut lamports,
+            &mut data,
+            &owner,
+            false,
+            0,
+        );
+        assert!(load_token_account(&info, None, &MINT_ADDRESS, true).is_err());
+    }
+
+    #[test]
+    pub fn test_load_token_account_bad_data() {
+        let key = Pubkey::new_unique();
+        let mut lamports = 1_000_000_000;
+        let mut data = [1];
+        let owner = spl_token::id();
+        let info = AccountInfo::new(
+            &key,
+            false,
+            true,
+            &mut lamports,
+            &mut data,
+            &owner,
+            false,
+            0,
+        );
+        assert!(load_token_account(&info, None, &MINT_ADDRESS, true).is_err());
+    }
+
+    #[test]
+    pub fn test_load_token_account_bad_owner_mint() {
+        let mut data: [u8; spl_token::state::Account::LEN] = [0; spl_token::state::Account::LEN];
+        spl_token::state::Account {
+            mint: MINT_ADDRESS,
+            owner: TREASURY_ADDRESS,
+            amount: 2_000_000_000,
+            delegate: COption::None,
+            state: AccountState::Initialized,
+            is_native: COption::None,
+            delegated_amount: 0,
+            close_authority: COption::None,
+        }
+        .pack_into_slice(&mut data);
+        let key = Pubkey::new_unique();
+        let mut lamports = 1_000_000_000;
+        let owner = spl_token::id();
+        let info = AccountInfo::new(
+            &key,
+            false,
+            false,
+            &mut lamports,
+            &mut data,
+            &owner,
+            false,
+            0,
+        );
+        assert!(load_token_account(&info, Some(&key), &MINT_ADDRESS, false).is_err());
+        assert!(load_token_account(&info, None, &Pubkey::new_unique(), false).is_err());
+        assert!(load_token_account(&info, None, &MINT_ADDRESS, true).is_err());
+    }
+
+    #[test]
+    pub fn test_load_uninitialized_pda_bad_key_bump() {
+        let pda = Pubkey::find_program_address(&[TREASURY], &crate::id());
+        let mut lamports = 1_000_000_000;
+        let mut data = [];
+        let owner = system_program::id();
+        let info = AccountInfo::new(
+            &pda.0,
+            false,
+            true,
+            &mut lamports,
+            &mut data,
+            &owner,
+            false,
+            0,
+        );
+        assert!(load_uninitialized_pda(&info, &[BUS], pda.1, &crate::id()).is_err());
+        assert!(load_uninitialized_pda(&info, &[TREASURY], 0, &crate::id()).is_err());
+    }
+
+    #[test]
+    pub fn test_load_uninitialized_account_bad_owner() {
+        let key = Pubkey::new_unique();
+        let mut lamports = 1_000_000_000;
+        let mut data = [];
+        let owner = spl_token::id();
+        let info = AccountInfo::new(
+            &key,
+            false,
+            true,
+            &mut lamports,
+            &mut data,
+            &owner,
+            false,
+            0,
+        );
+        assert!(load_uninitialized_account(&info).is_err());
+    }
+
+    #[test]
+    pub fn test_load_uninitialized_account_data_not_empty() {
+        let key = Pubkey::new_unique();
+        let mut lamports = 1_000_000_000;
+        let mut data = [0];
+        let owner = system_program::id();
+        let info = AccountInfo::new(
+            &key,
+            false,
+            true,
+            &mut lamports,
+            &mut data,
+            &owner,
+            false,
+            0,
+        );
+        assert!(load_uninitialized_account(&info).is_err());
+    }
+
+    #[test]
+    pub fn test_load_uninitialized_account_not_writeable() {
+        let key = Pubkey::new_unique();
+        let mut lamports = 1_000_000_000;
+        let mut data = [];
+        let owner = system_program::id();
+        let info = AccountInfo::new(
+            &key,
+            false,
+            false,
+            &mut lamports,
+            &mut data,
+            &owner,
+            false,
+            0,
+        );
+        assert!(load_uninitialized_account(&info).is_err());
+    }
+
+    #[test]
+    pub fn test_load_sysvar_bad_owner() {
+        let key = Pubkey::new_unique();
+        let mut lamports = 1_000_000_000;
+        let mut data = [];
+        let owner = system_program::id();
+        let info = AccountInfo::new(
+            &key,
+            false,
+            false,
+            &mut lamports,
+            &mut data,
+            &owner,
+            false,
+            0,
+        );
+        assert!(load_sysvar(&info, key).is_err());
+    }
+
+    #[test]
+    pub fn test_load_account_bad_key() {
+        let key = Pubkey::new_unique();
+        let mut lamports = 1_000_000_000;
+        let mut data = [];
+        let owner = system_program::id();
+        let info = AccountInfo::new(
+            &key,
+            false,
+            false,
+            &mut lamports,
+            &mut data,
+            &owner,
+            false,
+            0,
+        );
+        assert!(load_account(&info, Pubkey::new_unique(), false).is_err());
+    }
+
+    #[test]
+    pub fn test_load_account_not_writeable() {
+        let key = Pubkey::new_unique();
+        let mut lamports = 1_000_000_000;
+        let mut data = [];
+        let owner = system_program::id();
+        let info = AccountInfo::new(
+            &key,
+            false,
+            false,
+            &mut lamports,
+            &mut data,
+            &owner,
+            false,
+            0,
+        );
+        assert!(load_account(&info, key, true).is_err());
+    }
+
+    #[test]
+    pub fn test_load_program_bad_key() {
+        let key = Pubkey::new_unique();
+        let mut lamports = 1_000_000_000;
+        let mut data = [];
+        let owner = system_program::id();
+        let info = AccountInfo::new(
+            &key,
+            false,
+            false,
+            &mut lamports,
+            &mut data,
+            &owner,
+            true,
+            0,
+        );
+        assert!(load_program(&info, Pubkey::new_unique()).is_err());
+    }
+
+    #[test]
+    pub fn test_load_program_not_executable() {
+        let key = Pubkey::new_unique();
+        let mut lamports = 1_000_000_000;
+        let mut data = [];
+        let owner = system_program::id();
+        let info = AccountInfo::new(
+            &key,
+            false,
+            false,
+            &mut lamports,
+            &mut data,
+            &owner,
+            false,
+            0,
+        );
+        assert!(load_program(&info, key).is_err());
+    }
+}