// swiftlint:disable file_length
import ArgumentParser
import Foundation
@testable import peepit
import Testing
@Suite("ImageCommand Tests", .tags(.imageCapture, .unit))
struct ImageCommandTests {
// MARK: - Test Data & Helpers
private static let validFormats: [ImageFormat] = [.png, .jpg]
private static let validCaptureModes: [CaptureMode] = [.screen, .window, .multi]
private static let validCaptureFocus: [CaptureFocus] = [.background, .foreground]
private static func createTestCommand(_ args: [String] = []) throws -> ImageCommand {
try ImageCommand.parse(args)
}
// MARK: - Command Parsing Tests
@Test("Basic command parsing with defaults", .tags(.fast))
func imageCommandParsing() throws {
// Test basic command parsing
let command = try ImageCommand.parse([])
// Verify defaults
#expect(command.mode == nil)
#expect(command.format == .png)
#expect(command.path == nil)
#expect(command.app == nil)
#expect(command.captureFocus == .auto)
#expect(command.jsonOutput == false)
}
@Test("Command with screen mode", .tags(.fast))
func imageCommandWithScreenMode() throws {
// Test screen capture mode
let command = try ImageCommand.parse(["--mode", "screen"])
#expect(command.mode == .screen)
}
@Test("Command with app specifier", .tags(.fast))
func imageCommandWithAppSpecifier() throws {
// Test app-specific capture
let command = try ImageCommand.parse([
"--app", "Finder"
])
#expect(command.mode == nil) // mode is optional
#expect(command.app == "Finder")
}
@Test("Command with PID specifier", .tags(.fast))
func imageCommandWithPIDSpecifier() throws {
// Test PID-specific capture
let command = try ImageCommand.parse([
"--app", "PID:1234"
])
#expect(command.mode == nil) // mode is optional
#expect(command.app == "PID:1234")
}
@Test("Command with window title", .tags(.fast))
func imageCommandWithWindowTitle() throws {
// Test window title capture
let command = try ImageCommand.parse([
"--window-title", "Documents"
])
#expect(command.windowTitle == "Documents")
}
@Test("Command with output path", .tags(.fast))
func imageCommandWithOutput() throws {
// Test output path specification
let outputPath = "/tmp/test-images"
let command = try ImageCommand.parse([
"--path", outputPath
])
#expect(command.path == outputPath)
}
@Test("Command with format option", .tags(.fast))
func imageCommandWithFormat() throws {
// Test format specification
let command = try ImageCommand.parse([
"--format", "jpg"
])
#expect(command.format == .jpg)
}
@Test("Command with focus option", .tags(.fast))
func imageCommandWithFocus() throws {
// Test focus option
let command = try ImageCommand.parse([
"--capture-focus", "foreground"
])
#expect(command.captureFocus == .foreground)
}
@Test("Command with JSON output", .tags(.fast))
func imageCommandWithJSONOutput() throws {
// Test JSON output flag
let command = try ImageCommand.parse([
"--json-output"
])
#expect(command.jsonOutput == true)
}
@Test("Command with multi mode", .tags(.fast))
func imageCommandWithMultiMode() throws {
// Test multi capture mode
let command = try ImageCommand.parse([
"--mode", "multi"
])
#expect(command.mode == .multi)
}
@Test("Command with screen index", .tags(.fast))
func imageCommandWithScreenIndex() throws {
// Test screen index specification
let command = try ImageCommand.parse([
"--screen-index", "1"
])
#expect(command.screenIndex == 1)
}
// MARK: - Parameterized Command Tests
@Test(
"Various command combinations",
arguments: [
(args: ["--mode", "screen", "--format", "png"], mode: CaptureMode.screen, format: ImageFormat.png),
(args: ["--mode", "window", "--format", "jpg"], mode: CaptureMode.window, format: ImageFormat.jpg),
(args: ["--mode", "multi", "--json-output"], mode: CaptureMode.multi, format: ImageFormat.png)
]
)
func commandCombinations(args: [String], mode: CaptureMode, format: ImageFormat) throws {
let command = try ImageCommand.parse(args)
#expect(command.mode == mode)
#expect(command.format == format)
}
@Test(
"Invalid arguments throw errors",
arguments: [
["--mode", "invalid"],
["--format", "bmp"],
["--capture-focus", "neither"],
["--screen-index", "abc"]
]
)
func invalidArguments(args: [String]) {
#expect(throws: (any Error).self) {
_ = try ImageCommand.parse(args)
}
}
// MARK: - Model Tests
@Test("SavedFile model creation", .tags(.fast))
func savedFileModel() {
let savedFile = SavedFile(
path: "/tmp/screenshot.png",
item_label: "Screen 1",
window_title: nil,
window_id: nil,
window_index: nil,
mime_type: "image/png"
)
#expect(savedFile.path == "/tmp/screenshot.png")
#expect(savedFile.item_label == "Screen 1")
#expect(savedFile.mime_type == "image/png")
}
@Test("ImageCaptureData encoding", .tags(.fast))
func imageCaptureDataEncoding() throws {
let savedFile = SavedFile(
path: "/tmp/test.png",
item_label: "Test",
window_title: nil,
window_id: nil,
window_index: nil,
mime_type: "image/png"
)
let captureData = ImageCaptureData(saved_files: [savedFile])
// Test JSON encoding
let encoder = JSONEncoder()
// Properties are already in snake_case, no conversion needed
let data = try encoder.encode(captureData)
#expect(!data.isEmpty)
// Test decoding
let decoder = JSONDecoder()
// Properties are already in snake_case, no conversion needed
let decoded = try decoder.decode(ImageCaptureData.self, from: data)
#expect(decoded.saved_files.count == 1)
#expect(decoded.saved_files[0].path == "/tmp/test.png")
}
// MARK: - Enum Raw Value Tests
@Test("CaptureMode raw values", .tags(.fast))
func captureModeRawValues() {
#expect(CaptureMode.screen.rawValue == "screen")
#expect(CaptureMode.window.rawValue == "window")
#expect(CaptureMode.multi.rawValue == "multi")
}
@Test("ImageFormat raw values", .tags(.fast))
func imageFormatRawValues() {
#expect(ImageFormat.png.rawValue == "png")
#expect(ImageFormat.jpg.rawValue == "jpg")
}
@Test("CaptureFocus raw values", .tags(.fast))
func captureFocusRawValues() {
#expect(CaptureFocus.background.rawValue == "background")
#expect(CaptureFocus.foreground.rawValue == "foreground")
}
// MARK: - Mode Determination & Logic Tests
@Test("Mode determination logic", .tags(.fast))
func modeDeterminationLogic() throws {
// No mode, no app -> should default to screen
let screenCommand = try ImageCommand.parse([])
#expect(screenCommand.mode == nil)
#expect(screenCommand.app == nil)
// No mode, with app -> should infer window mode in actual execution
let windowCommand = try ImageCommand.parse(["--app", "Finder"])
#expect(windowCommand.mode == nil)
#expect(windowCommand.app == "Finder")
// Explicit mode should be preserved
let explicitCommand = try ImageCommand.parse(["--mode", "multi"])
#expect(explicitCommand.mode == .multi)
}
@Test("Default values verification", .tags(.fast))
func defaultValues() throws {
let command = try ImageCommand.parse([])
#expect(command.mode == nil)
#expect(command.format == .png)
#expect(command.path == nil)
#expect(command.app == nil)
#expect(command.windowTitle == nil)
#expect(command.windowIndex == nil)
#expect(command.screenIndex == nil)
#expect(command.captureFocus == .auto)
#expect(command.jsonOutput == false)
}
@Test(
"Screen index boundary values",
arguments: [0, 1, 99, 9999]
)
func screenIndexBoundaries(index: Int) throws {
let command = try ImageCommand.parse(["--screen-index", String(index)])
#expect(command.screenIndex == index)
}
@Test(
"Window index boundary values",
arguments: [0, 1, 10, 9999]
)
func windowIndexBoundaries(index: Int) throws {
let command = try ImageCommand.parse(["--window-index", String(index)])
#expect(command.windowIndex == index)
}
@Test("Error handling for invalid combinations", .tags(.fast))
func invalidCombinations() {
// Window capture without app should fail in execution
// This tests the parsing, execution would fail later
do {
let command = try ImageCommand.parse(["--mode", "window"])
#expect(command.mode == .window)
#expect(command.app == nil) // This would cause execution error
} catch {
Issue.record("Parsing should succeed even with invalid combinations")
}
}
}
// MARK: - Path Handling Tests
@Suite("ImageCommand Path Handling Tests", .tags(.imageCapture, .unit))
struct ImageCommandPathHandlingTests {
// MARK: - Helper Methods
private func createTestImageCommand(path: String?, screenIndex: Int? = nil) -> ImageCommand {
var command = ImageCommand()
command.path = path
command.screenIndex = screenIndex
command.format = .png
return command
}
// MARK: - Path Detection Tests
@Test("File vs directory path detection", .tags(.fast))
func pathDetection() {
// Test file-like paths (have extension, no trailing slash)
let filePaths = [
"/tmp/screenshot.png",
"/home/user/image.jpg",
"/path/with spaces/file.png",
"./relative/file.png",
"simple.png"
]
// Test directory-like paths (no extension or trailing slash)
let directoryPaths = [
"/tmp/",
"/home/user/screenshots",
"/path/with spaces/",
"simple-dir"
]
// File paths should be detected correctly
for filePath in filePaths {
let isLikelyFile = filePath.contains(".") && !filePath.hasSuffix("/")
#expect(isLikelyFile == true, "Path '\(filePath)' should be detected as file")
}
// Directory paths should be detected correctly
for dirPath in directoryPaths {
let isLikelyFile = dirPath.contains(".") && !dirPath.hasSuffix("/")
#expect(isLikelyFile == false, "Path '\(dirPath)' should be detected as directory")
}
}
@Test("Single screen file path handling", .tags(.fast))
func singleScreenFilePath() {
// For single screen, should use exact path
let fileName = "screen_1_20250608_120000.png"
let result = OutputPathResolver.determineOutputPath(
basePath: "/tmp/my-screenshot.png",
fileName: fileName,
screenIndex: 0,
isSingleCapture: true
)
#expect(result == "/tmp/my-screenshot.png")
}
@Test("Multiple screens file path handling", .tags(.fast))
func multipleScreensFilePath() {
// For multiple screens, should append screen info
let fileName = "screen_1_20250608_120000.png"
let result = OutputPathResolver.determineOutputPath(
basePath: "/tmp/screenshot.png",
fileName: fileName,
screenIndex: nil,
isSingleCapture: false
)
#expect(result == "/tmp/screenshot_1_20250608_120000.png")
}
@Test("Directory path handling", .tags(.fast))
func directoryPathHandling() {
let fileName = "screen_1_20250608_120000.png"
let result = OutputPathResolver.determineOutputPath(basePath: "/tmp/screenshots", fileName: fileName)
#expect(result == "/tmp/screenshots/screen_1_20250608_120000.png")
}
@Test("Directory with trailing slash handling", .tags(.fast))
func directoryWithTrailingSlashHandling() {
let fileName = "screen_1_20250608_120000.png"
let result = OutputPathResolver.determineOutputPath(basePath: "/tmp/screenshots/", fileName: fileName)
#expect(result == "/tmp/screenshots//screen_1_20250608_120000.png")
}
@Test(
"Various file extensions",
arguments: [
"/tmp/image.png",
"/tmp/photo.jpg",
"/tmp/picture.jpeg",
"/tmp/screen.PNG",
"/tmp/capture.JPG"
]
)
func variousFileExtensions(path: String) {
let fileName = "screen_1_20250608_120000.png"
let result = OutputPathResolver.determineOutputPath(basePath: path, fileName: fileName)
// Should modify the filename for multiple screens, keeping original extension
let pathExtension = (path as NSString).pathExtension
let pathWithoutExtension = (path as NSString).deletingPathExtension
let expected = "\(pathWithoutExtension)_1_20250608_120000.\(pathExtension)"
#expect(result == expected)
}
@Test(
"Edge case paths",
arguments: [
("", false), // Empty path
("...", true), // File-like with dots
("/", false), // Root directory
("/tmp/.hidden", true), // Hidden file
("/tmp/.hidden/", false), // Hidden directory
("file.tar.gz", true) // Multiple extensions
]
)
func edgeCasePaths(path: String, expectedAsFile: Bool) {
let isLikelyFile = path.contains(".") && !path.hasSuffix("/")
#expect(isLikelyFile == expectedAsFile, "Path '\(path)' detection failed")
}
@Test("Filename generation with screen suffix extraction", .tags(.fast))
func filenameSuffixExtraction() {
// Test various filename patterns
let testCases = [
(fileName: "screen_1_20250608_120000.png", expected: "/tmp/shot_1_20250608_120000.png"),
(fileName: "screen_2_20250608_120001.png", expected: "/tmp/shot_2_20250608_120001.png"),
(fileName: "screen_10_20250608_120002.png", expected: "/tmp/shot_10_20250608_120002.png")
]
for testCase in testCases {
let result = OutputPathResolver.determineOutputPath(basePath: "/tmp/shot.png", fileName: testCase.fileName)
#expect(result == testCase.expected, "Failed for fileName: \(testCase.fileName)")
}
}
@Test("Path with special characters", .tags(.fast))
func pathWithSpecialCharacters() {
let specialPaths = [
"/tmp/测试 screenshot.png",
"/tmp/スクリーン capture.png",
"/tmp/screen-shot_v2.png",
"/tmp/my file (1).png"
]
for path in specialPaths {
let fileName = "screen_1_20250608_120000.png"
let result = OutputPathResolver.determineOutputPath(
basePath: path,
fileName: fileName,
screenIndex: 0,
isSingleCapture: true
)
// For single screen, should use exact path
#expect(result == path, "Failed for special path: \(path)")
}
}
@Test("Nested directory path creation logic", .tags(.fast))
func nestedDirectoryPathCreation() {
let nestedPaths = [
"/tmp/very/deep/nested/path/file.png",
"/home/user/Documents/Screenshots/test.jpg",
"./relative/deep/path/image.png"
]
for path in nestedPaths {
let fileName = "screen_1_20250608_120000.png"
let result = OutputPathResolver.determineOutputPath(
basePath: path,
fileName: fileName,
screenIndex: 0,
isSingleCapture: true
)
#expect(result == path, "Should return exact path for nested file: \(path)")
// Test parent directory extraction
let parentDir = (path as NSString).deletingLastPathComponent
#expect(!parentDir.isEmpty, "Parent directory should be extractable from: \(path)")
}
}
@Test("Default path behavior (nil path)", .tags(.fast))
func defaultPathBehavior() {
let fileName = "screen_1_20250608_120000.png"
let result = OutputPathResolver.getOutputPath(basePath: nil, fileName: fileName)
#expect(result == "/tmp/\(fileName)")
}
@Test("getOutputPath method delegation", .tags(.fast))
func getOutputPathDelegation() {
// Test that getOutputPath properly delegates to determineOutputPath
let fileName = "screen_1_20250608_120000.png"
let result = OutputPathResolver.getOutputPath(basePath: "/tmp/test.png", fileName: fileName)
// Should call determineOutputPath and return its result
#expect(result.contains("/tmp/test"))
#expect(result.hasSuffix(".png"))
}
}
// MARK: - Error Handling Tests
@Suite("ImageCommand Error Handling Tests", .tags(.imageCapture, .unit))
struct ImageCommandErrorHandlingTests {
@Test("Improved file write error messages", .tags(.fast))
func improvedFileWriteErrorMessages() {
// Test enhanced error messages with different underlying errors
// Test with permission error
let permissionError = NSError(domain: NSCocoaErrorDomain, code: NSFileWriteNoPermissionError, userInfo: [
NSLocalizedDescriptionKey: "Permission denied"
])
let fileErrorWithPermission = CaptureError.fileWriteError("/tmp/test.png", permissionError)
let permissionMessage = fileErrorWithPermission.errorDescription ?? ""
#expect(permissionMessage.contains("Failed to write capture file to path: /tmp/test.png."))
#expect(permissionMessage.contains("Permission denied - check that the directory is writable"))
// Test with no such file error
let noFileError = NSError(domain: NSCocoaErrorDomain, code: NSFileNoSuchFileError, userInfo: [
NSLocalizedDescriptionKey: "No such file or directory"
])
let fileErrorWithNoFile = CaptureError.fileWriteError("/tmp/nonexistent/test.png", noFileError)
let noFileMessage = fileErrorWithNoFile.errorDescription ?? ""
#expect(noFileMessage.contains("Failed to write capture file to path: /tmp/nonexistent/test.png."))
#expect(noFileMessage.contains("Directory does not exist - ensure the parent directory exists"))
// Test with disk space error
let spaceError = NSError(domain: NSCocoaErrorDomain, code: NSFileWriteOutOfSpaceError, userInfo: [
NSLocalizedDescriptionKey: "No space left on device"
])
let fileErrorWithSpace = CaptureError.fileWriteError("/tmp/test.png", spaceError)
let spaceMessage = fileErrorWithSpace.errorDescription ?? ""
#expect(spaceMessage.contains("Failed to write capture file to path: /tmp/test.png."))
#expect(spaceMessage.contains("Insufficient disk space available"))
// Test with generic error
let genericError = NSError(domain: "TestDomain", code: 999, userInfo: [
NSLocalizedDescriptionKey: "Some generic error"
])
let fileErrorWithGeneric = CaptureError.fileWriteError("/tmp/test.png", genericError)
let genericMessage = fileErrorWithGeneric.errorDescription ?? ""
#expect(genericMessage.contains("Failed to write capture file to path: /tmp/test.png."))
#expect(genericMessage.contains("Some generic error"))
// Test with no underlying error
let fileErrorWithoutUnderlying = CaptureError.fileWriteError("/tmp/test.png", nil)
let noUnderlyingMessage = fileErrorWithoutUnderlying.errorDescription ?? ""
#expect(noUnderlyingMessage.contains("Failed to write capture file to path: /tmp/test.png."))
#expect(noUnderlyingMessage
.contains("This may be due to insufficient permissions, missing directory, or disk space issues")
)
}
@Test("Error message formatting consistency", .tags(.fast))
func errorMessageFormattingConsistency() {
// Test that all error messages end with proper punctuation and format
let testPath = "/tmp/test/path/file.png"
let testError = NSError(domain: "Test", code: 1, userInfo: [NSLocalizedDescriptionKey: "Test error"])
let fileError = CaptureError.fileWriteError(testPath, testError)
let message = fileError.errorDescription ?? ""
// Should contain the path
#expect(message.contains(testPath))
// Should be properly formatted
#expect(message.starts(with: "Failed to write capture file to path:"))
// Should have additional context
#expect(message.count > "Failed to write capture file to path: \(testPath).".count)
}
@Test("Error exit codes consistency", .tags(.fast))
func errorExitCodesConsistency() {
// Test that file write errors maintain proper exit codes
let fileError1 = CaptureError.fileWriteError("/tmp/test1.png", nil)
let fileError2 = CaptureError.fileWriteError("/tmp/test2.png", NSError(domain: "Test", code: 1))
#expect(fileError1.exitCode == 17)
#expect(fileError2.exitCode == 17)
#expect(fileError1.exitCode == fileError2.exitCode)
}
@Test("Directory creation error handling", .tags(.fast))
func directoryCreationErrorHandling() {
// Test that directory creation failures are handled gracefully
// This test validates the logic without actually creating directories
let fileName = "screen_1_20250608_120001.png"
let result = OutputPathResolver.determineOutputPath(
basePath: "/tmp/test-path-creation/file.png",
fileName: fileName
)
// Should return the intended path even if directory creation might fail
#expect(result == "/tmp/test-path-creation/file_1_20250608_120001.png")
}
@Test("Path validation edge cases", .tags(.fast))
func pathValidationEdgeCases() throws {
// Test empty path components
let emptyResult = OutputPathResolver.determineOutputPath(basePath: "", fileName: "test.png")
#expect(emptyResult == "/test.png")
// Test root path
let rootResult = OutputPathResolver.determineOutputPath(basePath: "/", fileName: "test.png")
#expect(rootResult == "//test.png")
// Test current directory
let currentResult = OutputPathResolver.determineOutputPath(basePath: ".", fileName: "test.png")
#expect(currentResult == "./test.png")
}
}
// MARK: - Extended Image Command Tests
@Suite("ImageCommand Advanced Tests", .tags(.imageCapture, .integration))
struct ImageCommandAdvancedTests {
// MARK: - Complex Scenario Tests
@Test("Complex command with multiple options", .tags(.fast))
func complexCommand() throws {
let command = try ImageCommand.parse([
"--mode", "window",
"--app", "Safari",
"--window-title", "Home",
"--window-index", "0",
"--format", "jpg",
"--path", "/tmp/safari-home.jpg",
"--capture-focus", "foreground",
"--json-output"
])
#expect(command.mode == .window)
#expect(command.app == "Safari")
#expect(command.windowTitle == "Home")
#expect(command.windowIndex == 0)
#expect(command.format == .jpg)
#expect(command.path == "/tmp/safari-home.jpg")
#expect(command.captureFocus == .foreground)
#expect(command.jsonOutput == true)
}
@Test("Command help text contains all options", .tags(.fast))
func commandHelpText() {
let helpText = ImageCommand.helpMessage()
// Verify key options are documented
#expect(helpText.contains("--mode"))
#expect(helpText.contains("--app"))
#expect(helpText.contains("--window-title"))
#expect(helpText.contains("--format"))
#expect(helpText.contains("--path"))
#expect(helpText.contains("--capture-focus"))
#expect(helpText.contains("--json-output"))
}
@Test("Command configuration", .tags(.fast))
func commandConfiguration() {
let config = ImageCommand.configuration
#expect(config.commandName == "image")
#expect(config.abstract.contains("Capture"))
}
@Test(
"Window specifier combinations",
arguments: [
(app: "Safari", title: "Home", index: nil),
(app: "Finder", title: nil, index: 0),
(app: "Terminal", title: nil, index: nil)
]
)
func windowSpecifierCombinations(app: String, title: String?, index: Int?) throws {
var args = ["--app", app]
if let title {
args.append(contentsOf: ["--window-title", title])
}
if let index {
args.append(contentsOf: ["--window-index", String(index)])
}
let command = try ImageCommand.parse(args)
#expect(command.app == app)
#expect(command.windowTitle == title)
#expect(command.windowIndex == index)
}
@Test(
"Path expansion handling",
arguments: [
"~/Desktop/screenshot.png",
"/tmp/test.png",
"./relative/path.png",
"/path with spaces/image.png"
]
)
func pathExpansion(path: String) throws {
let command = try ImageCommand.parse(["--path", path])
#expect(command.path == path)
}
@Test("FileHandleTextOutputStream functionality", .tags(.fast))
func fileHandleTextOutputStream() {
// Test the custom text output stream
let pipe = Pipe()
var stream = FileHandleTextOutputStream(pipe.fileHandleForWriting)
let testString = "Test output"
stream.write(testString)
pipe.fileHandleForWriting.closeFile()
let data = pipe.fileHandleForReading.readDataToEndOfFile()
let output = String(data: data, encoding: .utf8)
#expect(output == testString)
}
@Test("Command validation edge cases", .tags(.fast))
func commandValidationEdgeCases() {
// Test very long paths
let longPath = String(repeating: "a", count: 1000)
do {
let command = try ImageCommand.parse(["--path", longPath])
#expect(command.path == longPath)
} catch {
Issue.record("Should handle long paths gracefully")
}
// Test unicode in paths
let unicodePath = "/tmp/测试/スクリーン.png"
do {
let command = try ImageCommand.parse(["--path", unicodePath])
#expect(command.path == unicodePath)
} catch {
Issue.record("Should handle unicode paths")
}
}
@Test("MIME type assignment logic", .tags(.fast))
func mimeTypeAssignment() throws {
// Test MIME type logic for different formats
let pngCommand = try ImageCommand.parse(["--format", "png"])
#expect(pngCommand.format == .png)
let jpgCommand = try ImageCommand.parse(["--format", "jpg"])
#expect(jpgCommand.format == .jpg)
// Verify MIME types would be assigned correctly
// (This logic is in the SavedFile creation during actual capture)
}
@Test("Argument parsing stress test", .tags(.performance))
func argumentParsingStressTest() {
// Test parsing performance with many arguments
let args = [
"--mode", "multi",
"--app", "Very Long Application Name With Spaces",
"--window-title", "Very Long Window Title With Special Characters 测试 スクリーン",
"--path", "/very/long/path/to/some/directory/with/many/components/screenshot.png",
"--format", "jpg",
"--capture-focus", "foreground",
"--json-output"
]
do {
let command = try ImageCommand.parse(args)
#expect(command.mode == .multi)
#expect(command.jsonOutput == true)
} catch {
Issue.record("Should handle complex argument parsing")
}
}
@Test(
"Command option combinations validation",
arguments: [
(["--mode", "screen"], true),
(["--mode", "window", "--app", "Finder"], true),
(["--mode", "multi"], true),
(["--app", "Safari"], true),
(["--window-title", "Test"], true),
(["--screen-index", "0"], true),
(["--window-index", "0"], true)
]
)
func commandOptionCombinations(args: [String], shouldParse: Bool) {
do {
_ = try ImageCommand.parse(args)
#expect(shouldParse == true)
} catch {
#expect(shouldParse == false)
}
}
}
