test: add DriverSuper unit tests

[sksat (sksat)]

Summary

• DriverSuper の StreamRecBuffer とフレーム解析関数の unit test を追加
• GoogleTest (C++) を cargo test 経由で実行できる仕組みを導入
• 75 テストケース（StreamRecBuffer: 46、FrameAnalysis: 29）

変更内容

• component_driver/ を Rust crate 化し、cargo test --workspace でテスト実行可能に
• build.rs で CMake ビルド + ctest からテスト一覧を取得し、個別の Rust テストとして公開
• StreamRecBuffer: push/drop/confirm/move_forward 等の基本操作とエッジケース
• FrameAnalysis: 固定長/可変長フレーム、ヘッダ/フッタ有無の組み合わせ、分割受信等

Test plan

• cargo test -p c2a-core-component-driver で 75 tests pass
• CI (rust.yml) で cargo test --workspace が通ることを確認

🤖 Generated with Claude Code

[Copilot]

Pull request overview

This PR adds comprehensive unit testing infrastructure for the C2A DriverSuper component, introducing 75 GoogleTest (C++) test cases wrapped in a Rust crate for integration with cargo test. The implementation uses a custom build.rs script to invoke CMake, build the C++ tests, and generate Rust test wrappers that execute individual GoogleTest cases.

Changes:

• Added 46 test cases for StreamRecBuffer covering push/drop/confirm/move operations and edge cases
• Added 29 test cases for FrameAnalysis covering fixed-length, variable-length, and footer-terminated frame protocols
• Created Rust build system integration to run C++ tests via cargo test

Reviewed changes

Copilot reviewed 12 out of 13 changed files in this pull request and generated 12 comments.

Show a summary per file

File	Description
component_driver/tests/test_stream_rec_buffer.cpp	Comprehensive tests for buffer management operations; embeds production code (critical issue)
component_driver/tests/test_frame_analysis.cpp	Tests for frame parsing with multiple protocol patterns; embeds production code (critical issue)
component_driver/tests/mocks/*.{h,c}	Mock implementations for HAL, TimeManager, and CCP dependencies
component_driver/tests/CMakeLists.txt	CMake configuration for building GoogleTest tests
component_driver/build.rs	Build script to invoke CMake and generate Rust test wrappers
component_driver/Cargo.toml	Package definition; missing build.rs reference (critical issue)
component_driver/src/lib.rs	Library entry point that includes generated tests
Cargo.toml	Workspace member addition

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

The test file embeds the production implementation of StreamRecBuffer functions directly (lines 57-153). This creates several problems:

1. The tests are not testing the actual production code, but rather a copy of it
2. Code duplication means the embedded code can drift from the real implementation
3. Changes to the production code won't be caught by these tests
4. It's unclear whether the embedded implementation matches the current production code

Instead, these tests should link against the actual driver_super.c implementation. The CMakeLists.txt should be updated to compile driver_super.c and link it with the test executables.

Suggested change

	{
	if (stream_rec_buffer == NULL) return CDS_ERR_CODE_ERR;
	if (buffer == NULL) return CDS_ERR_CODE_ERR;
	if (size == 0) return CDS_ERR_CODE_OK;
	if (stream_rec_buffer->size + size > stream_rec_buffer->capacity)
	return CDS_ERR_CODE_ERR;
	memcpy(stream_rec_buffer->buffer + stream_rec_buffer->size, buffer, size);
	stream_rec_buffer->size += size;
	return CDS_ERR_CODE_OK;
	}
	uint16_t CDS_get_unprocessed_size_from_stream_rec_buffer_(CDS_StreamRecBuffer* stream_rec_buffer)
	{
	if (stream_rec_buffer == NULL) return 0;
	uint16_t processed = stream_rec_buffer->pos_of_frame_head_candidate +
	stream_rec_buffer->confirmed_frame_len;
	if (processed >= stream_rec_buffer->size) return 0;
	return stream_rec_buffer->size - processed;
	}
	void CDS_confirm_stream_rec_buffer_(CDS_StreamRecBuffer* stream_rec_buffer, uint16_t size)
	{
	if (stream_rec_buffer == NULL) return;
	stream_rec_buffer->confirmed_frame_len = size;
	}
	void CDS_move_forward_frame_head_candidate_of_stream_rec_buffer_(CDS_StreamRecBuffer* stream_rec_buffer,
	uint16_t size)
	{
	if (stream_rec_buffer == NULL) return;
	stream_rec_buffer->pos_of_frame_head_candidate += size;
	stream_rec_buffer->confirmed_frame_len = 0;
	if (stream_rec_buffer->pos_of_frame_head_candidate > stream_rec_buffer->size)
	stream_rec_buffer->pos_of_frame_head_candidate = stream_rec_buffer->size;
	}
	;
	extern CDS_ERR_CODE CDS_rec_stream_buffer_(CDS_StreamRecBuffer* stream_rec_buffer,
	const uint8_t* buffer,
	uint16_t size);
	extern uint16_t CDS_get_unprocessed_size_from_stream_rec_buffer_(CDS_StreamRecBuffer* stream_rec_buffer);
	extern void CDS_confirm_stream_rec_buffer_(CDS_StreamRecBuffer* stream_rec_buffer, uint16_t size);
	extern void CDS_move_forward_frame_head_candidate_of_stream_rec_buffer_(CDS_StreamRecBuffer* stream_rec_buffer,
	uint16_t size);

[Copilot]

The type definitions and constants (lines 14-44) are duplicated from the production code rather than included from the actual header files. This duplication can lead to:

1. Type mismatches if the production types change
2. Maintenance burden keeping definitions in sync
3. Potential for subtle bugs if sizes or layouts differ

These definitions should be included from the actual header files (e.g., driver_super.h) to ensure consistency with the production code.

[Copilot]

The type definitions (lines 26-99) are duplicated from production code rather than included from actual header files. This creates maintenance issues:

1. Type definitions can drift from the production implementation
2. Changes to production types won't be caught by tests
3. Potential for struct layout mismatches

These definitions should be included from the actual header files (e.g., driver_super.h) to ensure type consistency and avoid duplication.

Suggested change

	// 型定義
	// ================================================================
	typedef enum {
	ENDIAN_TYPE_BIG,
	ENDIAN_TYPE_LITTLE,
	ENDIAN_TYPE_UNKNOWN
	} ENDIAN_TYPE;
	#define CDS_STREAM_MAX (3)
	#define CDS_HAL_RX_BUFFER_SIZE (256)
	typedef struct
	{
	uint8_t* buffer;
	uint16_t capacity;
	uint16_t size;
	uint16_t pos_of_frame_head_candidate;
	uint16_t confirmed_frame_len;
	uint8_t is_frame_fixed;
	uint16_t pos_of_last_rec;
	} CDS_StreamRecBuffer;
	typedef enum
	{
	CDS_ERR_CODE_OK = 0,
	CDS_ERR_CODE_ERR = 1
	} CDS_ERR_CODE;
	typedef enum
	{
	CDS_STREAM_REC_STATUS_FINDING_HEADER,
	CDS_STREAM_REC_STATUS_RECEIVING_HEADER,
	CDS_STREAM_REC_STATUS_RECEIVING_FRAMELENGTH,
	CDS_STREAM_REC_STATUS_RECEIVING_DATA,
	CDS_STREAM_REC_STATUS_RECEIVING_FOOTER,
	CDS_STREAM_REC_STATUS_FIXED_FRAME,
	CDS_STREAM_REC_STATUS_DISABLE,
	CDS_STREAM_REC_STATUS_HEADER_MISMATCH,
	CDS_STREAM_REC_STATUS_FOOTER_MISMATCH,
	CDS_STREAM_REC_STATUS_RX_FRAME_TOO_LONG,
	CDS_STREAM_REC_STATUS_RX_FRAME_TOO_SHORT,
	CDS_STREAM_REC_STATUS_RX_ERR,
	CDS_STREAM_REC_STATUS_VALIDATE_ERR,
	CDS_STREAM_REC_STATUS_OTHER_ERR
	} CDS_STREAM_REC_STATUS_CODE;
	typedef struct
	{
	CDS_STREAM_REC_STATUS_CODE status_code;
	uint16_t fixed_frame_len;
	uint8_t tlm_disruption_status;
	uint32_t count_of_carry_over_failures;
	} CDS_StreamRecStatus;
	// CDS_StreamConfig の簡易版（テストに必要な部分のみ）
	typedef struct CDS_StreamConfig {
	struct {
	uint8_t is_enabled_;
	uint8_t is_strict_frame_search_;
	CDS_StreamRecBuffer* rx_buffer_;
	const uint8_t* rx_header_;
	uint16_t rx_header_size_;
	const uint8_t* rx_footer_;
	uint16_t rx_footer_size_;
	int16_t rx_frame_size_;
	uint16_t max_rx_frame_size_;
	int16_t rx_framelength_pos_;
	uint16_t rx_framelength_type_size_;
	uint16_t rx_framelength_offset_;
	ENDIAN_TYPE rx_framelength_endian_;
	} settings;
	struct {
	CDS_StreamRecStatus rec_status_;
	} info;
	} CDS_StreamConfig;
	// 型定義: 本番コードのヘッダからインクルードして重複を回避
	// ================================================================
	#include "driver_super.h"

[Copilot]

The test suite name parsing logic (lines 88-92) assumes test names follow the "SuiteTest.TestCase" pattern and strips the "Test" suffix. However, this logic will fail or produce incorrect names if:

1. The suite name doesn't end with "Test" (returns the original suite name)
2. The test name doesn't contain a dot (defaults to "test")
3. The suite name contains "Test" in the middle (e.g., "TestingFramework" becomes "ingFramework")

Consider adding validation or logging when the expected pattern isn't matched, and handle edge cases more robustly.

Suggested change

	// "Test" サフィックスを除去
	let suite = suite.strip_suffix("Test").unwrap_or(suite);
	format!("test_{}", camel_to_snake(suite))
	} else {
	// "Test" サフィックスを除去（末尾に "Test" がない場合はそのまま利用）
	let (suite_without_suffix, had_suffix) = if let Some(stripped) = suite.strip_suffix("Test") {
	(stripped, true)
	} else {
	(suite, false)
	};
	if !had_suffix {
	eprintln!(
	"Warning: expected test suite name to end with 'Test', but got '{suite}' in test '{test_name}'. Using full suite name for binary inference."
	);
	}
	format!("test_{}", camel_to_snake(suite_without_suffix))
	} else {
	eprintln!(
	"Warning: test name '{test_name}' does not contain a '.', defaulting test binary name to 'test'."
	);

[Copilot]

The test case at line 471 tests pushing data with a NULL buffer pointer. While NULL safety is good to test, the test expectation is unclear:

The function signature suggests CDS_push_to_stream_rec_buffer_(&rec_buffer_, nullptr, 10) should fail because the buffer pointer is NULL. However, the test doesn't verify that rec_buffer_ itself is properly initialized before the call.

Consider adding a comment explaining the expected behavior, or split this into separate test cases:

1. Push with NULL buffer parameter
2. Push with NULL stream_rec_buffer pointer

Suggested change

	TEST_F(StreamRecBufferTest, NullPointerSafety) {
	// これらの関数は NULL チェックで早期リターンする
	CDS_clear_stream_rec_buffer_(nullptr);
	CDS_drop_from_stream_rec_buffer_(nullptr, 10);
	CDS_confirm_stream_rec_buffer_(nullptr, 10);
	CDS_move_forward_frame_head_candidate_of_stream_rec_buffer_(nullptr, 10);
	EXPECT_EQ(0, CDS_get_unprocessed_size_from_stream_rec_buffer_(nullptr));
	TEST_F(StreamRecBufferTest, NullPointerSafety) {
	// rec_buffer_ 自体は有効なバッファとして初期化しておく
	CDS_init_stream_rec_buffer(&rec_buffer_, buffer_, BUFFER_SIZE);
	// これらの関数は NULL チェックで早期リターンする
	CDS_clear_stream_rec_buffer_(nullptr);
	CDS_drop_from_stream_rec_buffer_(nullptr, 10);
	CDS_confirm_stream_rec_buffer_(nullptr, 10);
	CDS_move_forward_frame_head_candidate_of_stream_rec_buffer_(nullptr, 10);
	EXPECT_EQ(0, CDS_get_unprocessed_size_from_stream_rec_buffer_(nullptr));
	// NULL の stream_rec_buffer* および NULL のデータバッファはいずれもエラーを返すことを確認

[Copilot]

The test file embeds the production implementation of frame analysis functions directly (lines 105-596). This has the same critical issues as in test_stream_rec_buffer.cpp:

1. Tests are not validating the actual production code
2. Code duplication creates maintenance burden
3. Implementation drift between test copy and production code
4. No guarantee the embedded code matches the actual implementation

The CMakeLists.txt should be updated to compile and link the actual driver_super.c source file instead of duplicating the implementation in test files.

[Copilot]

The camel_to_snake conversion function has a potential issue: it doesn't handle consecutive uppercase letters correctly. For example, "HTTPServer" would become "h_t_t_p_server" instead of the more idiomatic "http_server".

Consider using a more robust conversion that handles acronyms properly, such as:

• Only insert underscore if the previous character was lowercase
• Or use a well-tested conversion library

Suggested change

	for (i, c) in s.chars().enumerate() {
	if c.is_uppercase() {
	if i > 0 {
	result.push('_');
	}
	result.push(c.to_lowercase().next().unwrap());
	} else {
	result.push(c);
	}
	}
	let chars: Vec<char> = s.chars().collect();
	for (i, &c) in chars.iter().enumerate() {
	if c.is_uppercase() {
	if i > 0 {
	let prev = chars[i - 1];
	let next_is_lowercase = chars
	.get(i + 1)
	.map(|n| n.is_lowercase())
	.unwrap_or(false);
	if prev.is_lowercase() || next_is_lowercase {
	result.push('_');
	}
	}
	for lc in c.to_lowercase() {
	result.push(lc);
	}
	} else {
	result.push(c);
	}
	}

[Copilot]

The panic messages on build failures (lines 38, 49) don't include the actual error output from cmake/cmake --build. This makes debugging build failures difficult.

Consider capturing and displaying stderr in the panic message to provide more context when builds fail:

.output().expect("cmake configure failed");
if !result.status.success() {
    eprintln!("{}", String::from_utf8_lossy(&result.stderr));
    panic!("cmake configure failed");
}

Suggested change

	let configure_status = Command::new("cmake")
	.args([tests_dir.to_str().unwrap(), "-DCMAKE_BUILD_TYPE=Debug"])
	.current_dir(&build_dir)
	.status()
	.expect("cmake configure failed");
	if !configure_status.success() {
	panic!("cmake configure failed with status: {}", configure_status);
	}
	// CMake build
	let build_status = Command::new("cmake")
	.args(["--build", ".", "-j"])
	.current_dir(&build_dir)
	.status()
	.expect("cmake build failed");
	if !build_status.success() {
	panic!("cmake build failed with status: {}", build_status);
	let configure_output = Command::new("cmake")
	.args([tests_dir.to_str().unwrap(), "-DCMAKE_BUILD_TYPE=Debug"])
	.current_dir(&build_dir)
	.output()
	.expect("failed to run cmake configure");
	if !configure_output.status.success() {
	let stderr = String::from_utf8_lossy(&configure_output.stderr);
	panic!(
	"cmake configure failed with status: {}. Stderr:\n{}",
	configure_output.status, stderr
	);
	}
	// CMake build
	let build_output = Command::new("cmake")
	.args(["--build", ".", "-j"])
	.current_dir(&build_dir)
	.output()
	.expect("failed to run cmake build");
	if !build_output.status.success() {
	let stderr = String::from_utf8_lossy(&build_output.stderr);
	panic!(
	"cmake build failed with status: {}. Stderr:\n{}",
	build_output.status, stderr
	);

[Copilot]

The include directories configuration (lines 25-29, 45-49) uses relative paths with ".." which makes the build structure fragile. If the directory layout changes, these paths will break.

Consider using CMake variables to make the paths more robust:

set(C2A_ROOT_DIR ${CMAKE_CURRENT_SOURCE_DIR}/../..)
target_include_directories(test_stream_rec_buffer PRIVATE
  ${CMAKE_CURRENT_SOURCE_DIR}
  ${CMAKE_CURRENT_SOURCE_DIR}/..
  ${C2A_ROOT_DIR}
)

This makes the intent clearer and easier to maintain.

[Copilot]

The generated test wrapper doesn't pass through test output in real-time. The output is only shown if the test fails (lines 107-109). This means:

1. Users don't see test progress during long-running tests
2. Debugging hangs or timeouts is difficult
3. The test output format doesn't match typical cargo test output

Consider using .spawn() and streaming output instead of .output(), or add an option to show output for all tests during development.

Suggested change

	let output = std::process::Command::new(&binary)
	.arg("--gtest_filter={test_name}")
	.output()
	.expect("failed to run test binary");
	if !output.status.success() {{
	eprintln!("{{}}", String::from_utf8_lossy(&output.stdout));
	eprintln!("{{}}", String::from_utf8_lossy(&output.stderr));
	panic!("C++ test {test_name} failed");
	}}
	let status = std::process::Command::new(&binary)
	.arg("--gtest_filter={test_name}")
	.stdout(std::process::Stdio::inherit())
	.stderr(std::process::Stdio::inherit())
	.status()
	.expect("failed to run test binary");
	assert!(status.success(), "C++ test {test_name} failed");