more tests

Author: sha0coder

crates/libmwemu/src/tests/banzai_mode_tests.rs

@@ -0,0 +1,93 @@
+
+#[test]
+fn test_banzai_initially_empty() {
+    let emu = crate::emu64();
+    
+    // Banzai should have no API params by default
+    // We test this by trying to get params for a non-existent function (which should panic)
+    // Since we can't test  panics easily here, we just verify the structure exists
+}
+
+#[test]
+fn test_banzai_add_function() {
+    let mut emu = crate::emu64();
+    
+    // Add a function to banazai list
+    emu.banzai_add("CreateFileA", 7);
+    
+    // Verify it was added by trying to get params
+    let params = emu.banzai.get_params("CreateFileA");
+    assert_eq!(params, 7, "Parameter count should match");
+}
+
+#[test]
+fn test_banzai_add_multiple_functions() {
+    let mut emu = crate::emu64();
+    
+    // Add multiple functions
+    emu.banzai_add("CreateFileA", 7);
+    emu.banzai_add("ReadFile", 5);
+    emu.banzai_add("WriteFile", 5);
+    
+    // Verify all were added
+    assert_eq!(emu.banzai.get_params("CreateFileA"), 7);
+    assert_eq!(emu.banzai.get_params("ReadFile"), 5);
+    assert_eq!(emu.banzai.get_params("WriteFile"), 5);
+}
+
+#[test]
+fn test_banzai_different_param_counts() {
+    let mut emu = crate::emu64();
+    
+    // Add functions with different parameter counts
+    emu.banzai_add("Func0", 0);
+    emu.banzai_add("Func1", 1);
+    emu.banzai_add("Func10", 10);
+    
+    assert_eq!(emu.banzai.get_params("Func0"), 0);
+    assert_eq!(emu.banzai.get_params("Func1"), 1);
+    assert_eq!(emu.banzai.get_params("Func10"), 10);
+}
+
+#[test]
+fn test_banzai_add_overwrite() {
+    let mut emu = crate::emu64();
+    
+    // Add a function
+    emu.banzai_add("TestFunc", 5);
+    assert_eq!(emu.banzai.get_params("TestFunc"), 5);
+    
+    // Add it again with different param count
+    emu.banzai_add("TestFunc", 10);
+    
+    // Should be overwritten
+    assert_eq!(emu.banzai.get_params("TestFunc"), 10, "Parameter count should be updated");
+}
+
+#[test]
+fn test_banzai_32bit_mode() {
+    let mut emu = crate::emu32();
+    
+    emu.banzai_add("TestFunc32", 3);
+    assert_eq!(emu.banzai.get_params("TestFunc32"), 3, "Banzai should work in 32-bit mode");
+}
+
+#[test]
+fn test_banzai_enable_works() {
+    let mut emu = crate::emu64();
+    
+    // enable_banzai and disable_banzai exist and should not panic
+    emu.enable_banzai();
+    emu.disable_banzai();
+}
+
+#[test]
+fn test_banzai_add_clears_previous() {
+    let mut emu = crate::emu64();
+    
+    emu.banzai_add("Func1", 1);
+    emu.banzai_add("Func2", 2);
+    
+    assert_eq!(emu.banzai.get_params("Func1"), 1);
+    assert_eq!(emu.banzai.get_params("Func2"), 2);
+}

crates/libmwemu/src/tests/config_tests.rs

@@ -0,0 +1,150 @@
+use crate::config::Config;
+
+#[test]
+fn test_config_default_values() {
+    let cfg = Config::new();
+    
+    // Test default values
+    assert!(!cfg.is_64bits, "Default should be 32-bit mode");
+    assert_eq!(cfg.verbose, 0, "Default verbose should be 0");
+}
+
+#[test]
+fn test_config_64bit_mode() {
+    let mut cfg = Config::new();
+    cfg.is_64bits = true;
+    
+    assert!(cfg.is_64bits, "Should be in 64-bit mode");
+}
+
+#[test]
+fn test_config_32bit_mode() {
+    let mut cfg = Config::new();
+    cfg.is_64bits = false;
+    
+    assert!(!cfg.is_64bits, "Should be in 32-bit mode");
+}
+
+#[test]
+fn test_config_verbose_levels() {
+    let mut cfg = Config::new();
+    
+    // Test different verbose levels
+    cfg.verbose = 0;
+    assert_eq!(cfg.verbose, 0);
+    
+    cfg.verbose = 1;
+    assert_eq!(cfg.verbose, 1);
+    
+    cfg.verbose = 2;
+    assert_eq!(cfg.verbose, 2);
+    
+    cfg.verbose = 3;
+    assert_eq!(cfg.verbose, 3);
+}
+
+#[test]
+fn test_config_console_default() {
+    let cfg = Config::new();
+    
+    // Check default console state (whatever it is)
+    let _console_state = cfg.console_enabled;
+}
+
+#[test]
+fn test_config_console_toggle() {
+    let mut cfg = Config::new();
+    
+    cfg.console_enabled = false;
+    assert!(!cfg.console_enabled);
+    
+    cfg.console_enabled = true;
+    assert!(cfg.console_enabled);
+}
+
+#[test]
+fn test_config_threading_disabled_by_default() {
+    let cfg = Config::new();
+    
+    assert!(!cfg.enable_threading, "Threading should be disabled by default");
+}
+
+#[test]
+fn test_config_threading_enable() {
+    let mut cfg = Config::new();
+    
+    cfg.enable_threading = true;
+    assert!(cfg.enable_threading, "Threading should be enabled");
+}
+
+#[test]
+fn test_config_multiple_settings() {
+    let mut cfg = Config::new();
+    
+    // Set multiple configuration options
+    cfg.is_64bits = true;
+    cfg.verbose = 2;
+    cfg.console_enabled = false;
+    cfg.enable_threading = true;
+    
+    // Verify all are set correctly
+    assert!(cfg.is_64bits);
+    assert_eq!(cfg.verbose, 2);
+    assert!(!cfg.console_enabled);
+    assert!(cfg.enable_threading);
+}
+
+#[test]
+fn test_emu64_default_config() {
+    let emu = crate::emu64();
+    
+    assert!(emu.cfg.is_64bits, "emu64() should create 64-bit emulator");
+}
+
+#[test]
+fn test_emu32_default_config() {
+    let emu = crate::emu32();
+    
+    assert!(!emu.cfg.is_64bits, "emu32() should create 32-bit emulator");
+}
+
+#[test]
+fn test_config_independence() {
+    let cfg1 = Config::new();
+    let mut cfg2 = Config::new();
+    
+    cfg2.verbose = 5;
+    
+    // cfg1 should not be affected
+    assert_eq!(cfg1.verbose, 0, "Configs should be independent");
+    assert_eq!(cfg2.verbose, 5);
+}
+
+#[test]
+fn test_set_config() {
+    let mut emu = crate::emu64();
+    
+    let mut custom_cfg = Config::new();
+    custom_cfg.verbose = 3;
+    custom_cfg.console_enabled = false;
+    
+    emu.set_config(custom_cfg);
+    
+    assert_eq!(emu.cfg.verbose, 3, "Custom config should be applied");
+    assert!(!emu.cfg.console_enabled, "Custom config should be applied");
+}
+
+#[test]
+fn test_config_verbose_range() {
+    let mut cfg = Config::new();
+    
+    // Test edge cases
+    cfg.verbose = 0;
+    assert_eq!(cfg.verbose, 0);
+    
+    cfg.verbose = 10;
+    assert_eq!(cfg.verbose, 10);
+    
+    cfg.verbose = 100;
+    assert_eq!(cfg.verbose, 100);
+}