Complete CLI test coverage with 12 new comprehensive tests

Device-Independent Tests (+7):
- VerboseOption: --verbose flag
- InvalidYUVConversion tests (3): Error handling for missing dimensions, format, non-existent files
- ConvertI420ToImage tests (2): I420 Red and Green color conversion validation

Device-Dependent Tests (+6):
- CaptureWithOutputFormat: --format option
- CaptureWithFPS: --fps option
- CaptureWithTimeout: --timeout option
- CaptureInvalidDevice: Invalid device handling
- CaptureWithVerbose: Verbose capture
- ShowDeviceInfoAll: All devices info

Coverage: 25 tests (13 device-independent + 12 device-dependent)
All tests passing.

Author: wysaid

tests/test_ccap_cli.cpp

@@ -187,6 +187,26 @@ RGB readBMPPixel(const fs::path& bmpPath, int x, int y) {
     return pixel;
 }
 
+// Helper to create a solid color YUV I420 image
+void createSolidColorI420(const fs::path& path, int width, int height, uint8_t y, uint8_t u, uint8_t v) {
+    std::ofstream file(path, std::ios::binary);
+    if (!file.is_open()) {
+        throw std::runtime_error("Failed to create YUV file");
+    }
+    
+    // Y plane
+    std::vector<uint8_t> yPlane(width * height, y);
+    file.write(reinterpret_cast<const char*>(yPlane.data()), yPlane.size());
+    
+    // U plane
+    std::vector<uint8_t> uPlane((width / 2) * (height / 2), u);
+    file.write(reinterpret_cast<const char*>(uPlane.data()), uPlane.size());
+    
+    // V plane
+    std::vector<uint8_t> vPlane((width / 2) * (height / 2), v);
+    file.write(reinterpret_cast<const char*>(vPlane.data()), vPlane.size());
+}
+
 // Test fixture for device-independent tests
 class CCAPCLITest : public ::testing::Test {
 protected:
@@ -264,6 +284,57 @@ TEST_F(CCAPCLITest, NoArgumentsShowsHelp) {
 //     EXPECT_NE(result.exitCode, 0);
 // }
 
+TEST_F(CCAPCLITest, VerboseOption) {
+    // Test that verbose flag is accepted
+    auto result = runCLI("--verbose --help");
+    EXPECT_EQ(result.exitCode, 0);
+    EXPECT_THAT(result.output, ::testing::HasSubstr("Usage:"));
+}
+
+TEST_F(CCAPCLITest, InvalidYUVConversion_MissingDimensions) {
+    // Create a dummy YUV file
+    fs::path yuvPath = testOutputDir / "test.yuv";
+    createSolidColorNV12(yuvPath, 64, 64, 128, 128, 128);
+    
+    // Try to convert without specifying dimensions (should fail)
+    fs::path outputPath = testOutputDir / "output.bmp";
+    std::string cmd = "--convert " + yuvPath.string() + 
+                      " --yuv-format nv12" +
+                      " --convert-output " + outputPath.string();
+    
+    auto result = runCLI(cmd);
+    // Should fail or handle gracefully
+    EXPECT_NE(result.exitCode, 0) << "Should fail without YUV dimensions";
+}
+
+TEST_F(CCAPCLITest, InvalidYUVConversion_MissingFormat) {
+    // Create a dummy YUV file
+    fs::path yuvPath = testOutputDir / "test.yuv";
+    createSolidColorNV12(yuvPath, 64, 64, 128, 128, 128);
+    
+    // Try to convert without specifying format (should fail)
+    fs::path outputPath = testOutputDir / "output.bmp";
+    std::string cmd = "--convert " + yuvPath.string() + 
+                      " --yuv-width 64 --yuv-height 64" +
+                      " --convert-output " + outputPath.string();
+    
+    auto result = runCLI(cmd);
+    // Should fail or handle gracefully
+    EXPECT_NE(result.exitCode, 0) << "Should fail without YUV format";
+}
+
+TEST_F(CCAPCLITest, InvalidYUVConversion_NonExistentFile) {
+    // Try to convert a non-existent file
+    fs::path yuvPath = testOutputDir / "nonexistent.yuv";
+    fs::path outputPath = testOutputDir / "output.bmp";
+    std::string cmd = "--convert " + yuvPath.string() + 
+                      " --yuv-format nv12 --yuv-width 64 --yuv-height 64" +
+                      " --convert-output " + outputPath.string();
+    
+    auto result = runCLI(cmd);
+    EXPECT_NE(result.exitCode, 0) << "Should fail for non-existent input file";
+}
+
 // ============================================================================
 // Device-Dependent Tests (requires camera)
 // ============================================================================
@@ -371,6 +442,105 @@ TEST_F(CCAPCLIDeviceTest, CaptureWithInternalFormat) {
     ASSERT_GT(imageCount, 0) << "No image files created";
 }
 
+TEST_F(CCAPCLIDeviceTest, CaptureWithOutputFormat) {
+    std::string outputDir = testOutputDir.string();
+    auto result = runCLI("-d 0 -c 1 --format rgb24 -o " + outputDir);
+    
+    // Camera exists, capture MUST succeed
+    ASSERT_EQ(result.exitCode, 0) << "Capture command failed: " << result.output;
+    
+    // Verify image file was created
+    int imageCount = 0;
+    for (const auto& entry : fs::directory_iterator(testOutputDir)) {
+        if (entry.path().extension() == ".bmp") {
+            imageCount++;
+        }
+    }
+    
+    ASSERT_EQ(imageCount, 1) << "Expected 1 image file, found " << imageCount;
+}
+
+TEST_F(CCAPCLIDeviceTest, CaptureWithFPS) {
+    std::string outputDir = testOutputDir.string();
+    // Test with different FPS (30 fps)
+    auto result = runCLI("-d 0 -f 30 -c 1 -o " + outputDir);
+    
+    ASSERT_EQ(result.exitCode, 0) << "Capture command failed: " << result.output;
+    
+    // Verify image file was created
+    int imageCount = 0;
+    for (const auto& entry : fs::directory_iterator(testOutputDir)) {
+        if (entry.path().extension() == ".bmp") {
+            imageCount++;
+        }
+    }
+    
+    ASSERT_EQ(imageCount, 1) << "Expected 1 image file, found " << imageCount;
+}
+
+TEST_F(CCAPCLIDeviceTest, CaptureWithTimeout) {
+    std::string outputDir = testOutputDir.string();
+    // Test with short timeout (should still succeed for 1 frame)
+    auto result = runCLI("-d 0 -t 3000 -c 1 -o " + outputDir);
+    
+    ASSERT_EQ(result.exitCode, 0) << "Capture command failed: " << result.output;
+    
+    // Verify image file was created
+    int imageCount = 0;
+    for (const auto& entry : fs::directory_iterator(testOutputDir)) {
+        if (entry.path().extension() == ".bmp") {
+            imageCount++;
+        }
+    }
+    
+    ASSERT_EQ(imageCount, 1) << "Expected 1 image file, found " << imageCount;
+}
+
+TEST_F(CCAPCLIDeviceTest, CaptureInvalidDevice) {
+    std::string outputDir = testOutputDir.string();
+    // Try to capture from device index 999 (should fail or fallback to default)
+    auto result = runCLI("-d 999 -c 1 -o " + outputDir);
+    
+    // Some implementations may fallback to default device instead of failing
+    // So we just check that it doesn't crash
+    // If it succeeds, verify output exists
+    if (result.exitCode == 0) {
+        // Fallback to default device, verify output
+        int imageCount = 0;
+        for (const auto& entry : fs::directory_iterator(testOutputDir)) {
+            if (entry.path().extension() == ".bmp") {
+                imageCount++;
+            }
+        }
+        EXPECT_GT(imageCount, 0) << "If command succeeds, should create images";
+    }
+    // If it fails, that's also acceptable behavior
+}
+
+TEST_F(CCAPCLIDeviceTest, CaptureWithVerbose) {
+    std::string outputDir = testOutputDir.string();
+    auto result = runCLI("--verbose -d 0 -c 1 -o " + outputDir);
+    
+    ASSERT_EQ(result.exitCode, 0) << "Capture command failed: " << result.output;
+    
+    // Verify image file was created
+    int imageCount = 0;
+    for (const auto& entry : fs::directory_iterator(testOutputDir)) {
+        if (entry.path().extension() == ".bmp") {
+            imageCount++;
+        }
+    }
+    
+    ASSERT_EQ(imageCount, 1) << "Expected 1 image file, found " << imageCount;
+}
+
+TEST_F(CCAPCLIDeviceTest, ShowDeviceInfoAll) {
+    // Test showing info for all devices (-1 means all)
+    auto result = runCLI("--device-info");
+    EXPECT_EQ(result.exitCode, 0);
+    EXPECT_THAT(result.output, ::testing::HasSubstr("Device"));
+}
+
 // ============================================================================
 // Format Conversion Tests
 // ============================================================================
@@ -466,3 +636,45 @@ TEST_F(CCAPCLITest, ConvertNV12ToImage_White) {
     EXPECT_GT(pixel.g, 240) << "Green channel too low: " << (int)pixel.g;
     EXPECT_GT(pixel.b, 240) << "Blue channel too low: " << (int)pixel.b;
 }
+
+TEST_F(CCAPCLITest, ConvertI420ToImage_Red) {
+    // Create a solid red I420 image (64x64)
+    fs::path yuvPath = testOutputDir / "test_i420_red.yuv";
+    createSolidColorI420(yuvPath, 64, 64, 76, 84, 255);
+    
+    fs::path outputPath = testOutputDir / "output_i420_red.bmp";
+    std::string cmd = "--convert " + yuvPath.string() + 
+                      " --yuv-format i420 --yuv-width 64 --yuv-height 64" +
+                      " --convert-output " + outputPath.string();
+    
+    auto result = runCLI(cmd);
+    ASSERT_EQ(result.exitCode, 0) << "Convert command failed: " << result.output;
+    ASSERT_TRUE(fs::exists(outputPath)) << "Output BMP file not created";
+    
+    // Read and verify pixel color (should be close to red)
+    RGB pixel = readBMPPixel(outputPath, 32, 32);
+    EXPECT_GT(pixel.r, 200) << "Red channel too low: " << (int)pixel.r;
+    EXPECT_LT(pixel.g, 100) << "Green channel too high: " << (int)pixel.g;
+    EXPECT_LT(pixel.b, 100) << "Blue channel too high: " << (int)pixel.b;
+}
+
+TEST_F(CCAPCLITest, ConvertI420ToImage_Green) {
+    // Create a solid green I420 image (64x64)
+    fs::path yuvPath = testOutputDir / "test_i420_green.yuv";
+    createSolidColorI420(yuvPath, 64, 64, 149, 43, 21);
+    
+    fs::path outputPath = testOutputDir / "output_i420_green.bmp";
+    std::string cmd = "--convert " + yuvPath.string() + 
+                      " --yuv-format i420 --yuv-width 64 --yuv-height 64" +
+                      " --convert-output " + outputPath.string();
+    
+    auto result = runCLI(cmd);
+    ASSERT_EQ(result.exitCode, 0) << "Convert command failed: " << result.output;
+    ASSERT_TRUE(fs::exists(outputPath)) << "Output BMP file not created";
+    
+    // Read and verify pixel color (should be close to green)
+    RGB pixel = readBMPPixel(outputPath, 32, 32);
+    EXPECT_LT(pixel.r, 100) << "Red channel too high: " << (int)pixel.r;
+    EXPECT_GT(pixel.g, 200) << "Green channel too low: " << (int)pixel.g;
+    EXPECT_LT(pixel.b, 100) << "Blue channel too high: " << (int)pixel.b;
+}