205 lines
8.6 KiB
Rust
205 lines
8.6 KiB
Rust
use anvil::templates::{TemplateManager, TemplateContext};
|
|
use std::fs;
|
|
use tempfile::TempDir;
|
|
|
|
// ==========================================================================
|
|
// Mock Arduino: template file content verification
|
|
// ==========================================================================
|
|
|
|
#[test]
|
|
fn test_mock_arduino_header_has_core_api() {
|
|
let tmp = TempDir::new().unwrap();
|
|
let ctx = TemplateContext {
|
|
project_name: "mock_test".to_string(),
|
|
anvil_version: "1.0.0".to_string(),
|
|
board_name: "uno".to_string(),
|
|
fqbn: "arduino:avr:uno".to_string(),
|
|
baud: 115200,
|
|
};
|
|
TemplateManager::extract("basic", tmp.path(), &ctx).unwrap();
|
|
|
|
let header = fs::read_to_string(tmp.path().join("test/mocks/mock_arduino.h")).unwrap();
|
|
|
|
// Core Arduino constants
|
|
assert!(header.contains("#define INPUT"), "Should define INPUT");
|
|
assert!(header.contains("#define OUTPUT"), "Should define OUTPUT");
|
|
assert!(header.contains("#define HIGH"), "Should define HIGH");
|
|
assert!(header.contains("#define LOW"), "Should define LOW");
|
|
assert!(header.contains("#define LED_BUILTIN"), "Should define LED_BUILTIN");
|
|
assert!(header.contains("#define A0"), "Should define A0");
|
|
|
|
// Core Arduino functions (declarations use aligned whitespace)
|
|
assert!(header.contains("pinMode("), "Should declare pinMode");
|
|
assert!(header.contains("digitalWrite("), "Should declare digitalWrite");
|
|
assert!(header.contains("digitalRead("), "Should declare digitalRead");
|
|
assert!(header.contains("analogRead("), "Should declare analogRead");
|
|
assert!(header.contains("analogWrite("), "Should declare analogWrite");
|
|
assert!(header.contains("millis()"), "Should declare millis");
|
|
assert!(header.contains("delay("), "Should declare delay");
|
|
|
|
// Serial class
|
|
assert!(header.contains("class MockSerial"), "Should declare MockSerial");
|
|
assert!(header.contains("extern MockSerial Serial"), "Should declare global Serial");
|
|
|
|
// Test control API
|
|
assert!(header.contains("mock_arduino_reset()"), "Should have reset");
|
|
assert!(header.contains("mock_arduino_advance_millis("), "Should have advance_millis");
|
|
assert!(header.contains("mock_arduino_set_digital("), "Should have set_digital");
|
|
assert!(header.contains("mock_arduino_set_analog("), "Should have set_analog");
|
|
|
|
// String class
|
|
assert!(header.contains("class String"), "Should declare String class");
|
|
}
|
|
|
|
#[test]
|
|
fn test_mock_arduino_shims_exist() {
|
|
let tmp = TempDir::new().unwrap();
|
|
let ctx = TemplateContext {
|
|
project_name: "shim_test".to_string(),
|
|
anvil_version: "1.0.0".to_string(),
|
|
board_name: "uno".to_string(),
|
|
fqbn: "arduino:avr:uno".to_string(),
|
|
baud: 115200,
|
|
};
|
|
TemplateManager::extract("basic", tmp.path(), &ctx).unwrap();
|
|
|
|
// Arduino.h shim should include mock_arduino.h
|
|
let arduino_h = fs::read_to_string(tmp.path().join("test/mocks/Arduino.h")).unwrap();
|
|
assert!(
|
|
arduino_h.contains("mock_arduino.h"),
|
|
"Arduino.h shim should redirect to mock_arduino.h"
|
|
);
|
|
|
|
// Wire.h shim should provide MockWire
|
|
let wire_h = fs::read_to_string(tmp.path().join("test/mocks/Wire.h")).unwrap();
|
|
assert!(wire_h.contains("class MockWire"), "Wire.h should declare MockWire");
|
|
assert!(wire_h.contains("extern MockWire Wire"), "Wire.h should declare global Wire");
|
|
|
|
// SPI.h shim should provide MockSPI
|
|
let spi_h = fs::read_to_string(tmp.path().join("test/mocks/SPI.h")).unwrap();
|
|
assert!(spi_h.contains("class MockSPI"), "SPI.h should declare MockSPI");
|
|
assert!(spi_h.contains("extern MockSPI SPI"), "SPI.h should declare global SPI");
|
|
assert!(spi_h.contains("SPI_MODE0"), "SPI.h should define SPI modes");
|
|
assert!(spi_h.contains("struct SPISettings"), "SPI.h should define SPISettings");
|
|
}
|
|
|
|
#[test]
|
|
fn test_mock_arduino_all_files_ascii() {
|
|
let tmp = TempDir::new().unwrap();
|
|
let ctx = TemplateContext {
|
|
project_name: "ascii_mock".to_string(),
|
|
anvil_version: "1.0.0".to_string(),
|
|
board_name: "uno".to_string(),
|
|
fqbn: "arduino:avr:uno".to_string(),
|
|
baud: 115200,
|
|
};
|
|
TemplateManager::extract("basic", tmp.path(), &ctx).unwrap();
|
|
|
|
let mock_files = vec![
|
|
"test/mocks/mock_arduino.h",
|
|
"test/mocks/mock_arduino.cpp",
|
|
"test/mocks/Arduino.h",
|
|
"test/mocks/Wire.h",
|
|
"test/mocks/SPI.h",
|
|
];
|
|
|
|
for filename in &mock_files {
|
|
let content = fs::read_to_string(tmp.path().join(filename)).unwrap();
|
|
for (line_num, line) in content.lines().enumerate() {
|
|
for (col, ch) in line.chars().enumerate() {
|
|
assert!(
|
|
ch.is_ascii(),
|
|
"Non-ASCII in {} at {}:{}: '{}' (U+{:04X})",
|
|
filename, line_num + 1, col + 1, ch, ch as u32
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn test_cmake_links_mock_arduino() {
|
|
let tmp = TempDir::new().unwrap();
|
|
let ctx = TemplateContext {
|
|
project_name: "cmake_test".to_string(),
|
|
anvil_version: "1.0.0".to_string(),
|
|
board_name: "uno".to_string(),
|
|
fqbn: "arduino:avr:uno".to_string(),
|
|
baud: 115200,
|
|
};
|
|
TemplateManager::extract("basic", tmp.path(), &ctx).unwrap();
|
|
|
|
let cmake = fs::read_to_string(tmp.path().join("test/CMakeLists.txt")).unwrap();
|
|
|
|
// Should define mock_arduino library
|
|
assert!(cmake.contains("add_library(mock_arduino"), "Should define mock_arduino library");
|
|
assert!(cmake.contains("mock_arduino.cpp"), "Should compile mock_arduino.cpp");
|
|
|
|
// Both test targets should link mock_arduino
|
|
assert!(cmake.contains("target_link_libraries(test_unit"), "Should have test_unit target");
|
|
assert!(cmake.contains("target_link_libraries(test_system"), "Should have test_system target");
|
|
|
|
// System test target
|
|
assert!(cmake.contains("add_executable(test_system"), "Should build test_system");
|
|
assert!(cmake.contains("test_system.cpp"), "Should compile test_system.cpp");
|
|
|
|
// gtest discovery for both
|
|
assert!(cmake.contains("gtest_discover_tests(test_unit)"), "Should discover unit tests");
|
|
assert!(cmake.contains("gtest_discover_tests(test_system)"), "Should discover system tests");
|
|
}
|
|
|
|
#[test]
|
|
fn test_system_test_template_uses_simhal() {
|
|
let tmp = TempDir::new().unwrap();
|
|
let ctx = TemplateContext {
|
|
project_name: "sys_test".to_string(),
|
|
anvil_version: "1.0.0".to_string(),
|
|
board_name: "uno".to_string(),
|
|
fqbn: "arduino:avr:uno".to_string(),
|
|
baud: 115200,
|
|
};
|
|
TemplateManager::extract("basic", tmp.path(), &ctx).unwrap();
|
|
|
|
let system_test = fs::read_to_string(tmp.path().join("test/test_system.cpp")).unwrap();
|
|
|
|
// Should include mock_arduino and sim_hal
|
|
assert!(system_test.contains("mock_arduino.h"), "Should include mock_arduino.h");
|
|
assert!(system_test.contains("sim_hal.h"), "Should include sim_hal.h");
|
|
assert!(system_test.contains("sys_test_app.h"), "Should reference project app header");
|
|
|
|
// Should use SimHal, not MockHal
|
|
assert!(system_test.contains("SimHal"), "Should use SimHal for system tests");
|
|
|
|
// Should call mock_arduino_reset
|
|
assert!(system_test.contains("mock_arduino_reset()"), "Should reset mock state in SetUp");
|
|
}
|
|
|
|
#[test]
|
|
fn test_root_test_scripts_exist_and_reference_test_dir() {
|
|
let tmp = TempDir::new().unwrap();
|
|
let ctx = TemplateContext {
|
|
project_name: "script_test".to_string(),
|
|
anvil_version: "1.0.0".to_string(),
|
|
board_name: "uno".to_string(),
|
|
fqbn: "arduino:avr:uno".to_string(),
|
|
baud: 115200,
|
|
};
|
|
TemplateManager::extract("basic", tmp.path(), &ctx).unwrap();
|
|
|
|
// test.sh
|
|
let test_sh = fs::read_to_string(tmp.path().join("test.sh")).unwrap();
|
|
assert!(test_sh.contains("TEST_DIR="), "test.sh should set TEST_DIR");
|
|
assert!(test_sh.contains("cmake"), "test.sh should invoke cmake");
|
|
assert!(test_sh.contains("ctest"), "test.sh should invoke ctest");
|
|
assert!(test_sh.contains("--unit"), "test.sh should support --unit flag");
|
|
assert!(test_sh.contains("--system"), "test.sh should support --system flag");
|
|
assert!(test_sh.contains("--clean"), "test.sh should support --clean flag");
|
|
|
|
// test.bat
|
|
let test_bat = fs::read_to_string(tmp.path().join("test.bat")).unwrap();
|
|
assert!(test_bat.contains("TEST_DIR"), "test.bat should set TEST_DIR");
|
|
assert!(test_bat.contains("cmake"), "test.bat should invoke cmake");
|
|
assert!(test_bat.contains("ctest"), "test.bat should invoke ctest");
|
|
assert!(test_bat.contains("--unit"), "test.bat should support --unit flag");
|
|
assert!(test_bat.contains("--system"), "test.bat should support --system flag");
|
|
} |