diff --git a/Cargo.lock b/Cargo.lock
index f4b2279a1d..f1fb54c03d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -2035,6 +2035,7 @@ dependencies = [
  "solana-bpfloader 0.12.0",
  "solana-logger 0.12.0",
  "solana-native-loader 0.12.0",
+ "solana-runtime 0.12.0",
  "solana-sdk 0.12.0",
 ]
 
diff --git a/programs/bpf/Cargo.toml b/programs/bpf/Cargo.toml
index 0dc42c545f..0f1da2c9d8 100644
--- a/programs/bpf/Cargo.toml
+++ b/programs/bpf/Cargo.toml
@@ -22,4 +22,5 @@ solana = { path = "../../core", version = "0.12.0" }
 solana-bpfloader = { path = "../bpf_loader", version = "0.12.0" }
 solana-logger = { path = "../../logger", version = "0.12.0" }
 solana-native-loader = { path = "../native_loader", version = "0.12.0" }
+solana-runtime = { path = "../../runtime", version = "0.12.0" }
 solana-sdk = { path = "../../sdk", version = "0.12.0" }
diff --git a/programs/bpf/tests/programs.rs b/programs/bpf/tests/programs.rs
index 2ae46265d4..2aa4a3960d 100644
--- a/programs/bpf/tests/programs.rs
+++ b/programs/bpf/tests/programs.rs
@@ -1,137 +1,148 @@
-#[cfg(feature = "bpf_c")]
-use solana_sdk::bpf_loader;
 #[cfg(any(feature = "bpf_c", feature = "bpf_rust"))]
-use std::env;
-#[cfg(any(feature = "bpf_c", feature = "bpf_rust"))]
-use std::fs::File;
-#[cfg(any(feature = "bpf_c", feature = "bpf_rust"))]
-use std::io::Read;
-#[cfg(any(feature = "bpf_c", feature = "bpf_rust"))]
-use std::path::PathBuf;
+mod bpf {
+    use solana_runtime::bank::Bank;
+    use solana_runtime::loader_utils::load_program;
+    use solana_sdk::genesis_block::GenesisBlock;
+    use solana_sdk::native_loader;
+    use solana_sdk::transaction::Transaction;
+    use std::env;
+    use std::fs::File;
+    use std::path::PathBuf;
 
-/// BPF program file extension
-#[cfg(any(feature = "bpf_c", feature = "bpf_rust"))]
-const PLATFORM_FILE_EXTENSION_BPF: &str = "so";
-/// Create a BPF program file name
-#[cfg(any(feature = "bpf_c", feature = "bpf_rust"))]
-fn create_bpf_path(name: &str) -> PathBuf {
-    let mut pathbuf = {
-        let current_exe = env::current_exe().unwrap();
-        PathBuf::from(current_exe.parent().unwrap().parent().unwrap())
-    };
-    pathbuf.push("bpf/");
-    pathbuf.push(name);
-    pathbuf.set_extension(PLATFORM_FILE_EXTENSION_BPF);
-    pathbuf
-}
+    /// BPF program file extension
+    const PLATFORM_FILE_EXTENSION_BPF: &str = "so";
 
-#[cfg(feature = "bpf_c")]
-#[test]
-fn test_program_bpf_c_noop() {
-    solana_logger::setup();
+    /// Create a BPF program file name
+    fn create_bpf_path(name: &str) -> PathBuf {
+        let mut pathbuf = {
+            let current_exe = env::current_exe().unwrap();
+            PathBuf::from(current_exe.parent().unwrap().parent().unwrap())
+        };
+        pathbuf.push("bpf/");
+        pathbuf.push(name);
+        pathbuf.set_extension(PLATFORM_FILE_EXTENSION_BPF);
+        pathbuf
+    }
 
-    let mut file = File::open(create_bpf_path("noop")).expect("file open failed");
-    let mut elf = Vec::new();
-    file.read_to_end(&mut elf).unwrap();
+    #[cfg(feature = "bpf_c")]
+    mod bpf_c {
+        use super::*;
+        use solana_sdk::bpf_loader;
+        use std::io::Read;
 
-    let (genesis_block, mint_keypair) = GenesisBlock::new(50);
-    let bank = Bank::new(&genesis_block);
+        #[test]
+        fn test_program_bpf_c_noop() {
+            solana_logger::setup();
 
-    // Call user program
-    let program_id = load_program(&bank, &mint_keypair, bpf_loader::id(), elf);
-    let tx = Transaction::new(
-        &mint_keypair,
-        &[],
-        program_id,
-        &vec![1u8],
-        bank.last_blockhash(),
-        0,
-    );
-    bank.process_transaction(&tx).unwrap();
-    assert_eq!(bank.get_signature_status(&tx.signatures[0]), Some(Ok(())));
-}
+            let mut file = File::open(create_bpf_path("noop")).expect("file open failed");
+            let mut elf = Vec::new();
+            file.read_to_end(&mut elf).unwrap();
 
-#[cfg(feature = "bpf_c")]
-#[test]
-fn test_program_bpf_c() {
-    solana_logger::setup();
+            let (genesis_block, mint_keypair) = GenesisBlock::new(50);
+            let bank = Bank::new(&genesis_block);
 
-    let programs = [
-        "bpf_to_bpf",
-        "multiple_static",
-        "noop",
-        "noop++",
-        "relative_call",
-        "struct_pass",
-        "struct_ret",
-    ];
-    for program in programs.iter() {
-        println!("Test program: {:?}", program);
-        let mut file = File::open(create_bpf_path(program)).expect("file open failed");
-        let mut elf = Vec::new();
-        file.read_to_end(&mut elf).unwrap();
+            // Call user program
+            let program_id = load_program(&bank, &mint_keypair, bpf_loader::id(), elf);
+            let tx = Transaction::new(
+                &mint_keypair,
+                &[],
+                program_id,
+                &vec![1u8],
+                bank.last_blockhash(),
+                0,
+            );
+            bank.process_transaction(&tx).unwrap();
+            assert_eq!(bank.get_signature_status(&tx.signatures[0]), Some(Ok(())));
+        }
 
-        let (genesis_block, mint_keypair) = GenesisBlock::new(50);
-        let bank = Bank::new(&genesis_block);
+        #[test]
+        fn test_program_bpf_c() {
+            solana_logger::setup();
 
-        let loader_id = load_program(
-            &bank,
-            &mint_keypair,
-            native_loader::id(),
-            "solana_bpf_loader".as_bytes().to_vec(),
-        );
+            let programs = [
+                "bpf_to_bpf",
+                "multiple_static",
+                "noop",
+                "noop++",
+                "relative_call",
+                "struct_pass",
+                "struct_ret",
+            ];
+            for program in programs.iter() {
+                println!("Test program: {:?}", program);
+                let mut file = File::open(create_bpf_path(program)).expect("file open failed");
+                let mut elf = Vec::new();
+                file.read_to_end(&mut elf).unwrap();
 
-        // Call user program
-        let program_id = load_program(&bank, &mint_keypair, loader_id, elf);
-        let tx = Transaction::new(
-            &mint_keypair,
-            &[],
-            program_id,
-            &vec![1u8],
-            bank.last_blockhash(),
-            0,
-        );
-        bank.process_transaction(&tx).unwrap();
-        assert_eq!(bank.get_signature_status(&tx.signatures[0]), Some(Ok(())));
-    }
-}
-
-// Cannot currently build the Rust BPF program as part
-// of the rest of the build due to recursive `cargo build` causing
-// a build deadlock.  Therefore you must build the Rust programs
-// yourself first by calling `make all` in the Rust BPF program's directory
-#[cfg(feature = "bpf_rust")]
-#[test]
-fn test_program_bpf_rust() {
-    solana_logger::setup();
-
-    let programs = ["solana_bpf_rust_noop"];
-    for program in programs.iter() {
-        println!("Test program: {:?}", program);
-        let mut file = File::open(create_bpf_path(program)).expect("file open failed");
-        let mut elf = Vec::new();
-        file.read_to_end(&mut elf).unwrap();
-
-        let (genesis_block, mint_keypair) = GenesisBlock::new(50);
-        let bank = Bank::new(&genesis_block);
-        let loader_id = load_program(
-            &bank,
-            &mint_keypair,
-            native_loader::id(),
-            "solana_bpf_loader".as_bytes().to_vec(),
-        );
-
-        // Call user program
-        let program_id = load_program(&bank, &mint_keypair, loader_id, elf);
-        let tx = Transaction::new(
-            &mint_keypair,
-            &[],
-            program_id,
-            &vec![1u8],
-            bank.last_blockhash(),
-            0,
-        );
-        bank.process_transaction(&tx).unwrap();
-        assert_eq!(bank.get_signature_status(&tx.signatures[0]), Some(Ok(())));
+                let (genesis_block, mint_keypair) = GenesisBlock::new(50);
+                let bank = Bank::new(&genesis_block);
+
+                let loader_id = load_program(
+                    &bank,
+                    &mint_keypair,
+                    native_loader::id(),
+                    "solana_bpf_loader".as_bytes().to_vec(),
+                );
+
+                // Call user program
+                let program_id = load_program(&bank, &mint_keypair, loader_id, elf);
+                let tx = Transaction::new(
+                    &mint_keypair,
+                    &[],
+                    program_id,
+                    &vec![1u8],
+                    bank.last_blockhash(),
+                    0,
+                );
+                bank.process_transaction(&tx).unwrap();
+                assert_eq!(bank.get_signature_status(&tx.signatures[0]), Some(Ok(())));
+            }
+        }
+    }
+
+    // Cannot currently build the Rust BPF program as part
+    // of the rest of the build due to recursive `cargo build` causing
+    // a build deadlock.  Therefore you must build the Rust programs
+    // yourself first by calling `make all` in the Rust BPF program's directory
+    #[cfg(feature = "bpf_rust")]
+    mod bpf_rust {
+        use super::*;
+        use std::io::Read;
+
+        #[test]
+        fn test_program_bpf_rust() {
+            solana_logger::setup();
+
+            let programs = ["solana_bpf_rust_noop"];
+            for program in programs.iter() {
+                let filename = create_bpf_path(program);
+                println!("Test program: {:?} from {:?}", program, filename);
+                let mut file = File::open(filename).unwrap();
+                let mut elf = Vec::new();
+                file.read_to_end(&mut elf).unwrap();
+
+                let (genesis_block, mint_keypair) = GenesisBlock::new(50);
+                let bank = Bank::new(&genesis_block);
+                let loader_id = load_program(
+                    &bank,
+                    &mint_keypair,
+                    native_loader::id(),
+                    "solana_bpf_loader".as_bytes().to_vec(),
+                );
+
+                // Call user program
+                let program_id = load_program(&bank, &mint_keypair, loader_id, elf);
+                let tx = Transaction::new(
+                    &mint_keypair,
+                    &[],
+                    program_id,
+                    &vec![1u8],
+                    bank.last_blockhash(),
+                    0,
+                );
+                bank.process_transaction(&tx).unwrap();
+                assert_eq!(bank.get_signature_status(&tx.signatures[0]), Some(Ok(())));
+            }
+        }
     }
 }