Repository: apple/swift-argument-parser
Pull request #464 (2022-08-08 12:38:55)

[GSoC] Add API for disabling interactive mode
Solution to the issue #462.

This PR is used to track progress and view differences to make discussions easier.

### Checklist
- [x] I've added at least one test that validates that my change is working, if appropriate
- [x] I've followed the code style of the rest of the project
- [x] I've read the [Contribution Guidelines](https://github.com/apple/swift-argument-parser/blob/main/CONTRIBUTING.md)
- [x] I've updated the documentation if necessary

KeithBird: https://github.com/apple/swift-argument-parser/blob/df9ee6676cd5b3bf5b330ec7568a5644f547201b/Sources/ArgumentParser/Parsable%20Types/ParsableArguments.swift#L77

When `ParsableArguments` is converted to `ParsableCommand`, it is difficult to set the configuration parameters, but testing requires turning off interactive mode. So I've set the interaction mode to turn off by default for now. @natecook1000 
KeithBird: > One question about the new wrapper type for you. Let's also try to watch out for whitespace-only changes - makes it a bit harder to review. 👍

My apologies. You can turn on [Hide whitespace](https://cloudfour.com/thinks/quick-tip-how-to-hide-whitespace-changes-in-git-diffs/#github) which is hard to find. Can we manage formats automatically using [SwiftFormat](https://github.com/nicklockwood/SwiftFormat) and some configuration files? Manual formatting is a little tricky when there are a lot of files that have been slightly modified.

Patch:
diff --git a/Examples/count-lines/CountLines.swift b/Examples/count-lines/CountLines.swift
index 9bda535..2db3652 100644
--- a/Examples/count-lines/CountLines.swift
+++ b/Examples/count-lines/CountLines.swift
@@ -15,6 +15,8 @@ import Foundation
 @main
 @available(macOS 10.15, *)
 struct CountLines: AsyncParsableCommand {
+    static var configuration = CommandConfiguration(shouldPromptForMissing: false)
+
     @Argument(
         help: "A file to count lines in. If omitted, counts the lines of stdin.",
         completion: .file(), transform: URL.init(fileURLWithPath:))
diff --git a/Examples/math/Math.swift b/Examples/math/Math.swift
index 7684d8f..d4d2e7e 100644
--- a/Examples/math/Math.swift
+++ b/Examples/math/Math.swift
@@ -22,6 +22,9 @@ struct Math: ParsableCommand {
         // Commands can define a version for automatic '--version' support.
         version: "1.0.0",
 
+        // Throws an error when the required parameters are missing.
+        shouldPromptForMissing: false,
+
         // Pass an array to `subcommands` to set up a nested tree of subcommands.
         // With language support for type-level introspection, this could be
         // provided by automatically finding nested `ParsableCommand` types.
diff --git a/Examples/repeat/Repeat.swift b/Examples/repeat/Repeat.swift
index f6f75c5..a2ec7ac 100644
--- a/Examples/repeat/Repeat.swift
+++ b/Examples/repeat/Repeat.swift
@@ -13,6 +13,8 @@ import ArgumentParser
 
 @main
 struct Repeat: ParsableCommand {
+    static var configuration = CommandConfiguration(shouldPromptForMissing: false)
+
     @Option(help: "The number of times to repeat 'phrase'.")
     var count: Int?
 
@@ -23,7 +25,7 @@ struct Repeat: ParsableCommand {
     var phrase: String
 
     mutating func run() throws {
-        let repeatCount = count ?? .max
+        let repeatCount = count ?? 2
 
         for i in 1...repeatCount {
             if includeCounter {
diff --git a/Examples/roll/main.swift b/Examples/roll/main.swift
index 3ae5865..86429dd 100644
--- a/Examples/roll/main.swift
+++ b/Examples/roll/main.swift
@@ -12,6 +12,8 @@
 import ArgumentParser
 
 struct RollOptions: ParsableArguments {
+    static var configuration = CommandConfiguration(shouldPromptForMissing: false)
+
     @Option(help: ArgumentHelp("Rolls the dice <n> times.", valueName: "n"))
     var times = 1
 
diff --git a/Sources/ArgumentParser/Parsable Types/CommandConfiguration.swift b/Sources/ArgumentParser/Parsable Types/CommandConfiguration.swift
index 5c6614f..ff57f3f 100644
--- a/Sources/ArgumentParser/Parsable Types/CommandConfiguration.swift
+++ b/Sources/ArgumentParser/Parsable Types/CommandConfiguration.swift
@@ -45,6 +45,9 @@ public struct CommandConfiguration {
   /// A Boolean value indicating whether this command should be shown in
   /// the extended help display.
   public var shouldDisplay: Bool
+
+  /// A Boolean value indicating whether to prompt for missing required values.
+  public var shouldPromptForMissing: Bool
   
   /// An array of the types that define subcommands for this command.
   public var subcommands: [ParsableCommand.Type]
@@ -87,6 +90,7 @@ public struct CommandConfiguration {
     discussion: String = "",
     version: String = "",
     shouldDisplay: Bool = true,
+    shouldPromptForMissing: Bool = true,
     subcommands: [ParsableCommand.Type] = [],
     defaultSubcommand: ParsableCommand.Type? = nil,
     helpNames: NameSpecification? = nil
@@ -97,6 +101,7 @@ public struct CommandConfiguration {
     self.discussion = discussion
     self.version = version
     self.shouldDisplay = shouldDisplay
+    self.shouldPromptForMissing = shouldPromptForMissing
     self.subcommands = subcommands
     self.defaultSubcommand = defaultSubcommand
     self.helpNames = helpNames
@@ -112,6 +117,7 @@ public struct CommandConfiguration {
     discussion: String = "",
     version: String = "",
     shouldDisplay: Bool = true,
+    shouldPromptForMissing: Bool = true,
     subcommands: [ParsableCommand.Type] = [],
     defaultSubcommand: ParsableCommand.Type? = nil,
     helpNames: NameSpecification? = nil
@@ -123,6 +129,7 @@ public struct CommandConfiguration {
     self.discussion = discussion
     self.version = version
     self.shouldDisplay = shouldDisplay
+    self.shouldPromptForMissing = shouldPromptForMissing
     self.subcommands = subcommands
     self.defaultSubcommand = defaultSubcommand
     self.helpNames = helpNames
@@ -137,6 +144,7 @@ extension CommandConfiguration {
     discussion: String,
     version: String,
     shouldDisplay: Bool,
+    shouldPromptForMissing: Bool,
     subcommands: [ParsableCommand.Type],
     defaultSubcommand: ParsableCommand.Type?,
     helpNames: NameSpecification?
@@ -148,6 +156,7 @@ extension CommandConfiguration {
       discussion: discussion,
       version: version,
       shouldDisplay: shouldDisplay,
+      shouldPromptForMissing: shouldPromptForMissing,
       subcommands: subcommands,
       defaultSubcommand: defaultSubcommand,
       helpNames: helpNames)
diff --git a/Sources/ArgumentParser/Parsable Types/ParsableArguments.swift b/Sources/ArgumentParser/Parsable Types/ParsableArguments.swift
index 061492d..8ec9f9d 100644
--- a/Sources/ArgumentParser/Parsable Types/ParsableArguments.swift
+++ b/Sources/ArgumentParser/Parsable Types/ParsableArguments.swift
@@ -41,11 +41,14 @@ public protocol ParsableArguments: Decodable {
   static var _errorLabel: String { get }
 }
 
-/// A type that provides the `ParsableCommand` interface to a `ParsableArguments` type.
+/// A type that provides the `ParsableCommand` interface to a `ParsableArguments` type,
+/// and set the `shouldPromptForMissing` to true.
 struct _WrappedParsableCommand<P: ParsableArguments>: ParsableCommand {
+  static var configuration: CommandConfiguration { .init(shouldPromptForMissing: false) }
+
   static var _commandName: String {
     let name = String(describing: P.self).convertedToSnakeCase()
-    
+
     // If the type is named something like "TransformOptions", we only want
     // to use "transform" as the command name.
     if let optionsRange = name.range(of: "_options"),
@@ -56,7 +59,7 @@ struct _WrappedParsableCommand<P: ParsableArguments>: ParsableCommand {
       return name
     }
   }
-  
+
   @OptionGroup var options: P
 }
 
@@ -70,16 +73,14 @@ var standardError = StandardError()
 
 extension ParsableArguments {
   public mutating func validate() throws {}
-  
+
+  public static var _errorLabel: String { "Error" }
+
   /// This type as-is if it conforms to `ParsableCommand`, or wrapped in the
   /// `ParsableCommand` wrapper if not.
   internal static var asCommand: ParsableCommand.Type {
     self as? ParsableCommand.Type ?? _WrappedParsableCommand<Self>.self
   }
-  
-  public static var _errorLabel: String {
-    "Error"
-  }
 }
 
 // MARK: - API
diff --git a/Sources/ArgumentParser/Parsing/Interactive.swift b/Sources/ArgumentParser/Parsing/Interactive.swift
index 34c9418..5311c2d 100644
--- a/Sources/ArgumentParser/Parsing/Interactive.swift
+++ b/Sources/ArgumentParser/Parsing/Interactive.swift
@@ -16,6 +16,7 @@ extension CommandParser {
   ///   - split: A collection of parsed arguments which needs to be modified.
   /// - Returns: Whether the dialog resolve the error.
   mutating func canInteract(error: Error, split: inout SplitArguments) -> Bool {
+    guard rootCommand.configuration.shouldPromptForMissing else { return false }
     guard lineStack == nil || !lineStack!.isEmpty else { return false }
     guard let error = error as? ParserError else { return false }
     guard case let .missingValueForOption(inputOrigin, name) = error else { return false }
@@ -44,6 +45,7 @@ extension CommandParser {
   ///   - values: The resulting values after parsing the arguments which needs to be modified.
   /// - Returns: Whether the dialog resolve the error.
   mutating func canInteract(error: Error, arguments: ArgumentSet, values: inout ParsedValues) -> Bool {
+    guard rootCommand.configuration.shouldPromptForMissing else { return false }
     guard lineStack == nil || !lineStack!.isEmpty else { return false }
     guard let error = error as? ParserError else { return false }
 


Test patch:
diff --git a/Tests/ArgumentParserEndToEndTests/CustomParsingEndToEndTests.swift b/Tests/ArgumentParserEndToEndTests/CustomParsingEndToEndTests.swift
index 57d95f4..54db368 100644
--- a/Tests/ArgumentParserEndToEndTests/CustomParsingEndToEndTests.swift
+++ b/Tests/ArgumentParserEndToEndTests/CustomParsingEndToEndTests.swift
@@ -36,6 +36,7 @@ extension Array where Element == Name {
 // MARK: -
 
 fileprivate struct Foo: ParsableCommand {
+  static var configuration = CommandConfiguration(shouldPromptForMissing: false)
   enum Subgroup: Equatable {
     case first(Int)
     case second(Int)
@@ -86,6 +87,7 @@ extension ParsingEndToEndTests {
 // MARK: -
 
 fileprivate struct Bar: ParsableCommand {
+  static var configuration = CommandConfiguration(shouldPromptForMissing: false)
   @Option(transform: { try Name(rawValue: $0) })
   var firstName: Name = try! Name(rawValue: "none")
 
@@ -125,6 +127,7 @@ extension ParsingEndToEndTests {
 // MARK: -
 
 fileprivate struct Qux: ParsableCommand {
+  static var configuration = CommandConfiguration(shouldPromptForMissing: false)
   @Option(transform: { try Name(rawValue: $0) })
   var firstName: [Name] = []
 
diff --git a/Tests/ArgumentParserEndToEndTests/DefaultSubcommandEndToEndTests.swift b/Tests/ArgumentParserEndToEndTests/DefaultSubcommandEndToEndTests.swift
index 2073afa..32ad5e5 100644
--- a/Tests/ArgumentParserEndToEndTests/DefaultSubcommandEndToEndTests.swift
+++ b/Tests/ArgumentParserEndToEndTests/DefaultSubcommandEndToEndTests.swift
@@ -73,40 +73,41 @@ extension DefaultSubcommandEndToEndTests {
 extension DefaultSubcommandEndToEndTests {
   fileprivate struct MyCommand: ParsableCommand {
     static var configuration = CommandConfiguration(
+      shouldPromptForMissing: false,
       subcommands: [Plugin.self, NonDefault.self, Other.self],
       defaultSubcommand: Plugin.self
     )
-    
+
     @OptionGroup
     var options: CommonOptions
   }
-  
+
   fileprivate struct CommonOptions: ParsableArguments {
     @Flag(name: [.customLong("verbose"), .customShort("v")],
           help: "Enable verbose aoutput.")
     var verbose = false
   }
-  
+
   fileprivate struct Plugin: ParsableCommand {
     @OptionGroup var options: CommonOptions
     @Argument var pluginName: String
-    
+
     @Argument(parsing: .unconditionalRemaining)
     var pluginArguments: [String] = []
   }
-  
+
   fileprivate struct NonDefault: ParsableCommand {
     @OptionGroup var options: CommonOptions
     @Argument var pluginName: String
-    
+
     @Argument(parsing: .unconditionalRemaining)
     var pluginArguments: [String] = []
   }
-  
+
   fileprivate struct Other: ParsableCommand {
     @OptionGroup var options: CommonOptions
   }
-  
+
   func testRemainingDefaultImplicit() throws {
     AssertParseCommand(MyCommand.self, Plugin.self, ["my-plugin"]) { plugin in
       XCTAssertEqual(plugin.pluginName, "my-plugin")
@@ -184,7 +185,7 @@ extension DefaultSubcommandEndToEndTests {
       XCTAssertEqual(other.options.verbose, true)
     }
   }
-  
+
   func testRemainingDefaultFailure() {
     XCTAssertThrowsError(try MyCommand.parseAsRoot([]))
     XCTAssertThrowsError(try MyCommand.parseAsRoot(["--verbose"]))
diff --git a/Tests/ArgumentParserEndToEndTests/DefaultsEndToEndTests.swift b/Tests/ArgumentParserEndToEndTests/DefaultsEndToEndTests.swift
index f9b9fd7..e290566 100644
--- a/Tests/ArgumentParserEndToEndTests/DefaultsEndToEndTests.swift
+++ b/Tests/ArgumentParserEndToEndTests/DefaultsEndToEndTests.swift
@@ -454,7 +454,7 @@ fileprivate struct ArgumentPropertyInitArguments_NoDefault_NoTransform: Parsable
 
 fileprivate struct ArgumentPropertyInitArguments_Default_Transform: ParsableArguments {
   @Argument(transform: exclaim)
-    var transformedData: String = "test"
+  var transformedData: String = "test"
 }
 
 fileprivate struct ArgumentPropertyInitArguments_NoDefault_Transform: ParsableArguments {
@@ -511,7 +511,7 @@ extension DefaultsEndToEndTests {
 fileprivate struct Quux: ParsableArguments {
   @Option(parsing: .upToNextOption)
   var letters: [String] = ["A", "B"]
-  
+
   @Argument()
   var numbers: [Int] = [1, 2]
 }
@@ -614,19 +614,21 @@ extension DefaultsEndToEndTests {
 
 fileprivate struct Main: ParsableCommand {
   static var configuration = CommandConfiguration(
+    shouldPromptForMissing: false,
     subcommands: [Sub.self],
     defaultSubcommand: Sub.self
   )
-  
+
   struct Options: ParsableArguments {
     @Option(parsing: .upToNextOption)
     var letters: [String] = ["A", "B"]
   }
-  
+
   struct Sub: ParsableCommand {
+    static var configuration = CommandConfiguration(shouldPromptForMissing: false)
     @Argument()
     var numbers: [Int] = [1, 2]
-    
+
     @OptionGroup()
     var options: Main.Options
   }
diff --git a/Tests/ArgumentParserEndToEndTests/EnumEndToEndTests.swift b/Tests/ArgumentParserEndToEndTests/EnumEndToEndTests.swift
index 283cc90..8e6fdaa 100644
--- a/Tests/ArgumentParserEndToEndTests/EnumEndToEndTests.swift
+++ b/Tests/ArgumentParserEndToEndTests/EnumEndToEndTests.swift
@@ -23,7 +23,7 @@ fileprivate struct Bar: ParsableArguments {
     case hello
     case goodbye
   }
-  
+
   @Option()
   var index: Index
 }
@@ -37,13 +37,13 @@ extension EnumEndToEndTests {
       XCTAssertEqual(bar.index, Bar.Index.goodbye)
     }
   }
-  
+
   func testParsing_SingleOptionMultipleTimes() throws {
     AssertParse(Bar.self, ["--index", "hello", "--index", "goodbye"]) { bar in
       XCTAssertEqual(bar.index, Bar.Index.goodbye)
     }
   }
-  
+
   func testParsing_SingleOption_Fails() throws {
     XCTAssertThrowsError(try Bar.parse([]))
     XCTAssertThrowsError(try Bar.parse(["--index"]))
@@ -59,7 +59,7 @@ fileprivate struct Baz: ParsableArguments {
     case generateBashScript = "generate-bash-script"
     case generateZshScript
   }
-  
+
   @Option(name: .customLong("mode")) var modeOption: Mode?
   @Argument() var modeArg: Mode?
 }
@@ -75,7 +75,7 @@ extension EnumEndToEndTests {
       XCTAssertNil(baz.modeArg)
     }
   }
-  
+
   func test_ParsingRawValue_Argument() throws {
     AssertParse(Baz.self, ["generate-bash-script"]) { baz in
       XCTAssertEqual(baz.modeArg, .generateBashScript)
@@ -86,7 +86,7 @@ extension EnumEndToEndTests {
       XCTAssertNil(baz.modeOption)
     }
   }
-  
+
   func test_ParsingRawValue_Fails() throws {
     XCTAssertThrowsError(try Baz.parse(["generateBashScript"]))
     XCTAssertThrowsError(try Baz.parse(["--mode generateBashScript"]))
diff --git a/Tests/ArgumentParserEndToEndTests/JoinedEndToEndTests.swift b/Tests/ArgumentParserEndToEndTests/JoinedEndToEndTests.swift
index 482d3fc..f6a9d0a 100644
--- a/Tests/ArgumentParserEndToEndTests/JoinedEndToEndTests.swift
+++ b/Tests/ArgumentParserEndToEndTests/JoinedEndToEndTests.swift
@@ -21,10 +21,10 @@ final class JoinedEndToEndTests: XCTestCase {
 fileprivate struct Foo: ParsableArguments {
   @Option(name: .customShort("f"))
   var file = ""
-  
+
   @Option(name: .customShort("d", allowingJoined: true))
   var debug = ""
-  
+
   @Flag(name: .customLong("fdi", withSingleDash: true))
   var fdi = false
 }
@@ -85,7 +85,7 @@ extension JoinedEndToEndTests {
       XCTAssertEqual(foo.fdi, true)
     }
   }
-  
+
   func testSingleValueParsing_Fails() throws {
     XCTAssertThrowsError(try Foo.parse(["-f", "-d"]))
     XCTAssertThrowsError(try Foo.parse(["-f", "file", "-d"]))
@@ -120,7 +120,7 @@ extension JoinedEndToEndTests {
       XCTAssertEqual(bar.debug, ["debug1", "debug2", "debug3"])
     }
   }
-  
+
   func testArrayValueParsing_Fails() throws {
     XCTAssertThrowsError(try Bar.parse(["-D"]))
     XCTAssertThrowsError(try Bar.parse(["-Ddebug1", "debug2"]))
@@ -132,7 +132,7 @@ extension JoinedEndToEndTests {
 fileprivate struct Baz: ParsableArguments {
   @Option(name: .customShort("D", allowingJoined: true), parsing: .upToNextOption)
   var debug: [String] = []
-  
+
   @Flag var verbose = false
 }
 
@@ -141,22 +141,22 @@ extension JoinedEndToEndTests {
     AssertParse(Baz.self, []) { baz in
       XCTAssertEqual(baz.debug, [])
     }
-    
+
     AssertParse(Baz.self, ["-Ddebug1", "debug2"]) { baz in
       XCTAssertEqual(baz.debug, ["debug1", "debug2"])
       XCTAssertEqual(baz.verbose, false)
     }
-    
+
     AssertParse(Baz.self, ["-Ddebug1", "debug2", "--verbose"]) { baz in
       XCTAssertEqual(baz.debug, ["debug1", "debug2"])
       XCTAssertEqual(baz.verbose, true)
     }
-    
+
     AssertParse(Baz.self, ["-Ddebug1", "debug2", "-Ddebug3", "debug4"]) { baz in
       XCTAssertEqual(baz.debug, ["debug1", "debug2", "debug3", "debug4"])
     }
   }
-  
+
   func testArrayUpToNextParsing_Fails() throws {
     XCTAssertThrowsError(try Baz.parse(["-D", "--other"]))
     XCTAssertThrowsError(try Baz.parse(["-Ddebug", "--other"]))
@@ -177,16 +177,16 @@ extension JoinedEndToEndTests {
     AssertParse(Qux.self, []) { qux in
       XCTAssertEqual(qux.debug, [])
     }
-    
+
     AssertParse(Qux.self, ["-Ddebug1", "debug2"]) { qux in
       XCTAssertEqual(qux.debug, ["debug1", "debug2"])
     }
-    
+
     AssertParse(Qux.self, ["-Ddebug1", "debug2", "-Ddebug3", "debug4", "--other"]) { qux in
       XCTAssertEqual(qux.debug, ["debug1", "debug2", "-Ddebug3", "debug4", "--other"])
     }
   }
-  
+
   func testArrayRemainingParsing_Fails() throws {
     XCTAssertThrowsError(try Baz.parse(["--other", "-Ddebug", "debug"]))
   }
diff --git a/Tests/ArgumentParserEndToEndTests/LongNameWithShortDashEndToEndTests.swift b/Tests/ArgumentParserEndToEndTests/LongNameWithShortDashEndToEndTests.swift
index 8dedfd5..97c0c0a 100644
--- a/Tests/ArgumentParserEndToEndTests/LongNameWithShortDashEndToEndTests.swift
+++ b/Tests/ArgumentParserEndToEndTests/LongNameWithShortDashEndToEndTests.swift
@@ -110,6 +110,7 @@ extension LongNameWithSingleDashEndToEndTests {
 
 extension LongNameWithSingleDashEndToEndTests {
   private struct Issue327: ParsableCommand {
+    static var configuration = CommandConfiguration(shouldPromptForMissing: false)
     @Option(name: .customLong("argWithAnH", withSingleDash: true),
             parsing: .upToNextOption)
     var args: [String]
@@ -120,8 +121,9 @@ extension LongNameWithSingleDashEndToEndTests {
       XCTAssertEqual(issue327.args, ["03ade86c0", "8f2058e3ade86c84ec5b"])
     }
   }
-  
+
   private struct JoinedItem: ParsableCommand {
+    static var configuration = CommandConfiguration(shouldPromptForMissing: false)
     @Option(name: .customLong("argWithAnH", withSingleDash: true))
     var arg: String
   }
diff --git a/Tests/ArgumentParserEndToEndTests/NestedCommandEndToEndTests.swift b/Tests/ArgumentParserEndToEndTests/NestedCommandEndToEndTests.swift
index 1c5c520..e030c47 100644
--- a/Tests/ArgumentParserEndToEndTests/NestedCommandEndToEndTests.swift
+++ b/Tests/ArgumentParserEndToEndTests/NestedCommandEndToEndTests.swift
@@ -18,14 +18,16 @@ final class NestedCommandEndToEndTests: XCTestCase {
 
 // MARK: Single value String
 
-fileprivate struct Foo: ParsableCommand {
-  static var configuration =
-    CommandConfiguration(subcommands: [Build.self, Package.self])
+private struct Foo: ParsableCommand {
+  static var configuration = CommandConfiguration(
+    shouldPromptForMissing: false,
+    subcommands: [Build.self, Package.self])
 
   @Flag(name: .short)
   var verbose: Bool = false
 
   struct Build: ParsableCommand {
+    static var configuration = CommandConfiguration(shouldPromptForMissing: false)
     @OptionGroup() var foo: Foo
 
     @Argument()
@@ -33,18 +35,21 @@ fileprivate struct Foo: ParsableCommand {
   }
 
   struct Package: ParsableCommand {
-    static var configuration =
-      CommandConfiguration(subcommands: [Clean.self, Config.self])
+    static var configuration = CommandConfiguration(
+      shouldPromptForMissing: false,
+      subcommands: [Clean.self, Config.self])
 
     @Flag(name: .short)
     var force: Bool = false
 
     struct Clean: ParsableCommand {
+      static var configuration = CommandConfiguration(shouldPromptForMissing: false)
       @OptionGroup() var foo: Foo
       @OptionGroup() var package: Package
     }
 
     struct Config: ParsableCommand {
+      static var configuration = CommandConfiguration(shouldPromptForMissing: false)
       @OptionGroup() var foo: Foo
       @OptionGroup() var package: Package
     }
@@ -153,16 +158,18 @@ private struct UniqueOptions: ParsableArguments {
 
 private struct Super: ParsableCommand {
   static var configuration: CommandConfiguration {
-    .init(subcommands: [Sub1.self, Sub2.self])
+    .init(shouldPromptForMissing: false, subcommands: [Sub1.self, Sub2.self])
   }
 
   @OptionGroup() var options: Options
 
   struct Sub1: ParsableCommand {
+    static var configuration = CommandConfiguration(shouldPromptForMissing: false)
     @OptionGroup() var options: Options
   }
 
   struct Sub2: ParsableCommand {
+    static var configuration = CommandConfiguration(shouldPromptForMissing: false)
     @OptionGroup() var options: UniqueOptions
   }
 }
diff --git a/Tests/ArgumentParserEndToEndTests/OptionGroupEndToEndTests.swift b/Tests/ArgumentParserEndToEndTests/OptionGroupEndToEndTests.swift
index 20b1d9d..d53b8df 100644
--- a/Tests/ArgumentParserEndToEndTests/OptionGroupEndToEndTests.swift
+++ b/Tests/ArgumentParserEndToEndTests/OptionGroupEndToEndTests.swift
@@ -13,8 +13,7 @@ import XCTest
 import ArgumentParserTestHelpers
 import ArgumentParser
 
-final class OptionGroupEndToEndTests: XCTestCase {
-}
+final class OptionGroupEndToEndTests: XCTestCase { }
 
 fileprivate struct Inner: TestableParsableArguments {
   @Flag(name: [.short, .long])
@@ -43,6 +42,7 @@ fileprivate struct Outer: TestableParsableArguments {
   @Argument()
   var after: String
 
+  public static var shouldPromptForMissing: Bool { true }
   let didValidateExpectation = XCTestExpectation(singleExpectation: "outer validated")
 
   private enum CodingKeys: CodingKey {
diff --git a/Tests/ArgumentParserEndToEndTests/OptionalEndToEndTests.swift b/Tests/ArgumentParserEndToEndTests/OptionalEndToEndTests.swift
index 9148b3c..8c29a25 100644
--- a/Tests/ArgumentParserEndToEndTests/OptionalEndToEndTests.swift
+++ b/Tests/ArgumentParserEndToEndTests/OptionalEndToEndTests.swift
@@ -32,17 +32,17 @@ extension OptionalEndToEndTests {
       XCTAssertNil(foo.name)
       XCTAssertNil(foo.max)
     }
-    
+
     AssertParse(Foo.self, ["--name", "A"]) { foo in
       XCTAssertEqual(foo.name?.rawValue, "A")
       XCTAssertNil(foo.max)
     }
-    
+
     AssertParse(Foo.self, ["--max", "3"]) { foo in
       XCTAssertNil(foo.name)
       XCTAssertEqual(foo.max, 3)
     }
-    
+
     AssertParse(Foo.self, ["--max", "3", "--name", "A"]) { foo in
       XCTAssertEqual(foo.name?.rawValue, "A")
       XCTAssertEqual(foo.max, 3)
@@ -73,7 +73,7 @@ extension OptionalEndToEndTests {
       XCTAssertEqual(bar.bar, "D")
     }
   }
-  
+
   func testParsing_Optional_WithAllValues_2() {
     AssertParse(Bar.self, ["D", "--format", "B", "--foo", "C", "--name", "A"]) { bar in
       XCTAssertEqual(bar.name, "A")
@@ -82,7 +82,7 @@ extension OptionalEndToEndTests {
       XCTAssertEqual(bar.bar, "D")
     }
   }
-  
+
   func testParsing_Optional_WithAllValues_3() {
     AssertParse(Bar.self, ["--format", "B", "--foo", "C", "D", "--name", "A"]) { bar in
       XCTAssertEqual(bar.name, "A")
@@ -91,7 +91,7 @@ extension OptionalEndToEndTests {
       XCTAssertEqual(bar.bar, "D")
     }
   }
-  
+
   func testParsing_Optional_WithMissingValues_1() {
     AssertParse(Bar.self, ["--format", "B", "--foo", "C", "D"]) { bar in
       XCTAssertEqual(bar.name, nil)
@@ -100,7 +100,7 @@ extension OptionalEndToEndTests {
       XCTAssertEqual(bar.bar, "D")
     }
   }
-  
+
   func testParsing_Optional_WithMissingValues_2() {
     AssertParse(Bar.self, ["D", "--format", "B", "--foo", "C"]) { bar in
       XCTAssertEqual(bar.name, nil)
@@ -109,7 +109,7 @@ extension OptionalEndToEndTests {
       XCTAssertEqual(bar.bar, "D")
     }
   }
-  
+
   func testParsing_Optional_WithMissingValues_3() {
     AssertParse(Bar.self, ["--format", "B", "--foo", "C", "D"]) { bar in
       XCTAssertEqual(bar.name, nil)
@@ -118,7 +118,7 @@ extension OptionalEndToEndTests {
       XCTAssertEqual(bar.bar, "D")
     }
   }
-  
+
   func testParsing_Optional_WithMissingValues_4() {
     AssertParse(Bar.self, ["--name", "A", "--format", "B", "--foo", "C"]) { bar in
       XCTAssertEqual(bar.name, "A")
@@ -127,7 +127,7 @@ extension OptionalEndToEndTests {
       XCTAssertEqual(bar.bar, nil)
     }
   }
-  
+
   func testParsing_Optional_WithMissingValues_5() {
     AssertParse(Bar.self, ["--format", "B", "--foo", "C", "--name", "A"]) { bar in
       XCTAssertEqual(bar.name, "A")
@@ -136,7 +136,7 @@ extension OptionalEndToEndTests {
       XCTAssertEqual(bar.bar, nil)
     }
   }
-  
+
   func testParsing_Optional_WithMissingValues_6() {
     AssertParse(Bar.self, ["--format", "B", "--foo", "C", "--name", "A"]) { bar in
       XCTAssertEqual(bar.name, "A")
@@ -145,7 +145,7 @@ extension OptionalEndToEndTests {
       XCTAssertEqual(bar.bar, nil)
     }
   }
-  
+
   func testParsing_Optional_WithMissingValues_7() {
     AssertParse(Bar.self, ["--foo", "C"]) { bar in
       XCTAssertEqual(bar.name, nil)
@@ -154,7 +154,7 @@ extension OptionalEndToEndTests {
       XCTAssertEqual(bar.bar, nil)
     }
   }
-  
+
   func testParsing_Optional_WithMissingValues_8() {
     AssertParse(Bar.self, ["--format", "B", "--foo", "C"]) { bar in
       XCTAssertEqual(bar.name, nil)
@@ -163,7 +163,7 @@ extension OptionalEndToEndTests {
       XCTAssertEqual(bar.bar, nil)
     }
   }
-  
+
   func testParsing_Optional_WithMissingValues_9() {
     AssertParse(Bar.self, ["--format", "B", "--foo", "C"]) { bar in
       XCTAssertEqual(bar.name, nil)
@@ -172,7 +172,7 @@ extension OptionalEndToEndTests {
       XCTAssertEqual(bar.bar, nil)
     }
   }
-  
+
   func testParsing_Optional_WithMissingValues_10() {
     AssertParse(Bar.self, ["--format", "B", "--foo", "C"]) { bar in
       XCTAssertEqual(bar.name, nil)
@@ -181,7 +181,7 @@ extension OptionalEndToEndTests {
       XCTAssertEqual(bar.bar, nil)
     }
   }
-  
+
   func testParsing_Optional_WithMissingValues_11() {
     AssertParse(Bar.self, ["--format", "B", "--foo", "C", "--name", "A"]) { bar in
       XCTAssertEqual(bar.name, "A")
@@ -190,7 +190,7 @@ extension OptionalEndToEndTests {
       XCTAssertEqual(bar.bar, nil)
     }
   }
-  
+
   func testParsing_Optional_Fails() throws {
     XCTAssertThrowsError(try Bar.parse([]))
     XCTAssertThrowsError(try Bar.parse(["--format", "ZZ", "--foo", "C"]))
diff --git a/Tests/ArgumentParserEndToEndTests/PositionalEndToEndTests.swift b/Tests/ArgumentParserEndToEndTests/PositionalEndToEndTests.swift
index c1e3f1b..3558f32 100644
--- a/Tests/ArgumentParserEndToEndTests/PositionalEndToEndTests.swift
+++ b/Tests/ArgumentParserEndToEndTests/PositionalEndToEndTests.swift
@@ -43,7 +43,7 @@ extension PositionalEndToEndTests {
       XCTAssertEqual(bar.name, "--")
     }
   }
-  
+
   func testParsing_SinglePositional_Fails() throws {
     XCTAssertThrowsError(try Bar.parse([]))
     XCTAssertThrowsError(try Bar.parse(["--name"]))
@@ -81,7 +81,7 @@ extension PositionalEndToEndTests {
       XCTAssertEqual(baz.format, "--f")
     }
   }
-  
+
   func testParsing_TwoPositional_Fails() throws {
     XCTAssertThrowsError(try Baz.parse(["Bar", "Foo", "Baz"]))
     XCTAssertThrowsError(try Baz.parse(["Bar"]))
@@ -112,7 +112,7 @@ extension PositionalEndToEndTests {
     AssertParse(Qux.self, ["Bar", "Foo", "Baz"]) { qux in
       XCTAssertEqual(qux.names, ["Bar", "Foo", "Baz"])
     }
-    
+
     AssertParse(Qux.self, ["--", "--b", "--f"]) { qux in
       XCTAssertEqual(qux.names, ["--b", "--f"])
     }
@@ -120,7 +120,7 @@ extension PositionalEndToEndTests {
       XCTAssertEqual(qux.names, ["b", "--f"])
     }
   }
-  
+
   func testParsing_MultiplePositional_Fails() throws {
     // TODO: Allow zero-argument arrays?
     XCTAssertThrowsError(try Qux.parse(["--name", "Bar", "Foo"]))
@@ -154,7 +154,7 @@ extension PositionalEndToEndTests {
       XCTAssertEqual(wobble.count, 5)
       XCTAssertEqual(wobble.names, ["Bar", "Foo", "Baz"])
     }
-    
+
     AssertParse(Wobble.self, ["5", "--", "--b", "--f"]) { wobble in
       XCTAssertEqual(wobble.count, 5)
       XCTAssertEqual(wobble.names, ["--b", "--f"])
@@ -168,7 +168,7 @@ extension PositionalEndToEndTests {
       XCTAssertEqual(wobble.names, ["b", "--f"])
     }
   }
-  
+
   func testParsing_SingleAndMultiplePositional_Fails() throws {
     XCTAssertThrowsError(try Wobble.parse([]))
     XCTAssertThrowsError(try Wobble.parse(["--name", "Bar", "Foo"]))
@@ -194,7 +194,7 @@ extension PositionalEndToEndTests {
     AssertParse(Flob.self, ["5", "6"]) { flob in
       XCTAssertEqual(flob.counts, [5, 6])
     }
-    
+
     AssertParse(Flob.self, ["5", "--", "6"]) { flob in
       XCTAssertEqual(flob.counts, [5, 6])
     }
@@ -205,7 +205,7 @@ extension PositionalEndToEndTests {
       XCTAssertEqual(flob.counts, [5, 6])
     }
   }
-  
+
   func testParsing_MultipleParsedPositional_Fails() throws {
     XCTAssertThrowsError(try Flob.parse(["a"]))
     XCTAssertThrowsError(try Flob.parse(["5", "6", "a"]))
diff --git a/Tests/ArgumentParserEndToEndTests/RawRepresentableEndToEndTests.swift b/Tests/ArgumentParserEndToEndTests/RawRepresentableEndToEndTests.swift
index 4ab344b..c03290b 100644
--- a/Tests/ArgumentParserEndToEndTests/RawRepresentableEndToEndTests.swift
+++ b/Tests/ArgumentParserEndToEndTests/RawRepresentableEndToEndTests.swift
@@ -22,7 +22,7 @@ fileprivate struct Bar: ParsableArguments {
   struct Identifier: RawRepresentable, Equatable, ExpressibleByArgument {
     var rawValue: Int
   }
-  
+
   @Option() var identifier: Identifier
 }
 
@@ -32,13 +32,13 @@ extension RawRepresentableEndToEndTests {
       XCTAssertEqual(bar.identifier, Bar.Identifier(rawValue: 123))
     }
   }
-  
+
   func testParsing_SingleOptionMultipleTimes() throws {
     AssertParse(Bar.self, ["--identifier", "123", "--identifier", "456"]) { bar in
       XCTAssertEqual(bar.identifier, Bar.Identifier(rawValue: 456))
     }
   }
-  
+
   func testParsing_SingleOption_Fails() throws {
     XCTAssertThrowsError(try Bar.parse([]))
     XCTAssertThrowsError(try Bar.parse(["--identifier"]))
diff --git a/Tests/ArgumentParserEndToEndTests/RepeatingEndToEndTests.swift b/Tests/ArgumentParserEndToEndTests/RepeatingEndToEndTests.swift
index a25847a..7dd58ca 100644
--- a/Tests/ArgumentParserEndToEndTests/RepeatingEndToEndTests.swift
+++ b/Tests/ArgumentParserEndToEndTests/RepeatingEndToEndTests.swift
@@ -416,6 +416,7 @@ extension RepeatingEndToEndTests {
 // MARK: -
 
 struct PerformanceTest: ParsableCommand {
+  static var configuration = CommandConfiguration(shouldPromptForMissing: false)
   @Option(name: .short) var bundleIdentifiers: [String] = []
 
   mutating func run() throws { print(bundleIdentifiers) }
diff --git a/Tests/ArgumentParserEndToEndTests/SimpleEndToEndTests.swift b/Tests/ArgumentParserEndToEndTests/SimpleEndToEndTests.swift
index c8fd2ef..ae40352 100644
--- a/Tests/ArgumentParserEndToEndTests/SimpleEndToEndTests.swift
+++ b/Tests/ArgumentParserEndToEndTests/SimpleEndToEndTests.swift
@@ -31,7 +31,7 @@ extension SimpleEndToEndTests {
       XCTAssertEqual(bar.name, " foo ")
     }
   }
-  
+
   func testParsing_SingleOption_Fails() throws {
     XCTAssertThrowsError(try Bar.parse([]))
     XCTAssertThrowsError(try Bar.parse(["--name"]))
@@ -59,7 +59,7 @@ extension SimpleEndToEndTests {
       XCTAssertEqual(foo.count, 42)
     }
   }
-  
+
   func testParsing_SingleOption_Int_Fails() throws {
     XCTAssertThrowsError(try Foo.parse([]))
     XCTAssertThrowsError(try Foo.parse(["--count"]))
@@ -89,20 +89,20 @@ extension SimpleEndToEndTests {
       XCTAssertEqual(baz.format, "Foo")
     }
   }
-  
+
   func testParsing_TwoOptions_2() throws {
     AssertParse(Baz.self, ["--format", "Foo", "--name", "Bar"]) { baz in
       XCTAssertEqual(baz.name, "Bar")
       XCTAssertEqual(baz.format, "Foo")
     }
   }
-  
+
   func testParsing_TwoOptions_Fails() throws {
     XCTAssertThrowsError(try Baz.parse(["--nam", "Bar", "--format", "Foo"]))
     XCTAssertThrowsError(try Baz.parse(["--name", "Bar", "--forma", "Foo"]))
     XCTAssertThrowsError(try Baz.parse(["--name", "Bar"]))
     XCTAssertThrowsError(try Baz.parse(["--format", "Foo"]))
-    
+
     XCTAssertThrowsError(try Baz.parse(["--name", "--format", "Foo"]))
     XCTAssertThrowsError(try Baz.parse(["--name", "Bar", "--format"]))
     XCTAssertThrowsError(try Baz.parse(["--name", "Bar", "--format", "Foo", "Baz"]))
diff --git a/Tests/ArgumentParserEndToEndTests/SingleValueParsingStrategyTests.swift b/Tests/ArgumentParserEndToEndTests/SingleValueParsingStrategyTests.swift
index 8014a73..5fdab3d 100644
--- a/Tests/ArgumentParserEndToEndTests/SingleValueParsingStrategyTests.swift
+++ b/Tests/ArgumentParserEndToEndTests/SingleValueParsingStrategyTests.swift
@@ -32,7 +32,7 @@ extension SingleValueParsingStrategyTests {
       XCTAssertEqual(bar.input, "Baz")
     }
   }
-  
+
   func testParsing_scanningForValue_2() throws {
     AssertParse(Bar.self, ["--name", "--format", "Foo", "Bar", "--input", "Baz"]) { bar in
       XCTAssertEqual(bar.name, "Foo")
@@ -40,7 +40,7 @@ extension SingleValueParsingStrategyTests {
       XCTAssertEqual(bar.input, "Baz")
     }
   }
-  
+
   func testParsing_scanningForValue_3() throws {
     AssertParse(Bar.self, ["--name", "--format", "--input", "Foo", "Bar", "Baz"]) { bar in
       XCTAssertEqual(bar.name, "Foo")
@@ -66,7 +66,7 @@ extension SingleValueParsingStrategyTests {
       XCTAssertEqual(bar.input, "Baz")
     }
   }
-  
+
   func testParsing_unconditional_2() throws {
     AssertParse(Baz.self, ["--name", "--name", "--format", "--format", "--input", "--input"]) { bar in
       XCTAssertEqual(bar.name, "--name")
@@ -74,7 +74,7 @@ extension SingleValueParsingStrategyTests {
       XCTAssertEqual(bar.input, "--input")
     }
   }
-  
+
   func testParsing_unconditional_3() throws {
     AssertParse(Baz.self, ["--name", "-Foo", "--format", "-Bar", "--input", "-Baz"]) { bar in
       XCTAssertEqual(bar.name, "-Foo")
diff --git a/Tests/ArgumentParserEndToEndTests/SubcommandEndToEndTests.swift b/Tests/ArgumentParserEndToEndTests/SubcommandEndToEndTests.swift
index ed89a44..b75b3d8 100644
--- a/Tests/ArgumentParserEndToEndTests/SubcommandEndToEndTests.swift
+++ b/Tests/ArgumentParserEndToEndTests/SubcommandEndToEndTests.swift
@@ -20,7 +20,9 @@ final class SubcommandEndToEndTests: XCTestCase {
 
 fileprivate struct Foo: ParsableCommand {
   static var configuration =
-    CommandConfiguration(subcommands: [CommandA.self, CommandB.self])
+  CommandConfiguration(
+    shouldPromptForMissing: false,
+    subcommands: [CommandA.self, CommandB.self])
 
   @Option() var name: String
 }
@@ -226,11 +228,11 @@ extension SubcommandEndToEndTests {
     AssertParseCommand(BaseCommand.self,
                        BaseCommand.SubCommand.SubSubCommand.self,
                        ["--base-flag", BaseCommand.baseFlagValue, "sub", "--sub-flag", BaseCommand.SubCommand.subFlagValue, "subsub", "--sub-sub-flag"]) { cmd in
-                        XCTAssertTrue(cmd.subSubFlag)
+      XCTAssertTrue(cmd.subSubFlag)
 
-                        // make sure that the instance of SubSubCommand provided
-                        // had its validate method called, not just that any instance of SubSubCommand was validated
-                        wait(for: [cmd.didValidateExpectation], timeout: 0.1)
+      // make sure that the instance of SubSubCommand provided
+      // had its validate method called, not just that any instance of SubSubCommand was validated
+      wait(for: [cmd.didValidateExpectation], timeout: 0.1)
     }
   }
 }
diff --git a/Tests/ArgumentParserEndToEndTests/TransformEndToEndTests.swift b/Tests/ArgumentParserEndToEndTests/TransformEndToEndTests.swift
index 957eae5..1738879 100644
--- a/Tests/ArgumentParserEndToEndTests/TransformEndToEndTests.swift
+++ b/Tests/ArgumentParserEndToEndTests/TransformEndToEndTests.swift
@@ -41,35 +41,35 @@ fileprivate struct FooOption: Convert, ParsableArguments {
     See 'foo_option --help' for more information.
   """
   static var help: String = "Help:  --string <int_str>  Convert string to integer\n"
-  
+
   @Option(help: ArgumentHelp("Convert string to integer", valueName: "int_str"),
           transform: { try convert($0) })
   var string: Int
 }
 
 fileprivate struct BarOption: Convert, ParsableCommand {
-    
+
   static var usageString: String = """
   Usage: bar-option [--strings <int_str> ...]
     See 'bar-option --help' for more information.
   """
   static var help: String = "Help:  --strings <int_str>  Convert a list of strings to an array of integers\n"
-    
+
   @Option(help: ArgumentHelp("Convert a list of strings to an array of integers", valueName: "int_str"),
           transform: { try convert($0) })
   var strings: [Int] = []
 }
 
 extension TransformEndToEndTests {
-    
+
   // MARK: Single Values
-    
+
   func testSingleOptionTransform() throws {
     AssertParse(FooOption.self, ["--string", "42"]) { foo in
       XCTAssertEqual(foo.string, 42)
     }
   }
-    
+
   func testSingleOptionValidation_Fail_CustomErrorMessage() throws {
     AssertFullErrorMessage(FooOption.self, ["--string", "Forty Two"], "Error: The value 'Forty Two' is invalid for '--string <int_str>': Could not transform to an Int.\n" + FooOption.help + FooOption.usageString)
   }
@@ -79,17 +79,17 @@ extension TransformEndToEndTests {
   }
 
   // MARK: Arrays
-  
+
   func testOptionArrayTransform() throws {
     AssertParse(BarOption.self, ["--strings", "42", "--strings", "72", "--strings", "99"]) { bar in
       XCTAssertEqual(bar.strings, [42, 72, 99])
     }
   }
-  
+
   func testOptionArrayValidation_Fail_CustomErrorMessage() throws {
     AssertFullErrorMessage(BarOption.self, ["--strings", "Forty Two", "--strings", "72", "--strings", "99"], "Error: The value 'Forty Two' is invalid for '--strings <int_str>': Could not transform to an Int.\n" + BarOption.help + BarOption.usageString)
   }
-  
+
   func testOptionArrayValidation_Fail_DefaultErrorMessage() throws {
     AssertFullErrorMessage(BarOption.self, ["--strings", "4827", "--strings", "72", "--strings", "99"], "Error: The value '4827' is invalid for '--strings <int_str>': outOfBounds\n" + BarOption.help + BarOption.usageString)
   }
@@ -104,39 +104,39 @@ fileprivate struct FooArgument: Convert, ParsableArguments {
     See 'foo_argument --help' for more information.
   """
   static var help: String = "Help:  <int_str>  Convert string to integer\n"
-  
+
   enum FooError: Error {
       case outOfBounds
   }
-  
+
   @Argument(help: ArgumentHelp("Convert string to integer", valueName: "int_str"),
             transform: { try convert($0) })
   var string: Int
 }
 
 fileprivate struct BarArgument: Convert, ParsableCommand {
-    
+
   static var usageString: String = """
   Usage: bar-argument [<int_str> ...]
     See 'bar-argument --help' for more information.
   """
   static var help: String = "Help:  <int_str>  Convert a list of strings to an array of integers\n"
-  
+
   @Argument(help: ArgumentHelp("Convert a list of strings to an array of integers", valueName: "int_str"),
             transform: { try convert($0) })
   var strings: [Int] = []
 }
 
 extension TransformEndToEndTests {
-    
+
   // MARK: Single Values
-  
+
   func testArgumentTransform() throws {
     AssertParse(FooArgument.self, ["42"]) { foo in
       XCTAssertEqual(foo.string, 42)
     }
   }
-  
+
   func testArgumentValidation_Fail_CustomErrorMessage() throws {
     AssertFullErrorMessage(FooArgument.self, ["Forty Two"], "Error: The value 'Forty Two' is invalid for '<int_str>': Could not transform to an Int.\n" + FooArgument.help + FooArgument.usageString)
   }
@@ -144,19 +144,19 @@ extension TransformEndToEndTests {
   func testArgumentValidation_Fail_DefaultErrorMessage() throws {
     AssertFullErrorMessage(FooArgument.self, ["4827"], "Error: The value '4827' is invalid for '<int_str>': outOfBounds\n" + FooArgument.help + FooArgument.usageString)
   }
-  
+
   // MARK: Arrays
-  
+
   func testArgumentArrayTransform() throws {
     AssertParse(BarArgument.self, ["42", "72", "99"]) { bar in
       XCTAssertEqual(bar.strings, [42, 72, 99])
     }
   }
-  
+
   func testArgumentArrayValidation_Fail_CustomErrorMessage() throws {
     AssertFullErrorMessage(BarArgument.self, ["Forty Two", "72", "99"], "Error: The value 'Forty Two' is invalid for '<int_str>': Could not transform to an Int.\n" + BarArgument.help + BarArgument.usageString)
   }
-  
+
   func testArgumentArrayValidation_Fail_DefaultErrorMessage() throws {
     AssertFullErrorMessage(BarArgument.self, ["4827", "72", "99"], "Error: The value '4827' is invalid for '<int_str>': outOfBounds\n" + BarArgument.help + BarArgument.usageString)
   }
diff --git a/Tests/ArgumentParserEndToEndTests/UnparsedValuesEndToEndTest.swift b/Tests/ArgumentParserEndToEndTests/UnparsedValuesEndToEndTest.swift
index ccf2e6c..97c4992 100644
--- a/Tests/ArgumentParserEndToEndTests/UnparsedValuesEndToEndTest.swift
+++ b/Tests/ArgumentParserEndToEndTests/UnparsedValuesEndToEndTest.swift
@@ -41,14 +41,14 @@ extension UnparsedValuesEndToEndTests {
       XCTAssertTrue(qux.verbose)
       XCTAssertEqual(qux.count, 0)
     }
-    
+
     AssertParse(Quizzo.self, ["--name", "Qux", "--verbose"]) { quizzo in
       XCTAssertEqual(quizzo.name, "Qux")
       XCTAssertTrue(quizzo.verbose)
       XCTAssertEqual(quizzo.count, 0)
     }
   }
-  
+
   func testParsing_TwoPlusUnparsed_Fails() throws {
     XCTAssertThrowsError(try Qux.parse([]))
     XCTAssertThrowsError(try Qux.parse(["--name"]))
@@ -86,7 +86,7 @@ extension UnparsedValuesEndToEndTests {
     AssertParse(Hogeraa.self, []) { hogeraa in
       XCTAssertEqual(hogeraa.fullName, "Full Name")
     }
-    
+
     AssertParse(Hogera.self, ["--first-name", "Hogera"]) { hogera in
       XCTAssertEqual(hogera.firstName, "Hogera")
       XCTAssertFalse(hogera.hasLastName)
@@ -97,7 +97,7 @@ extension UnparsedValuesEndToEndTests {
       XCTAssertTrue(hogera.hasLastName)
       XCTAssertEqual(hogera.fullName, "Hogera LastName")
     }
-    
+
     AssertParse(Piyo.self, ["--first-name", "Hogera"]) { piyo in
       XCTAssertEqual(piyo.firstName, "Hogera")
       XCTAssertFalse(piyo.hasLastName)
@@ -109,7 +109,7 @@ extension UnparsedValuesEndToEndTests {
       XCTAssertEqual(piyo.fullName, "Hogera LastName")
     }
   }
-  
+
   func testParsing_TwoPlusOptionalUnparsed_Fails() throws {
     XCTAssertThrowsError(try Hogeraa.parse(["--full-name"]))
     XCTAssertThrowsError(try Hogeraa.parse(["--full-name", "Hogera Piyo"]))
@@ -128,6 +128,7 @@ extension UnparsedValuesEndToEndTests {
 
 
 fileprivate struct Foo: ParsableCommand {
+  static var configuration = CommandConfiguration(shouldPromptForMissing: false)
   @Flag var foo: Bool = false
   var config: Config?
   @OptionGroup var opt: OptionalArguments
@@ -167,7 +168,7 @@ extension UnparsedValuesEndToEndTests {
       XCTAssertEqual(1, foo.def.two)
     }
   }
-  
+
   func testUnparsedNestedValues_Fails() {
     XCTAssertThrowsError(try Foo.parse(["--edition", "aaa"]))
     XCTAssertThrowsError(try Foo.parse(["--one", "aaa"]))
@@ -177,10 +178,12 @@ extension UnparsedValuesEndToEndTests {
 // MARK: Nested unparsed optional decodable type
 
 fileprivate struct Barr: ParsableCommand {
+  static var configuration = CommandConfiguration(shouldPromptForMissing: false)
   var baz: Baz? = Baz(name: "Some Name", age: 105)
 }
 
 fileprivate struct Bar: ParsableCommand {
+  static var configuration = CommandConfiguration(shouldPromptForMissing: false)
   @Flag var bar: Bool = false
   var baz: Baz?
   var bazz: Bazz?
@@ -209,7 +212,7 @@ extension UnparsedValuesEndToEndTests {
       XCTAssertEqual(barr.baz?.age, 105)
       XCTAssertEqual(barr.baz?.name, "Some Name")
     }
-    
+
     AssertParse(Bar.self, []) { bar in
       XCTAssertFalse(bar.bar)
       XCTAssertNil(bar.baz)
@@ -230,7 +233,7 @@ extension UnparsedValuesEndToEndTests {
       XCTAssertEqual(bar.bazz?.age, 101)
     }
   }
-  
+
   func testUnparsedNestedOptionalValue_Fails() {
     XCTAssertThrowsError(try Bar.parse(["--baz", "xyz"]))
     XCTAssertThrowsError(try Bar.parse(["--bazz", "xyz"]))
diff --git a/Tests/ArgumentParserEndToEndTests/ValidationEndToEndTests.swift b/Tests/ArgumentParserEndToEndTests/ValidationEndToEndTests.swift
index b4222bc..a6c0a92 100644
--- a/Tests/ArgumentParserEndToEndTests/ValidationEndToEndTests.swift
+++ b/Tests/ArgumentParserEndToEndTests/ValidationEndToEndTests.swift
@@ -148,6 +148,7 @@ extension ValidationEndToEndTests {
 }
 
 fileprivate struct FooCommand: ParsableCommand {
+  static var configuration = CommandConfiguration(shouldPromptForMissing: false)
   @Flag(help: .hidden)
   var foo = false
   @Flag(help: .hidden)
diff --git a/Tests/ArgumentParserExampleTests/CountLinesExampleTests.swift b/Tests/ArgumentParserExampleTests/CountLinesExampleTests.swift
index 56b54d5..e7cfbdb 100644
--- a/Tests/ArgumentParserExampleTests/CountLinesExampleTests.swift
+++ b/Tests/ArgumentParserExampleTests/CountLinesExampleTests.swift
@@ -21,7 +21,7 @@ final class CountLinesExampleTests: XCTestCase {
     try AssertExecuteCommand(command: "count-lines \(testFile.path)", expected: "20")
     try AssertExecuteCommand(command: "count-lines \(testFile.path) --prefix al", expected: "4")
   }
-  
+
   func testCountLinesHelp() throws {
     guard #available(macOS 12, *) else { return }
     let helpText = """
diff --git a/Tests/ArgumentParserExampleTests/MathExampleTests.swift b/Tests/ArgumentParserExampleTests/MathExampleTests.swift
index d687e29..27773de 100644
--- a/Tests/ArgumentParserExampleTests/MathExampleTests.swift
+++ b/Tests/ArgumentParserExampleTests/MathExampleTests.swift
@@ -18,7 +18,7 @@ final class MathExampleTests: XCTestCase {
     try AssertExecuteCommand(command: "math 1 2 3 4 5", expected: "15")
     try AssertExecuteCommand(command: "math multiply 1 2 3 4 5", expected: "120")
   }
-  
+
   func testMath_Help() throws {
     let helpText = """
         OVERVIEW: A utility for performing maths.
@@ -36,12 +36,12 @@ final class MathExampleTests: XCTestCase {
 
           See 'math help <subcommand>' for detailed help.
         """
-    
+
     try AssertExecuteCommand(command: "math -h", expected: helpText)
     try AssertExecuteCommand(command: "math --help", expected: helpText)
     try AssertExecuteCommand(command: "math help", expected: helpText)
   }
-  
+
   func testMath_AddHelp() throws {
     let helpText = """
         OVERVIEW: Print the sum of the values.
@@ -56,17 +56,17 @@ final class MathExampleTests: XCTestCase {
           --version               Show the version.
           -h, --help              Show help information.
         """
-    
+
     try AssertExecuteCommand(command: "math add -h", expected: helpText)
     try AssertExecuteCommand(command: "math add --help", expected: helpText)
     try AssertExecuteCommand(command: "math help add", expected: helpText)
-    
+
     // Verify that extra help flags are ignored.
     try AssertExecuteCommand(command: "math help add -h", expected: helpText)
     try AssertExecuteCommand(command: "math help add -help", expected: helpText)
     try AssertExecuteCommand(command: "math help add --help", expected: helpText)
   }
-  
+
   func testMath_StatsMeanHelp() throws {
     let helpText = """
         OVERVIEW: Print the average of the values.
@@ -81,12 +81,12 @@ final class MathExampleTests: XCTestCase {
           --version               Show the version.
           -h, --help              Show help information.
         """
-    
+
     try AssertExecuteCommand(command: "math stats average -h", expected: helpText)
     try AssertExecuteCommand(command: "math stats average --help", expected: helpText)
     try AssertExecuteCommand(command: "math help stats average", expected: helpText)
   }
-  
+
   func testMath_StatsQuantilesHelp() throws {
     let helpText = """
         OVERVIEW: Print the quantiles of the values (TBD).
@@ -106,16 +106,16 @@ final class MathExampleTests: XCTestCase {
           --version               Show the version.
           -h, --help              Show help information.
         """
-    
+
     // The "quantiles" subcommand's run() method is unimplemented, so it
     // just generates the help text.
     try AssertExecuteCommand(command: "math stats quantiles", expected: helpText)
-    
+
     try AssertExecuteCommand(command: "math stats quantiles -h", expected: helpText)
     try AssertExecuteCommand(command: "math stats quantiles --help", expected: helpText)
     try AssertExecuteCommand(command: "math help stats quantiles", expected: helpText)
   }
-  
+
   func testMath_CustomValidation() throws {
     try AssertExecuteCommand(
       command: "math stats average --kind mode",
@@ -126,7 +126,7 @@ final class MathExampleTests: XCTestCase {
             """,
       exitCode: .validationFailure)
   }
-  
+
   func testMath_Versions() throws {
     try AssertExecuteCommand(
       command: "math --version",
@@ -157,7 +157,7 @@ final class MathExampleTests: XCTestCase {
       expected: "",
       exitCode: ExitCode(42))
   }
-  
+
   func testMath_Fail() throws {
     try AssertExecuteCommand(
       command: "math --foo",
@@ -167,7 +167,7 @@ final class MathExampleTests: XCTestCase {
               See 'math add --help' for more information.
             """,
       exitCode: .validationFailure)
-    
+
     try AssertExecuteCommand(
       command: "math ZZZ",
       expected: """
@@ -203,7 +203,7 @@ extension MathExampleTests {
       command: "math --generate-completion-script fish",
       expected: fishCompletionScriptText)
   }
-  
+
   func testMath_CustomCompletion() throws {
     try AssertExecuteCommand(
       command: "math ---completion stats quantiles -- --custom",
@@ -212,7 +212,7 @@ extension MathExampleTests {
         helicopter
         heliotrope
         """)
-    
+
     try AssertExecuteCommand(
       command: "math ---completion stats quantiles -- --custom h",
       expected: """
@@ -220,7 +220,7 @@ extension MathExampleTests {
         helicopter
         heliotrope
         """)
-  
+
     try AssertExecuteCommand(
       command: "math ---completion stats quantiles -- --custom a",
       expected: """
diff --git a/Tests/ArgumentParserExampleTests/RepeatExampleTests.swift b/Tests/ArgumentParserExampleTests/RepeatExampleTests.swift
index 9f0e245..8efddff 100644
--- a/Tests/ArgumentParserExampleTests/RepeatExampleTests.swift
+++ b/Tests/ArgumentParserExampleTests/RepeatExampleTests.swift
@@ -19,14 +19,14 @@ final class RepeatExampleTests: XCTestCase {
         hello
         """)
   }
-  
+
   func testRepeat_include_counter() throws {
     try AssertExecuteCommand(command: "repeat --include-counter hello", expected: """
       1: hello
       2: hello
       """)
   }
-  
+
   func testRepeat_Count() throws {
     try AssertExecuteCommand(command: "repeat hello --count 6", expected: """
         hello
@@ -37,7 +37,7 @@ final class RepeatExampleTests: XCTestCase {
         hello
         """)
   }
-  
+
   func testRepeat_Help() throws {
     let helpText = """
         USAGE: repeat [--count <count>] [--include-counter] <phrase>
@@ -50,11 +50,11 @@ final class RepeatExampleTests: XCTestCase {
           --include-counter       Include a counter with each repetition.
           -h, --help              Show help information.
         """
-    
+
     try AssertExecuteCommand(command: "repeat -h", expected: helpText)
     try AssertExecuteCommand(command: "repeat --help", expected: helpText)
   }
-  
+
   func testRepeat_Fail() throws {
     try AssertExecuteCommand(
       command: "repeat",
@@ -82,7 +82,7 @@ final class RepeatExampleTests: XCTestCase {
               See 'repeat --help' for more information.
             """,
       exitCode: .validationFailure)
-    
+
     try AssertExecuteCommand(
       command: "repeat hello --count ZZZ",
       expected: """
@@ -92,7 +92,7 @@ final class RepeatExampleTests: XCTestCase {
               See 'repeat --help' for more information.
             """,
       exitCode: .validationFailure)
-    
+
     try AssertExecuteCommand(
       command: "repeat --version hello",
       expected: """
diff --git a/Tests/ArgumentParserExampleTests/RollDiceExampleTests.swift b/Tests/ArgumentParserExampleTests/RollDiceExampleTests.swift
index 32b3629..75ea43c 100644
--- a/Tests/ArgumentParserExampleTests/RollDiceExampleTests.swift
+++ b/Tests/ArgumentParserExampleTests/RollDiceExampleTests.swift
@@ -16,7 +16,7 @@ final class RollDiceExampleTests: XCTestCase {
   func testRollDice() throws {
     try AssertExecuteCommand(command: "roll --times 6")
   }
-  
+
   func testRollDice_Help() throws {
     let helpText = """
         USAGE: roll [--times <n>] [--sides <m>] [--seed <seed>] [--verbose]
@@ -29,11 +29,11 @@ final class RollDiceExampleTests: XCTestCase {
           -v, --verbose           Show all roll results.
           -h, --help              Show help information.
         """
-    
+
     try AssertExecuteCommand(command: "roll -h", expected: helpText)
     try AssertExecuteCommand(command: "roll --help", expected: helpText)
   }
-  
+
   func testRollDice_Fail() throws {
     try AssertExecuteCommand(
       command: "roll --times",
@@ -44,7 +44,7 @@ final class RollDiceExampleTests: XCTestCase {
               See 'roll --help' for more information.
             """,
       exitCode: .validationFailure)
-    
+
     try AssertExecuteCommand(
       command: "roll --times ZZZ",
       expected: """
diff --git a/Tests/ArgumentParserGenerateManualTests/CountLinesGenerateManualTests.swift b/Tests/ArgumentParserGenerateManualTests/CountLinesGenerateManualTests.swift
index fd9f824..7d704f6 100644
--- a/Tests/ArgumentParserGenerateManualTests/CountLinesGenerateManualTests.swift
+++ b/Tests/ArgumentParserGenerateManualTests/CountLinesGenerateManualTests.swift
@@ -55,7 +55,7 @@ final class CountLinesGenerateManualTests: XCTestCase {
       .Ac .
       """#)
   }
-  
+
   func testCountLines_MultiPageManual() throws {
     guard #available(macOS 12, *) else { return }
     try AssertGenerateManual(singlePage: false, command: "count-lines", expected: #"""
diff --git a/Tests/ArgumentParserPackageManagerTests/HelpTests.swift b/Tests/ArgumentParserPackageManagerTests/HelpTests.swift
index aa52bf8..bd9ff3b 100644
--- a/Tests/ArgumentParserPackageManagerTests/HelpTests.swift
+++ b/Tests/ArgumentParserPackageManagerTests/HelpTests.swift
@@ -44,7 +44,7 @@ extension HelpTests {
   func testGlobalHelp() throws {
     XCTAssertEqual(
       getErrorText(Package.self, ["help"]).trimmingLines(),
-      """
+                """
                 USAGE: package <subcommand>
 
                 OPTIONS:
@@ -63,7 +63,7 @@ extension HelpTests {
   func testGlobalHelp_messageForCleanExit_helpRequest() throws {
     XCTAssertEqual(
       Package.message(for: CleanExit.helpRequest()).trimmingLines(),
-      """
+                """
                 USAGE: package <subcommand>
 
                 OPTIONS:
@@ -91,7 +91,7 @@ extension HelpTests {
   func testConfigHelp() throws {
     XCTAssertEqual(
       getErrorText(Package.self, ["help", "config"], screenWidth: 80).trimmingLines(),
-      """
+                """
                 USAGE: package config <subcommand>
 
                 OPTIONS:
@@ -109,7 +109,7 @@ extension HelpTests {
   func testGetMirrorHelp() throws {
     XCTAssertEqual(
       getErrorText(Package.self, ["help", "config",  "get-mirror"], screenWidth: 80).trimmingLines(),
-      """
+                """
                 USAGE: package config get-mirror [<options>] --package-url <package-url>
 
                 OPTIONS:
@@ -187,6 +187,7 @@ extension HelpTests {
 
 struct CustomHelp: ParsableCommand {
   static let configuration = CommandConfiguration(
+    shouldPromptForMissing: false,
     helpNames: [.customShort("?"), .customLong("show-help")]
   )
 }
@@ -208,6 +209,7 @@ extension HelpTests {
 
 struct NoHelp: ParsableCommand {
   static let configuration = CommandConfiguration(
+    shouldPromptForMissing: false,
     helpNames: []
   )
 
@@ -229,7 +231,7 @@ extension HelpTests {
 
     XCTAssertEqual(
       NoHelp.message(for: CleanExit.helpRequest()).trimmingLines(),
-      """
+            """
             USAGE: no-help --count <count>
 
             OPTIONS:
@@ -241,20 +243,22 @@ extension HelpTests {
 
 struct SubCommandCustomHelp: ParsableCommand {
   static var configuration = CommandConfiguration (
+    shouldPromptForMissing: false,
     helpNames: [.customShort("p"), .customLong("parent-help")]
   )
 
   struct InheritHelp: ParsableCommand {
-
+    static let configuration = CommandConfiguration(shouldPromptForMissing: false)
   }
 
   struct ModifiedHelp: ParsableCommand {
     static var configuration = CommandConfiguration (
+      shouldPromptForMissing: false,
       helpNames: [.customShort("s"), .customLong("subcommand-help")]
     )
 
     struct InheritImmediateParentdHelp: ParsableCommand {
-
+      static var configuration = CommandConfiguration (shouldPromptForMissing: false)
     }
   }
 }
diff --git a/Tests/ArgumentParserPackageManagerTests/PackageManager/Clean.swift b/Tests/ArgumentParserPackageManagerTests/PackageManager/Clean.swift
index f787b5f..e299b77 100644
--- a/Tests/ArgumentParserPackageManagerTests/PackageManager/Clean.swift
+++ b/Tests/ArgumentParserPackageManagerTests/PackageManager/Clean.swift
@@ -13,6 +13,7 @@ import ArgumentParser
 
 extension Package {
   struct Clean: ParsableCommand {
+    static var configuration = CommandConfiguration(shouldPromptForMissing: false)
     @OptionGroup()
     var options: Options
   }
diff --git a/Tests/ArgumentParserPackageManagerTests/PackageManager/Config.swift b/Tests/ArgumentParserPackageManagerTests/PackageManager/Config.swift
index 8d19a6d..59fb41b 100644
--- a/Tests/ArgumentParserPackageManagerTests/PackageManager/Config.swift
+++ b/Tests/ArgumentParserPackageManagerTests/PackageManager/Config.swift
@@ -13,42 +13,45 @@ import ArgumentParser
 
 extension Package {
   /// Manipulate configuration of the package
-  struct Config: ParsableCommand {}
+  struct Config: ParsableCommand { }
 }
 
 extension Package.Config {
   public static var configuration = CommandConfiguration(
     subcommands: [GetMirror.self, SetMirror.self, UnsetMirror.self])
-  
+
   /// Print mirror configuration for the given package dependency
   struct GetMirror: ParsableCommand {
+    static var configuration = CommandConfiguration(shouldPromptForMissing: false)
     @OptionGroup()
     var options: Options
-    
+
     @Option(name: .customLong("package-url"), help: "The package dependency URL")
     var packageURL: String
   }
-  
+
   /// Set a mirror for a dependency
   struct SetMirror: ParsableCommand {
+    static var configuration = CommandConfiguration(shouldPromptForMissing: false)
     @OptionGroup()
     var options: Options
-    
+
     @Option(name: .customLong("mirror-url"), help: "The mirror URL")
     var mirrorURL: String
-    
+
     @Option(name: .customLong("package-url"), help: "The package dependency URL")
     var packageURL: String
   }
-  
+
   /// Remove an existing mirror
   struct UnsetMirror: ParsableCommand {
+    static var configuration = CommandConfiguration(shouldPromptForMissing: false)
     @OptionGroup()
     var options: Options
-    
+
     @Option(name: .customLong("mirror-url"), help: "The mirror URL")
     var mirrorURL: String
-    
+
     @Option(name: .customLong("package-url"), help: "The package dependency URL")
     var packageURL: String
   }
diff --git a/Tests/ArgumentParserPackageManagerTests/PackageManager/Describe.swift b/Tests/ArgumentParserPackageManagerTests/PackageManager/Describe.swift
index 844ee5e..f650c91 100644
--- a/Tests/ArgumentParserPackageManagerTests/PackageManager/Describe.swift
+++ b/Tests/ArgumentParserPackageManagerTests/PackageManager/Describe.swift
@@ -14,12 +14,13 @@ import ArgumentParser
 extension Package {
   /// Describe the current package
   struct Describe: ParsableCommand {
+    static var configuration = CommandConfiguration(shouldPromptForMissing: false)
     @OptionGroup()
     var options: Options
-    
+
     @Option(help: "Output format")
     var type: OutputType
-    
+
     enum OutputType: String, ExpressibleByArgument, Decodable {
       case json
       case text
diff --git a/Tests/ArgumentParserPackageManagerTests/PackageManager/GenerateXcodeProject.swift b/Tests/ArgumentParserPackageManagerTests/PackageManager/GenerateXcodeProject.swift
index d4a0fed..4424191 100644
--- a/Tests/ArgumentParserPackageManagerTests/PackageManager/GenerateXcodeProject.swift
+++ b/Tests/ArgumentParserPackageManagerTests/PackageManager/GenerateXcodeProject.swift
@@ -14,8 +14,9 @@ import ArgumentParser
 extension Package {
   /// Generates an Xcode project
   struct GenerateXcodeProject: ParsableCommand {
-    static var configuration =
-      CommandConfiguration(commandName: "generate-xcodeproj")
+    static var configuration = CommandConfiguration(
+      commandName: "generate-xcodeproj",
+      shouldPromptForMissing: false)
 
     @OptionGroup()
     var options: Options
diff --git a/Tests/ArgumentParserPackageManagerTests/PackageManager/Options.swift b/Tests/ArgumentParserPackageManagerTests/PackageManager/Options.swift
index ccdbc5a..2f5165c 100644
--- a/Tests/ArgumentParserPackageManagerTests/PackageManager/Options.swift
+++ b/Tests/ArgumentParserPackageManagerTests/PackageManager/Options.swift
@@ -89,11 +89,13 @@ struct Options: ParsableArguments {
 
 struct Package: ParsableCommand {
   static var configuration = CommandConfiguration(
+    shouldPromptForMissing: false,
     subcommands: [Clean.self, Config.self, Describe.self, GenerateXcodeProject.self, Hidden.self])
 }
 
 extension Package {
   struct Hidden: ParsableCommand {
-    static var configuration = CommandConfiguration(shouldDisplay: false)
+    static var configuration = CommandConfiguration(
+      shouldDisplay: false, shouldPromptForMissing: false)
   }
 }
diff --git a/Tests/ArgumentParserPackageManagerTests/Tests.swift b/Tests/ArgumentParserPackageManagerTests/Tests.swift
index 54db792..613a51a 100644
--- a/Tests/ArgumentParserPackageManagerTests/Tests.swift
+++ b/Tests/ArgumentParserPackageManagerTests/Tests.swift
@@ -39,13 +39,13 @@ extension Tests {
       XCTAssertEqual(options.swiftCompilerFlags, [])
     }
   }
-  
+
   func testParsingWithGlobalOption_1() {
     AssertParseCommand(Package.self, Package.GenerateXcodeProject.self, ["generate-xcodeproj", "--watch", "--output", "Foo", "--enable-automatic-resolution"]) { generate in
       XCTAssertEqual(generate.output, "Foo")
       XCTAssertFalse(generate.enableCodeCoverage)
       XCTAssertTrue(generate.watch)
-      
+
       let options = generate.options
       // Default global option
       XCTAssertEqual(options.configuration, .debug)
@@ -53,13 +53,13 @@ extension Tests {
       XCTAssertEqual(options.automaticResolution, true)
     }
   }
-  
+
   func testParsingWithGlobalOption_2() {
     AssertParseCommand(Package.self, Package.GenerateXcodeProject.self, ["generate-xcodeproj", "--watch", "--output", "Foo", "--enable-automatic-resolution", "-Xcc", "-Ddebug"]) { generate in
       XCTAssertEqual(generate.output, "Foo")
       XCTAssertFalse(generate.enableCodeCoverage)
       XCTAssertTrue(generate.watch)
-      
+
       let options = generate.options
       // Default global option
       XCTAssertEqual(options.configuration, .debug)
@@ -68,13 +68,13 @@ extension Tests {
       XCTAssertEqual(options.cCompilerFlags, ["-Ddebug"])
     }
   }
-  
+
   func testParsingWithGlobalOption_3() {
     AssertParseCommand(Package.self, Package.GenerateXcodeProject.self, ["generate-xcodeproj", "--watch", "--output=Foo", "--enable-automatic-resolution", "-Xcc=-Ddebug"]) { generate in
       XCTAssertEqual(generate.output, "Foo")
       XCTAssertFalse(generate.enableCodeCoverage)
       XCTAssertTrue(generate.watch)
-      
+
       let options = generate.options
       // Default global option
       XCTAssertEqual(options.configuration, .debug)
diff --git a/Tests/ArgumentParserUnitTests/CompletionScriptTests.swift b/Tests/ArgumentParserUnitTests/CompletionScriptTests.swift
index ab8b3ad..ac57534 100644
--- a/Tests/ArgumentParserUnitTests/CompletionScriptTests.swift
+++ b/Tests/ArgumentParserUnitTests/CompletionScriptTests.swift
@@ -19,67 +19,68 @@ final class CompletionScriptTests: XCTestCase {
 extension CompletionScriptTests {
   struct Path: ExpressibleByArgument {
     var path: String
-    
+
     init?(argument: String) {
       self.path = argument
     }
-    
+
     static var defaultCompletionKind: CompletionKind {
       .file()
     }
   }
-    
+
   enum Kind: String, ExpressibleByArgument, CaseIterable {
     case one, two, three = "custom-three"
   }
-  
+
   struct Base: ParsableCommand {
+    static var configuration = CommandConfiguration(shouldPromptForMissing: false)
     @Option(help: "The user's name.") var name: String
     @Option() var kind: Kind
     @Option(completion: .list(["1", "2", "3"])) var otherKind: Kind
-    
+
     @Option() var path1: Path
     @Option() var path2: Path?
     @Option(completion: .list(["a", "b", "c"])) var path3: Path
-    
+
     @Flag(help: .hidden) var verbose = false
   }
 
   func testBase_Zsh() throws {
     let script1 = try CompletionsGenerator(command: Base.self, shell: .zsh)
-          .generateCompletionScript()
+      .generateCompletionScript()
     XCTAssertEqual(zshBaseCompletions, script1)
-    
+
     let script2 = try CompletionsGenerator(command: Base.self, shellName: "zsh")
-          .generateCompletionScript()
+      .generateCompletionScript()
     XCTAssertEqual(zshBaseCompletions, script2)
-    
+
     let script3 = Base.completionScript(for: .zsh)
     XCTAssertEqual(zshBaseCompletions, script3)
   }
 
   func testBase_Bash() throws {
     let script1 = try CompletionsGenerator(command: Base.self, shell: .bash)
-          .generateCompletionScript()
+      .generateCompletionScript()
     XCTAssertEqual(bashBaseCompletions, script1)
-    
+
     let script2 = try CompletionsGenerator(command: Base.self, shellName: "bash")
-          .generateCompletionScript()
+      .generateCompletionScript()
     XCTAssertEqual(bashBaseCompletions, script2)
-    
+
     let script3 = Base.completionScript(for: .bash)
     XCTAssertEqual(bashBaseCompletions, script3)
   }
 
   func testBase_Fish() throws {
     let script1 = try CompletionsGenerator(command: Base.self, shell: .fish)
-          .generateCompletionScript()
+      .generateCompletionScript()
     XCTAssertEqual(fishBaseCompletions, script1)
-    
+
     let script2 = try CompletionsGenerator(command: Base.self, shellName: "fish")
-          .generateCompletionScript()
+      .generateCompletionScript()
     XCTAssertEqual(fishBaseCompletions, script2)
-    
+
     let script3 = Base.completionScript(for: .fish)
     XCTAssertEqual(fishBaseCompletions, script3)
   }
@@ -87,6 +88,7 @@ extension CompletionScriptTests {
 
 extension CompletionScriptTests {
   struct Custom: ParsableCommand {
+    static var configuration = CommandConfiguration(shouldPromptForMissing: false)
     @Option(name: .shortAndLong, completion: .custom { _ in ["a", "b", "c"] })
     var one: String
 
@@ -96,7 +98,7 @@ extension CompletionScriptTests {
     @Option(name: .customShort("z"), completion: .custom { _ in ["x", "y", "z"] })
     var three: String
   }
-  
+
   func verifyCustomOutput(
     _ arg: String,
     expectedOutput: String,
@@ -112,22 +114,23 @@ extension CompletionScriptTests {
       XCTAssertEqual(expectedOutput, output, file: (file), line: line)
     }
   }
-  
+
   func testCustomCompletions() throws {
     try verifyCustomOutput("-o", expectedOutput: "a\nb\nc")
     try verifyCustomOutput("--one", expectedOutput: "a\nb\nc")
     try verifyCustomOutput("two", expectedOutput: "d\ne\nf")
     try verifyCustomOutput("-z", expectedOutput: "x\ny\nz")
-    
+
     XCTAssertThrowsError(try verifyCustomOutput("--bad", expectedOutput: ""))
   }
 }
 
 extension CompletionScriptTests {
   struct EscapedCommand: ParsableCommand {
+    static var configuration = CommandConfiguration(shouldPromptForMissing: false)
     @Option(help: #"Escaped chars: '[]\."#)
     var one: String
-    
+
     @Argument(completion: .custom { _ in ["d", "e", "f"] })
     var two: String
   }
@@ -271,21 +274,24 @@ complete -c base -n '_swift_base_using_command base' -f -s h -l help -d 'Show he
 
 // MARK: - Test Hidden Subcommand
 struct Parent: ParsableCommand {
-    static var configuration = CommandConfiguration(subcommands: [HiddenChild.self])
+  static var configuration = CommandConfiguration(
+    shouldPromptForMissing: false,
+    subcommands: [HiddenChild.self])
 }
 
 struct HiddenChild: ParsableCommand {
-    static var configuration = CommandConfiguration(shouldDisplay: false)
+  static var configuration = CommandConfiguration(
+    shouldDisplay: false, shouldPromptForMissing: false)
 }
 
 extension CompletionScriptTests {
   func testHiddenSubcommand_Zsh() throws {
     let script1 = try CompletionsGenerator(command: Parent.self, shell: .zsh)
-          .generateCompletionScript()
+      .generateCompletionScript()
     XCTAssertEqual(zshHiddenCompletion, script1)
 
     let script2 = try CompletionsGenerator(command: Parent.self, shellName: "zsh")
-          .generateCompletionScript()
+      .generateCompletionScript()
     XCTAssertEqual(zshHiddenCompletion, script2)
 
     let script3 = Parent.completionScript(for: .zsh)
@@ -294,11 +300,11 @@ extension CompletionScriptTests {
 
   func testHiddenSubcommand_Bash() throws {
     let script1 = try CompletionsGenerator(command: Parent.self, shell: .bash)
-          .generateCompletionScript()
+      .generateCompletionScript()
     XCTAssertEqual(bashHiddenCompletion, script1)
 
     let script2 = try CompletionsGenerator(command: Parent.self, shellName: "bash")
-          .generateCompletionScript()
+      .generateCompletionScript()
     XCTAssertEqual(bashHiddenCompletion, script2)
 
     let script3 = Parent.completionScript(for: .bash)
@@ -307,11 +313,11 @@ extension CompletionScriptTests {
 
   func testHiddenSubcommand_Fish() throws {
     let script1 = try CompletionsGenerator(command: Parent.self, shell: .fish)
-          .generateCompletionScript()
+      .generateCompletionScript()
     XCTAssertEqual(fishHiddenCompletion, script1)
 
     let script2 = try CompletionsGenerator(command: Parent.self, shellName: "fish")
-          .generateCompletionScript()
+      .generateCompletionScript()
     XCTAssertEqual(fishHiddenCompletion, script2)
 
     let script3 = Parent.completionScript(for: .fish)
diff --git a/Tests/ArgumentParserUnitTests/DumpHelpGenerationTests.swift b/Tests/ArgumentParserUnitTests/DumpHelpGenerationTests.swift
index b05e826..0409803 100644
--- a/Tests/ArgumentParserUnitTests/DumpHelpGenerationTests.swift
+++ b/Tests/ArgumentParserUnitTests/DumpHelpGenerationTests.swift
@@ -21,6 +21,7 @@ final class DumpHelpGenerationTests: XCTestCase {
 
 extension DumpHelpGenerationTests {
   struct A: ParsableCommand {
+    static var configuration = CommandConfiguration(shouldPromptForMissing: false)
     enum TestEnum: String, CaseIterable, ExpressibleByArgument {
       case a, b, c
     }
@@ -30,40 +31,40 @@ extension DumpHelpGenerationTests {
 
     @Option
     var noHelpOption: Int
-    
+
     @Option(help: "int value option")
     var intOption: Int
-    
+
     @Option(help: "int value option with default value")
     var intOptionWithDefaultValue: Int = 0
-    
+
     @Argument
     var arg: Int
-     
+
     @Argument(help: "argument with help")
     var argWithHelp: Int
-    
+
     @Argument(help: "argument with default value")
     var argWithDefaultValue: Int = 1
   }
-  
+
   public func testDumpA() throws {
     try AssertDump(for: A.self, equals: Self.aDumpText)
   }
-  
+
   public func testDumpExampleCommands() throws {
     struct TestCase {
       let expected: String
       let command: String
     }
-    
+
     let testCases: [UInt : TestCase] = [
       #line : .init(expected: Self.mathDumpText, command: "math --experimental-dump-help"),
       #line : .init(expected: Self.mathAddDumpText, command: "math add --experimental-dump-help"),
       #line : .init(expected: Self.mathMultiplyDumpText, command: "math multiply --experimental-dump-help"),
       #line : .init(expected: Self.mathStatsDumpText, command: "math stats --experimental-dump-help")
     ]
-    
+
     try testCases.forEach { line, testCase in
       try AssertJSONOutputEqual(
         command: testCase.command,
diff --git a/Tests/ArgumentParserUnitTests/ErrorMessageTests.swift b/Tests/ArgumentParserUnitTests/ErrorMessageTests.swift
index d3cf274..50c73c1 100644
--- a/Tests/ArgumentParserUnitTests/ErrorMessageTests.swift
+++ b/Tests/ArgumentParserUnitTests/ErrorMessageTests.swift
@@ -237,7 +237,7 @@ extension ErrorMessageTests {
 private struct EmptyArray: ParsableArguments {
   @Option(parsing: .upToNextOption)
   var array: [String] = []
-  
+
   @Flag(name: [.short, .long])
   var verbose = false
 }
@@ -245,10 +245,10 @@ private struct EmptyArray: ParsableArguments {
 extension ErrorMessageTests {
   func testEmptyArrayOption() {
     AssertErrorMessage(EmptyArray.self, ["--array"], "Missing value for '--array <array>'")
-    
+
     AssertErrorMessage(EmptyArray.self, ["--array", "--verbose"], "Missing value for '--array <array>'")
     AssertErrorMessage(EmptyArray.self, ["-verbose", "--array"], "Missing value for '--array <array>'")
-    
+
     AssertErrorMessage(EmptyArray.self, ["--array", "-v"], "Missing value for '--array <array>'")
     AssertErrorMessage(EmptyArray.self, ["-v", "--array"], "Missing value for '--array <array>'")
   }
diff --git a/Tests/ArgumentParserUnitTests/ExitCodeTests.swift b/Tests/ArgumentParserUnitTests/ExitCodeTests.swift
index 1895aba..d6a339d 100644
--- a/Tests/ArgumentParserUnitTests/ExitCodeTests.swift
+++ b/Tests/ArgumentParserUnitTests/ExitCodeTests.swift
@@ -21,20 +21,21 @@ extension ExitCodeTests {
   struct A: ParsableArguments {}
   struct E: Error {}
   struct C: ParsableCommand {
-    static var configuration = CommandConfiguration(version: "v1")
+    static var configuration = CommandConfiguration(
+      version: "v1", shouldPromptForMissing: false)
   }
-  
+
   func testExitCodes() {
     XCTAssertEqual(ExitCode.failure, A.exitCode(for: E()))
     XCTAssertEqual(ExitCode.validationFailure, A.exitCode(for: ValidationError("")))
-    
+
     do {
       _ = try A.parse(["-h"])
       XCTFail("Didn't throw help request error.")
     } catch {
       XCTAssertEqual(ExitCode.success, A.exitCode(for: error))
     }
-    
+
     do {
       _ = try A.parse(["--version"])
       XCTFail("Didn't throw unrecognized --version error.")
@@ -53,21 +54,21 @@ extension ExitCodeTests {
   func testExitCode_Success() {
     XCTAssertFalse(A.exitCode(for: E()).isSuccess)
     XCTAssertFalse(A.exitCode(for: ValidationError("")).isSuccess)
-    
+
     do {
       _ = try A.parse(["-h"])
       XCTFail("Didn't throw help request error.")
     } catch {
       XCTAssertTrue(A.exitCode(for: error).isSuccess)
     }
-    
+
     do {
       _ = try A.parse(["--version"])
       XCTFail("Didn't throw unrecognized --version error.")
     } catch {
       XCTAssertFalse(A.exitCode(for: error).isSuccess)
     }
-    
+
     do {
       _ = try C.parse(["--version"])
       XCTFail("Didn't throw version request error.")
@@ -82,6 +83,7 @@ extension ExitCodeTests {
 extension ExitCodeTests {
   func testNSErrorIsHandled() {
     struct NSErrorCommand: ParsableCommand {
+      static var configuration = CommandConfiguration(shouldPromptForMissing: false)
       static let fileNotFoundNSError = NSError(domain: "", code: 1, userInfo: [NSLocalizedDescriptionKey: "The file “foo/bar” couldn’t be opened because there is no such file"])
     }
     XCTAssertEqual(NSErrorCommand.exitCode(for: NSErrorCommand.fileNotFoundNSError), ExitCode(rawValue: 1))
diff --git a/Tests/ArgumentParserUnitTests/HelpGenerationTests.swift b/Tests/ArgumentParserUnitTests/HelpGenerationTests.swift
index cc2e3a8..bcb496a 100644
--- a/Tests/ArgumentParserUnitTests/HelpGenerationTests.swift
+++ b/Tests/ArgumentParserUnitTests/HelpGenerationTests.swift
@@ -449,7 +449,7 @@ extension HelpGenerationTests {
 
     """)
   }
-    
+
   struct Foo: ParsableCommand {
     public static var configuration = CommandConfiguration(
       commandName: "foo",
@@ -458,10 +458,10 @@ extension HelpGenerationTests {
         Bar.self
       ],
       helpNames: [.short, .long, .customLong("help", withSingleDash: true)])
-        
+
     @Option(help: "Name for foo")
     var fooName: String?
-        
+
     public init() {}
   }
 
@@ -471,10 +471,10 @@ extension HelpGenerationTests {
       _superCommandName: "foo",
       abstract: "Perform bar operations",
       helpNames: [.short, .long, .customLong("help", withSingleDash: true)])
-            
+
     @Option(help: "Bar Strength")
     var barStrength: String?
-        
+
     public init() {}
   }
 
@@ -488,7 +488,7 @@ extension HelpGenerationTests {
       --bar-strength <bar-strength>
                               Bar Strength
       -h, -help, --help       Show help information.
-    
+
     """)
   }
 }
@@ -497,13 +497,13 @@ extension HelpGenerationTests {
   private struct optionsToHide: ParsableArguments {
     @Flag(help: "Verbose")
     var verbose: Bool = false
-    
+
     @Option(help: "Custom Name")
     var customName: String?
-    
+
     @Option(help: .hidden)
     var hiddenOption: String?
-    
+
     @Argument(help: .private)
     var privateArg: String?
   }
@@ -511,10 +511,10 @@ extension HelpGenerationTests {
   @available(*, deprecated)
   private struct HideOptionGroupLegacyDriver: ParsableCommand {
     static let configuration = CommandConfiguration(commandName: "driver", abstract: "Demo hiding option groups")
-    
+
     @OptionGroup(_hiddenFromHelp: true)
     var hideMe: optionsToHide
-    
+
     @Option(help: "Time to wait before timeout (in seconds)")
     var timeout: Int?
   }
@@ -578,7 +578,7 @@ extension HelpGenerationTests {
   func testHelpHiddenShowsDefaultAndHidden() throws {
     AssertHelp(.hidden, for: HideOptionGroupLegacyDriver.self, equals: helpHiddenMessage)
     AssertHelp(.hidden, for: HideOptionGroupDriver.self, equals: helpHiddenMessage)
-    
+
     // Note: Private option groups are not visible at `.hidden` help level.
     AssertHelp(.hidden, for: PrivateOptionGroupDriver.self, equals: helpMessage)
   }
@@ -657,7 +657,7 @@ extension HelpGenerationTests {
     static let configuration = CommandConfiguration(
       commandName: "parserBug",
       subcommands: [Sub.self])
-    
+
     struct CommonOptions: ParsableCommand {
       @Flag(help: "example flag")
       var example: Bool = false
@@ -666,12 +666,12 @@ extension HelpGenerationTests {
     struct Sub: ParsableCommand {
       @OptionGroup()
       var commonOptions: CommonOptions
-      
+
       @Argument(help: "Non-mandatory argument")
       var argument: String?
     }
   }
-  
+
   func testIssue278() {
     AssertHelp(.default, for: ParserBug.Sub.self, root: ParserBug.self, equals: """
       USAGE: parserBug sub [--example] [<argument>]
@@ -692,11 +692,11 @@ extension HelpGenerationTests {
         example [--verbose] <file-name>
         """)
     }
-    
+
     @Argument var file: String
     @Flag var verboseMode = false
   }
-  
+
   struct CustomUsageLong: ParsableCommand {
     static var configuration: CommandConfiguration {
       CommandConfiguration(usage: """
@@ -705,7 +705,7 @@ extension HelpGenerationTests {
         example --help
         """)
     }
-    
+
     @Argument var file: String
     @Flag var verboseMode = false
   }
@@ -714,7 +714,7 @@ extension HelpGenerationTests {
     static var configuration: CommandConfiguration {
       CommandConfiguration(usage: "")
     }
-    
+
     @Argument var file: String
     @Flag var verboseMode = false
   }
@@ -729,9 +729,9 @@ extension HelpGenerationTests {
       OPTIONS:
         --verbose-mode
         -h, --help              Show help information.
-      
+
       """)
-    
+
     XCTAssertEqual(CustomUsageLong.helpMessage(columns: 80), """
       USAGE: example <file-name>
              example --verbose <file-name>
@@ -743,9 +743,9 @@ extension HelpGenerationTests {
       OPTIONS:
         --verbose-mode
         -h, --help              Show help information.
-      
+
       """)
-    
+
     XCTAssertEqual(CustomUsageHidden.helpMessage(columns: 80), """
       ARGUMENTS:
         <file>
@@ -753,10 +753,10 @@ extension HelpGenerationTests {
       OPTIONS:
         --verbose-mode
         -h, --help              Show help information.
-      
+
       """)
   }
-  
+
   func testCustomUsageError() {
     XCTAssertEqual(CustomUsageShort.fullMessage(for: ValidationError("Test")), """
       Error: Test
diff --git a/Tests/ArgumentParserUnitTests/InputOriginTests.swift b/Tests/ArgumentParserUnitTests/InputOriginTests.swift
index a176792..de51be0 100644
--- a/Tests/ArgumentParserUnitTests/InputOriginTests.swift
+++ b/Tests/ArgumentParserUnitTests/InputOriginTests.swift
@@ -24,7 +24,7 @@ extension InputOriginTests {
         XCTAssertFalse(inputOrigin.isDefaultValue)
       }
     }
-    
+
     Assert(elements: [], expectedIsDefaultValue: false)
     Assert(elements: [.defaultValue], expectedIsDefaultValue: true)
     Assert(elements: [.argumentIndex(SplitArguments.Index(inputIndex: 1))], expectedIsDefaultValue: false)
diff --git a/Tests/ArgumentParserUnitTests/MirrorTests.swift b/Tests/ArgumentParserUnitTests/MirrorTests.swift
index cf2f2f7..bb80a09 100644
--- a/Tests/ArgumentParserUnitTests/MirrorTests.swift
+++ b/Tests/ArgumentParserUnitTests/MirrorTests.swift
@@ -50,7 +50,7 @@ extension MirrorTests {
         }
       }
     }
-    
+
     performTest(foo: "foo", baz: "baz")
     performTest(foo: "foo", baz: nil)
     performTest(foo: nil, baz: "baz")
diff --git a/Tests/ArgumentParserUnitTests/NameSpecificationTests.swift b/Tests/ArgumentParserUnitTests/NameSpecificationTests.swift
index 956a4a8..ff598a3 100644
--- a/Tests/ArgumentParserUnitTests/NameSpecificationTests.swift
+++ b/Tests/ArgumentParserUnitTests/NameSpecificationTests.swift
@@ -18,21 +18,21 @@ final class NameSpecificationTests: XCTestCase {
 extension NameSpecificationTests {
   func testFlagNames_withNoPrefix() {
     let key = InputKey(rawValue: "index")
-    
+
     XCTAssertEqual(FlagInversion.prefixedNo.enableDisableNamePair(for: key, name: .customLong("foo")).1, [.long("no-foo")])
     XCTAssertEqual(FlagInversion.prefixedNo.enableDisableNamePair(for: key, name: .customLong("foo-bar-baz")).1, [.long("no-foo-bar-baz")])
     XCTAssertEqual(FlagInversion.prefixedNo.enableDisableNamePair(for: key, name: .customLong("foo_bar_baz")).1, [.long("no_foo_bar_baz")])
     XCTAssertEqual(FlagInversion.prefixedNo.enableDisableNamePair(for: key, name: .customLong("fooBarBaz")).1, [.long("noFooBarBaz")])
   }
-  
+
   func testFlagNames_withEnableDisablePrefix() {
     let key = InputKey(rawValue: "index")
     XCTAssertEqual(FlagInversion.prefixedEnableDisable.enableDisableNamePair(for: key, name: .long).0, [.long("enable-index")])
     XCTAssertEqual(FlagInversion.prefixedEnableDisable.enableDisableNamePair(for: key, name: .long).1, [.long("disable-index")])
-    
+
     XCTAssertEqual(FlagInversion.prefixedEnableDisable.enableDisableNamePair(for: key, name: .customLong("foo")).0, [.long("enable-foo")])
     XCTAssertEqual(FlagInversion.prefixedEnableDisable.enableDisableNamePair(for: key, name: .customLong("foo")).1, [.long("disable-foo")])
-    
+
     XCTAssertEqual(FlagInversion.prefixedEnableDisable.enableDisableNamePair(for: key, name: .customLong("foo-bar-baz")).0, [.long("enable-foo-bar-baz")])
     XCTAssertEqual(FlagInversion.prefixedEnableDisable.enableDisableNamePair(for: key, name: .customLong("foo-bar-baz")).1, [.long("disable-foo-bar-baz")])
     XCTAssertEqual(FlagInversion.prefixedEnableDisable.enableDisableNamePair(for: key, name: .customLong("foo_bar_baz")).0, [.long("enable_foo_bar_baz")])
@@ -60,20 +60,20 @@ extension NameSpecificationTests {
   func testMakeNames_short() {
     Assert(nameSpecification: .short, key: "foo", makeNames: [.short("f")])
   }
-  
+
   func testMakeNames_Long() {
     Assert(nameSpecification: .long, key: "fooBarBaz", makeNames: [.long("foo-bar-baz")])
     Assert(nameSpecification: .long, key: "fooURLForBarBaz", makeNames: [.long("foo-url-for-bar-baz")])
   }
-  
+
   func testMakeNames_customLong() {
     Assert(nameSpecification: .customLong("bar"), key: "foo", makeNames: [.long("bar")])
   }
-  
+
   func testMakeNames_customShort() {
     Assert(nameSpecification: .customShort("v"), key: "foo", makeNames: [.short("v")])
   }
-  
+
   func testMakeNames_customLongWithSingleDash() {
     Assert(nameSpecification: .customLong("baz", withSingleDash: true), key: "foo", makeNames: [.longWithSingleDash("baz")])
   }
diff --git a/Tests/ArgumentParserUnitTests/ParsableArgumentsValidationTests.swift b/Tests/ArgumentParserUnitTests/ParsableArgumentsValidationTests.swift
index b7a3243..f7d64f8 100644
--- a/Tests/ArgumentParserUnitTests/ParsableArgumentsValidationTests.swift
+++ b/Tests/ArgumentParserUnitTests/ParsableArgumentsValidationTests.swift
@@ -15,6 +15,7 @@ import ArgumentParserTestHelpers
 
 final class ParsableArgumentsValidationTests: XCTestCase {
   private struct A: ParsableCommand {
+    static var configuration = CommandConfiguration(shouldPromptForMissing: false)
     @Option(help: "The number of times to repeat 'phrase'.")
     var count: Int?
 
@@ -30,6 +31,7 @@ final class ParsableArgumentsValidationTests: XCTestCase {
   }
 
   private struct B: ParsableCommand {
+    static var configuration = CommandConfiguration(shouldPromptForMissing: false)
     @Option(help: "The number of times to repeat 'phrase'.")
     var count: Int?
 
@@ -40,6 +42,7 @@ final class ParsableArgumentsValidationTests: XCTestCase {
   }
 
   private struct C: ParsableCommand {
+    static var configuration = CommandConfiguration(shouldPromptForMissing: false)
     @Option(help: "The number of times to repeat 'phrase'.")
     var count: Int?
 
@@ -85,15 +88,15 @@ final class ParsableArgumentsValidationTests: XCTestCase {
     XCTAssertNil(ParsableArgumentsCodingKeyValidator.validate(B.self))
 
     if let error = ParsableArgumentsCodingKeyValidator.validate(C.self)
-      as? ParsableArgumentsCodingKeyValidator.Error
+        as? ParsableArgumentsCodingKeyValidator.Error
     {
       XCTAssert(error.missingCodingKeys == ["count"])
     } else {
       XCTFail()
     }
-    
+
     if let error = ParsableArgumentsCodingKeyValidator.validate(D.self)
-      as? ParsableArgumentsCodingKeyValidator.Error
+        as? ParsableArgumentsCodingKeyValidator.Error
     {
       XCTAssert(error.missingCodingKeys == ["phrase"])
     } else {
@@ -101,7 +104,7 @@ final class ParsableArgumentsValidationTests: XCTestCase {
     }
 
     if let error = ParsableArgumentsCodingKeyValidator.validate(E.self)
-      as? ParsableArgumentsCodingKeyValidator.Error
+        as? ParsableArgumentsCodingKeyValidator.Error
     {
       XCTAssert(error.missingCodingKeys == ["phrase", "includeCounter"])
     } else {
@@ -219,6 +222,7 @@ final class ParsableArgumentsValidationTests: XCTestCase {
 
   // MARK: One name is duplicated
   fileprivate struct TwoOfTheSameName: ParsableCommand {
+    static var configuration = CommandConfiguration(shouldPromptForMissing: false)
     @Option()
     var foo: String
 
@@ -228,7 +232,7 @@ final class ParsableArgumentsValidationTests: XCTestCase {
 
   func testUniqueNamesValidation_TwoOfSameName() throws {
     if let error = ParsableArgumentsUniqueNamesValidator.validate(TwoOfTheSameName.self)
-      as? ParsableArgumentsUniqueNamesValidator.Error
+        as? ParsableArgumentsUniqueNamesValidator.Error
     {
       XCTAssertEqual(error.description, "Multiple (2) `Option` or `Flag` arguments are named \"--foo\".")
     } else {
@@ -256,7 +260,7 @@ final class ParsableArgumentsValidationTests: XCTestCase {
 
   func testUniqueNamesValidation_TwoDuplications() throws {
     if let error = ParsableArgumentsUniqueNamesValidator.validate(MultipleUniquenessViolations.self)
-      as? ParsableArgumentsUniqueNamesValidator.Error
+        as? ParsableArgumentsUniqueNamesValidator.Error
     {
       XCTAssert(
         /// The `Mirror` reflects the properties `foo` and `bar` in a random order each time it's built.
@@ -276,6 +280,7 @@ final class ParsableArgumentsValidationTests: XCTestCase {
 
   // MARK: Argument has multiple names and one is duplicated
   fileprivate struct MultipleNamesPerArgument: ParsableCommand {
+    static var configuration = CommandConfiguration(shouldPromptForMissing: false)
     @Flag(name: [.customShort("v"), .customLong("very-chatty")])
     var verbose: Bool = false
 
@@ -291,7 +296,7 @@ final class ParsableArgumentsValidationTests: XCTestCase {
 
   func testUniqueNamesValidation_ArgumentHasMultipleNames() throws {
     if let error = ParsableArgumentsUniqueNamesValidator.validate(MultipleNamesPerArgument.self)
-      as? ParsableArgumentsUniqueNamesValidator.Error
+        as? ParsableArgumentsUniqueNamesValidator.Error
     {
       XCTAssertEqual(error.description, "Multiple (2) `Option` or `Flag` arguments are named \"-v\".")
     } else {
@@ -322,7 +327,7 @@ final class ParsableArgumentsValidationTests: XCTestCase {
 
   func testUniqueNamesValidation_MoreThanTwoDuplications() throws {
     if let error = ParsableArgumentsUniqueNamesValidator.validate(FourDuplicateNames.self)
-      as? ParsableArgumentsUniqueNamesValidator.Error
+        as? ParsableArgumentsUniqueNamesValidator.Error
     {
       XCTAssertEqual(error.description, "Multiple (4) `Option` or `Flag` arguments are named \"--foo\".")
     } else {
@@ -333,6 +338,7 @@ final class ParsableArgumentsValidationTests: XCTestCase {
   // MARK: EnumerableFlag has first letter duplication
 
   fileprivate struct DuplicatedFirstLettersShortNames: ParsableCommand {
+    static var configuration = CommandConfiguration(shouldPromptForMissing: false)
     enum ExampleEnum: String, EnumerableFlag {
       case first
       case second
@@ -350,6 +356,7 @@ final class ParsableArgumentsValidationTests: XCTestCase {
   }
 
   fileprivate struct DuplicatedFirstLettersLongNames: ParsableCommand {
+    static var configuration = CommandConfiguration(shouldPromptForMissing: false)
     enum ExampleEnum: String, EnumerableFlag {
       case first
       case second
@@ -364,7 +371,7 @@ final class ParsableArgumentsValidationTests: XCTestCase {
 
   func testUniqueNamesValidation_DuplicatedFlagFirstLetters_ShortNames() throws {
     if let error = ParsableArgumentsUniqueNamesValidator.validate(DuplicatedFirstLettersShortNames.self)
-      as? ParsableArgumentsUniqueNamesValidator.Error
+        as? ParsableArgumentsUniqueNamesValidator.Error
     {
       XCTAssertEqual(error.description, "Multiple (3) `Option` or `Flag` arguments are named \"-f\".")
     } else {
@@ -375,8 +382,9 @@ final class ParsableArgumentsValidationTests: XCTestCase {
   func testUniqueNamesValidation_DuplicatedFlagFirstLetters_LongNames() throws {
     XCTAssertNil(ParsableArgumentsUniqueNamesValidator.validate(DuplicatedFirstLettersLongNames.self))
   }
-  
+
   fileprivate struct HasOneNonsenseFlag: ParsableCommand {
+    static var configuration = CommandConfiguration(shouldPromptForMissing: false)
     enum ExampleEnum: String, EnumerableFlag {
       case first
       case second
@@ -387,7 +395,7 @@ final class ParsableArgumentsValidationTests: XCTestCase {
 
     @Flag
     var enumFlag: ExampleEnum = .first
-    
+
     @Flag
     var fine: Bool = false
 
@@ -406,7 +414,7 @@ final class ParsableArgumentsValidationTests: XCTestCase {
 
   func testNonsenseFlagsValidation_OneFlag() throws {
     if let error = NonsenseFlagsValidator.validate(HasOneNonsenseFlag.self)
-      as? NonsenseFlagsValidator.Error
+        as? NonsenseFlagsValidator.Error
     {
       XCTAssertEqual(
         error.description,
@@ -426,6 +434,7 @@ final class ParsableArgumentsValidationTests: XCTestCase {
   }
 
   fileprivate struct MultipleNonsenseFlags: ParsableCommand {
+    static var configuration = CommandConfiguration(shouldPromptForMissing: false)
     @Flag
     var stuff = true
 
@@ -441,7 +450,7 @@ final class ParsableArgumentsValidationTests: XCTestCase {
 
   func testNonsenseFlagsValidation_MultipleFlags() throws {
     if let error = NonsenseFlagsValidator.validate(MultipleNonsenseFlags.self)
-      as? NonsenseFlagsValidator.Error
+        as? NonsenseFlagsValidator.Error
     {
       XCTAssertEqual(
         error.description,
diff --git a/Tests/ArgumentParserUnitTests/SequenceExtensionTests.swift b/Tests/ArgumentParserUnitTests/SequenceExtensionTests.swift
index 5c409be..587c15c 100644
--- a/Tests/ArgumentParserUnitTests/SequenceExtensionTests.swift
+++ b/Tests/ArgumentParserUnitTests/SequenceExtensionTests.swift
@@ -21,7 +21,7 @@ extension SequenceExtensionTests {
     XCTAssertEqual([0, 1, 2, 3, 4], [0, 1, 2, 3, 4, 0, 1, 2, 3, 4].uniquing())
     XCTAssertEqual([0, 1, 2, 3, 4], [0, 1, 2, 3, 4, 4, 3, 2, 1, 0].uniquing())
   }
-  
+
   func testUniquingAdjacentElements() {
     XCTAssertEqual([], (0..<0).uniquingAdjacentElements())
     XCTAssertEqual([0, 1, 2, 3, 4], (0..<5).uniquingAdjacentElements())
diff --git a/Tests/ArgumentParserUnitTests/SplitArgumentTests.swift b/Tests/ArgumentParserUnitTests/SplitArgumentTests.swift
index 5b1c1c2..6a0e824 100644
--- a/Tests/ArgumentParserUnitTests/SplitArgumentTests.swift
+++ b/Tests/ArgumentParserUnitTests/SplitArgumentTests.swift
@@ -48,80 +48,80 @@ final class SplitArgumentTests: XCTestCase {
     XCTAssertEqual(sut.elements.count, 0)
     XCTAssertEqual(sut.originalInput.count, 0)
   }
-  
+
   func testSingleValue() throws {
     let sut = try SplitArguments(arguments: ["abc"])
-    
+
     XCTAssertEqual(sut.elements.count, 1)
     AssertIndexEqual(sut, at: 0, inputIndex: 0, subIndex: .complete)
     AssertElementEqual(sut, at: 0, .value("abc"))
-    
+
     XCTAssertEqual(sut.originalInput.count, 1)
     XCTAssertEqual(sut.originalInput, ["abc"])
   }
-  
+
   func testSingleLongOption() throws {
     let sut = try SplitArguments(arguments: ["--abc"])
-    
+
     XCTAssertEqual(sut.elements.count, 1)
     AssertIndexEqual(sut, at: 0, inputIndex: 0, subIndex: .complete)
     AssertElementEqual(sut, at: 0, .option(.name(.long("abc"))))
-    
+
     XCTAssertEqual(sut.originalInput.count, 1)
     XCTAssertEqual(sut.originalInput, ["--abc"])
   }
-  
+
   func testSingleShortOption() throws {
     let sut = try SplitArguments(arguments: ["-a"])
-    
+
     XCTAssertEqual(sut.elements.count, 1)
     AssertIndexEqual(sut, at: 0, inputIndex: 0, subIndex: .complete)
     AssertElementEqual(sut, at: 0, .option(.name(.short("a"))))
-    
+
     XCTAssertEqual(sut.originalInput.count, 1)
     XCTAssertEqual(sut.originalInput, ["-a"])
   }
-  
+
   func testSingleLongOptionWithValue() throws {
     let sut = try SplitArguments(arguments: ["--abc=def"])
-    
+
     XCTAssertEqual(sut.elements.count, 1)
     AssertIndexEqual(sut, at: 0, inputIndex: 0, subIndex: .complete)
     AssertElementEqual(sut, at: 0, .option(.nameWithValue(.long("abc"), "def")))
-    
+
     XCTAssertEqual(sut.originalInput.count, 1)
     XCTAssertEqual(sut.originalInput, ["--abc=def"])
   }
-  
+
   func testMultipleShortOptionsCombined() throws {
     let sut = try SplitArguments(arguments: ["-abc"])
-    
+
     XCTAssertEqual(sut.elements.count, 4)
-    
+
     AssertIndexEqual(sut, at: 0, inputIndex: 0, subIndex: .complete)
     AssertElementEqual(sut, at: 0, .option(.name(.longWithSingleDash("abc"))))
-    
+
     AssertIndexEqual(sut, at: 1, inputIndex: 0, subIndex: .sub(0))
     AssertElementEqual(sut, at: 1, .option(.name(.short("a"))))
-    
+
     AssertIndexEqual(sut, at: 2, inputIndex: 0, subIndex: .sub(1))
     AssertElementEqual(sut, at: 2, .option(.name(.short("b"))))
-    
+
     AssertIndexEqual(sut, at: 3, inputIndex: 0, subIndex: .sub(2))
     AssertElementEqual(sut, at: 3, .option(.name(.short("c"))))
-    
+
     XCTAssertEqual(sut.originalInput.count, 1)
     XCTAssertEqual(sut.originalInput, ["-abc"])
   }
-  
+
   func testSingleLongOptionWithValueAndSingleDash() throws {
     let sut = try SplitArguments(arguments: ["-abc=def"])
-    
+
     XCTAssertEqual(sut.elements.count, 1)
-    
+
     AssertIndexEqual(sut, at: 0, inputIndex: 0, subIndex: .complete)
     AssertElementEqual(sut, at: 0, .option(.nameWithValue(.longWithSingleDash("abc"), "def")))
-    
+
     XCTAssertEqual(sut.originalInput.count, 1)
     XCTAssertEqual(sut.originalInput, ["-abc=def"])
   }
@@ -130,84 +130,84 @@ final class SplitArgumentTests: XCTestCase {
 extension SplitArgumentTests {
   func testMultipleValues() throws {
     let sut = try SplitArguments(arguments: ["abc", "x", "1234"])
-    
+
     XCTAssertEqual(sut.elements.count, 3)
-    
+
     AssertIndexEqual(sut, at: 0, inputIndex: 0, subIndex: .complete)
     AssertElementEqual(sut, at: 0, .value("abc"))
-    
+
     AssertIndexEqual(sut, at: 1, inputIndex: 1, subIndex: .complete)
     AssertElementEqual(sut, at: 1, .value("x"))
-    
+
     AssertIndexEqual(sut, at: 2, inputIndex: 2, subIndex: .complete)
     AssertElementEqual(sut, at: 2, .value("1234"))
-    
+
     XCTAssertEqual(sut.originalInput.count, 3)
     XCTAssertEqual(sut.originalInput, ["abc", "x", "1234"])
   }
-  
+
   func testMultipleLongOptions() throws {
     let sut = try SplitArguments(arguments: ["--d", "--1", "--abc-def"])
-    
+
     XCTAssertEqual(sut.elements.count, 3)
-    
+
     AssertIndexEqual(sut, at: 0, inputIndex: 0, subIndex: .complete)
     AssertElementEqual(sut, at: 0, .option(.name(.long("d"))))
-    
+
     AssertIndexEqual(sut, at: 1, inputIndex: 1, subIndex: .complete)
     AssertElementEqual(sut, at: 1, .option(.name(.long("1"))))
-    
+
     AssertIndexEqual(sut, at: 2, inputIndex: 2, subIndex: .complete)
     AssertElementEqual(sut, at: 2, .option(.name(.long("abc-def"))))
-    
+
     XCTAssertEqual(sut.originalInput.count, 3)
     XCTAssertEqual(sut.originalInput, ["--d", "--1", "--abc-def"])
   }
-  
+
   func testMultipleShortOptions() throws {
     let sut = try SplitArguments(arguments: ["-x", "-y", "-z"])
-    
+
     XCTAssertEqual(sut.elements.count, 3)
-    
+
     AssertIndexEqual(sut, at: 0, inputIndex: 0, subIndex: .complete)
     AssertElementEqual(sut, at: 0, .option(.name(.short("x"))))
-    
+
     AssertIndexEqual(sut, at: 1, inputIndex: 1, subIndex: .complete)
     AssertElementEqual(sut, at: 1, .option(.name(.short("y"))))
-    
+
     AssertIndexEqual(sut, at: 2, inputIndex: 2, subIndex: .complete)
     AssertElementEqual(sut, at: 2, .option(.name(.short("z"))))
-    
+
     XCTAssertEqual(sut.originalInput.count, 3)
     XCTAssertEqual(sut.originalInput, ["-x", "-y", "-z"])
   }
-  
+
   func testMultipleShortOptionsCombined_2() throws {
     let sut = try SplitArguments(arguments: ["-bc", "-fv", "-a"])
-    
+
     XCTAssertEqual(sut.elements.count, 7)
-    
+
     AssertIndexEqual(sut, at: 0, inputIndex: 0, subIndex: .complete)
     AssertElementEqual(sut, at: 0, .option(.name(.longWithSingleDash("bc"))))
-    
+
     AssertIndexEqual(sut, at: 1, inputIndex: 0, subIndex: .sub(0))
     AssertElementEqual(sut, at: 1, .option(.name(.short("b"))))
-    
+
     AssertIndexEqual(sut, at: 2, inputIndex: 0, subIndex: .sub(1))
     AssertElementEqual(sut, at: 2, .option(.name(.short("c"))))
-    
+
     AssertIndexEqual(sut, at: 3, inputIndex: 1, subIndex: .complete)
     AssertElementEqual(sut, at: 3, .option(.name(.longWithSingleDash("fv"))))
-    
+
     AssertIndexEqual(sut, at: 4, inputIndex: 1, subIndex: .sub(0))
     AssertElementEqual(sut, at: 4, .option(.name(.short("f"))))
-    
+
     AssertIndexEqual(sut, at: 5, inputIndex: 1, subIndex: .sub(1))
     AssertElementEqual(sut, at: 5, .option(.name(.short("v"))))
-    
+
     AssertIndexEqual(sut, at: 6, inputIndex: 2, subIndex: .complete)
     AssertElementEqual(sut, at: 6, .option(.name(.short("a"))))
-    
+
     XCTAssertEqual(sut.originalInput.count, 3)
     XCTAssertEqual(sut.originalInput, ["-bc", "-fv", "-a"])
   }
@@ -216,144 +216,144 @@ extension SplitArgumentTests {
 extension SplitArgumentTests {
   func testMixed_1() throws {
     let sut = try SplitArguments(arguments: ["-x", "abc", "--foo", "1234", "-zz"])
-    
+
     XCTAssertEqual(sut.elements.count, 7)
-    
+
     AssertIndexEqual(sut, at: 0, inputIndex: 0, subIndex: .complete)
     AssertElementEqual(sut, at: 0, .option(.name(.short("x"))))
-    
+
     AssertIndexEqual(sut, at: 1, inputIndex: 1, subIndex: .complete)
     AssertElementEqual(sut, at: 1, .value("abc"))
-    
+
     AssertIndexEqual(sut, at: 2, inputIndex: 2, subIndex: .complete)
     AssertElementEqual(sut, at: 2, .option(.name(.long("foo"))))
-    
+
     AssertIndexEqual(sut, at: 3, inputIndex: 3, subIndex: .complete)
     AssertElementEqual(sut, at: 3, .value("1234"))
-    
+
     AssertIndexEqual(sut, at: 4, inputIndex: 4, subIndex: .complete)
     AssertElementEqual(sut, at: 4, .option(.name(.longWithSingleDash("zz"))))
-    
+
     AssertIndexEqual(sut, at: 5, inputIndex: 4, subIndex: .sub(0))
     AssertElementEqual(sut, at: 5, .option(.name(.short("z"))))
-    
+
     AssertIndexEqual(sut, at: 6, inputIndex: 4, subIndex: .sub(1))
     AssertElementEqual(sut, at: 6, .option(.name(.short("z"))))
-    
+
     XCTAssertEqual(sut.originalInput.count, 5)
     XCTAssertEqual(sut.originalInput, ["-x", "abc", "--foo", "1234", "-zz"])
   }
-  
+
   func testMixed_2() throws {
     let sut = try SplitArguments(arguments: ["1234", "-zz", "abc", "-x", "--foo"])
-    
+
     XCTAssertEqual(sut.elements.count, 7)
-    
+
     AssertIndexEqual(sut, at: 0, inputIndex: 0, subIndex: .complete)
     AssertElementEqual(sut, at: 0, .value("1234"))
-    
+
     AssertIndexEqual(sut, at: 1, inputIndex: 1, subIndex: .complete)
     AssertElementEqual(sut, at: 1, .option(.name(.longWithSingleDash("zz"))))
-    
+
     AssertIndexEqual(sut, at: 2, inputIndex: 1, subIndex: .sub(0))
     AssertElementEqual(sut, at: 2, .option(.name(.short("z"))))
-    
+
     AssertIndexEqual(sut, at: 3, inputIndex: 1, subIndex: .sub(1))
     AssertElementEqual(sut, at: 3, .option(.name(.short("z"))))
-    
+
     AssertIndexEqual(sut, at: 4, inputIndex: 2, subIndex: .complete)
     AssertElementEqual(sut, at: 4, .value("abc"))
-    
+
     AssertIndexEqual(sut, at: 5, inputIndex: 3, subIndex: .complete)
     AssertElementEqual(sut, at: 5, .option(.name(.short("x"))))
-    
+
     AssertIndexEqual(sut, at: 6, inputIndex: 4, subIndex: .complete)
     AssertElementEqual(sut, at: 6, .option(.name(.long("foo"))))
-    
+
     XCTAssertEqual(sut.originalInput.count, 5)
     XCTAssertEqual(sut.originalInput, ["1234", "-zz", "abc", "-x", "--foo"])
   }
-  
+
   func testTerminator_1() throws {
     let sut = try SplitArguments(arguments: ["--foo", "--", "--bar"])
-    
+
     XCTAssertEqual(sut.elements.count, 3)
-    
+
     AssertIndexEqual(sut, at: 0, inputIndex: 0, subIndex: .complete)
     AssertElementEqual(sut, at: 0, .option(.name(.long("foo"))))
-    
+
     AssertIndexEqual(sut, at: 1, inputIndex: 1, subIndex: .complete)
     AssertElementEqual(sut, at: 1, .terminator)
-    
+
     AssertIndexEqual(sut, at: 2, inputIndex: 2, subIndex: .complete)
     AssertElementEqual(sut, at: 2, .value("--bar"))
-    
+
     XCTAssertEqual(sut.originalInput.count, 3)
     XCTAssertEqual(sut.originalInput, ["--foo", "--", "--bar"])
   }
-  
+
   func testTerminator_2() throws {
     let sut = try SplitArguments(arguments: ["--foo", "--", "bar"])
-    
+
     XCTAssertEqual(sut.elements.count, 3)
-    
+
     AssertIndexEqual(sut, at: 0, inputIndex: 0, subIndex: .complete)
     AssertElementEqual(sut, at: 0, .option(.name(.long("foo"))))
-    
+
     AssertIndexEqual(sut, at: 1, inputIndex: 1, subIndex: .complete)
     AssertElementEqual(sut, at: 1, .terminator)
-    
+
     AssertIndexEqual(sut, at: 2, inputIndex: 2, subIndex: .complete)
     AssertElementEqual(sut, at: 2, .value("bar"))
-    
+
     XCTAssertEqual(sut.originalInput.count, 3)
     XCTAssertEqual(sut.originalInput, ["--foo", "--", "bar"])
   }
-  
+
   func testTerminator_3() throws {
     let sut = try SplitArguments(arguments: ["--foo", "--", "--bar=baz"])
-    
+
     XCTAssertEqual(sut.elements.count, 3)
-    
+
     AssertIndexEqual(sut, at: 0, inputIndex: 0, subIndex: .complete)
     AssertElementEqual(sut, at: 0, .option(.name(.long("foo"))))
-    
+
     AssertIndexEqual(sut, at: 1, inputIndex: 1, subIndex: .complete)
     AssertElementEqual(sut, at: 1, .terminator)
-    
+
     AssertIndexEqual(sut, at: 2, inputIndex: 2, subIndex: .complete)
     AssertElementEqual(sut, at: 2, .value("--bar=baz"))
-    
+
     XCTAssertEqual(sut.originalInput.count, 3)
     XCTAssertEqual(sut.originalInput, ["--foo", "--", "--bar=baz"])
   }
-  
+
   func testTerminatorAtTheEnd() throws {
     let sut = try SplitArguments(arguments: ["--foo", "--"])
-    
+
     XCTAssertEqual(sut.elements.count, 2)
-    
+
     AssertIndexEqual(sut, at: 0, inputIndex: 0, subIndex: .complete)
     AssertElementEqual(sut, at: 0, .option(.name(.long("foo"))))
-    
+
     AssertIndexEqual(sut, at: 1, inputIndex: 1, subIndex: .complete)
     AssertElementEqual(sut, at: 1, .terminator)
-    
+
     XCTAssertEqual(sut.originalInput.count, 2)
     XCTAssertEqual(sut.originalInput, ["--foo", "--"])
   }
-  
+
   func testTerminatorAtTheBeginning() throws {
     let sut = try SplitArguments(arguments: ["--", "--foo"])
-    
+
     XCTAssertEqual(sut.elements.count, 2)
-    
+
     AssertIndexEqual(sut, at: 0, inputIndex: 0, subIndex: .complete)
     AssertElementEqual(sut, at: 0, .terminator)
-    
+
     AssertIndexEqual(sut, at: 1, inputIndex: 1, subIndex: .complete)
     AssertElementEqual(sut, at: 1, .value("--foo"))
-    
+
     XCTAssertEqual(sut.originalInput.count, 2)
     XCTAssertEqual(sut.originalInput, ["--", "--foo"])
   }
@@ -370,7 +370,7 @@ extension SplitArgumentTests {
     sut.remove(at: SplitArguments.Index(inputIndex: 1, subIndex: .complete))
     XCTAssertEqual(sut.elements.count, 0)
   }
-  
+
   func testRemovingValuesForLongNamesWithValue() throws {
     var sut = try SplitArguments(arguments: ["--foo=A", "--bar=B"])
     XCTAssertEqual(sut.elements.count, 2)
@@ -379,7 +379,7 @@ extension SplitArgumentTests {
     sut.remove(at: SplitArguments.Index(inputIndex: 1, subIndex: .complete))
     XCTAssertEqual(sut.elements.count, 0)
   }
-  
+
   func testRemovingValuesForShortNames() throws {
     var sut = try SplitArguments(arguments: ["-f", "-b"])
     XCTAssertEqual(sut.elements.count, 2)
@@ -388,10 +388,10 @@ extension SplitArgumentTests {
     sut.remove(at: SplitArguments.Index(inputIndex: 1, subIndex: .complete))
     XCTAssertEqual(sut.elements.count, 0)
   }
-  
+
   func testRemovingValuesForCombinedShortNames() throws {
     let sut = try SplitArguments(arguments: ["-fb"])
-    
+
     XCTAssertEqual(sut.elements.count, 3)
     AssertIndexEqual(sut, at: 0, inputIndex: 0, subIndex: .complete)
     AssertElementEqual(sut, at: 0, .option(.name(.longWithSingleDash("fb"))))
@@ -399,17 +399,17 @@ extension SplitArgumentTests {
     AssertElementEqual(sut, at: 1, .option(.name(.short("f"))))
     AssertIndexEqual(sut, at: 2, inputIndex: 0, subIndex: .sub(1))
     AssertElementEqual(sut, at: 2, .option(.name(.short("b"))))
-    
+
     do {
       var sutB = sut
       sutB.remove(at: SplitArguments.Index(inputIndex: 0, subIndex: .complete))
-      
+
       XCTAssertEqual(sutB.elements.count, 0)
     }
     do {
       var sutB = sut
       sutB.remove(at: SplitArguments.Index(inputIndex: 0, subIndex: .sub(0)))
-      
+
       XCTAssertEqual(sutB.elements.count, 1)
       AssertIndexEqual(sutB, at: 2, inputIndex: 0, subIndex: .sub(1))
       AssertElementEqual(sutB, at: 2, .option(.name(.short("b"))))
@@ -417,7 +417,7 @@ extension SplitArgumentTests {
     do {
       var sutB = sut
       sutB.remove(at: SplitArguments.Index(inputIndex: 0, subIndex: .sub(1)))
-      
+
       XCTAssertEqual(sutB.elements.count, 1)
       AssertIndexEqual(sutB, at: 2, inputIndex: 0, subIndex: .sub(0))
       AssertElementEqual(sutB, at: 2, .option(.name(.short("f"))))
@@ -430,143 +430,143 @@ extension SplitArgumentTests {
 extension SplitArgumentTests {
   func testPopNext() throws {
     var sut = try SplitArguments(arguments: ["--foo", "bar"])
-    
+
     let a = try XCTUnwrap(sut.popNext())
     XCTAssertEqual(a.0, .argumentIndex(SplitArguments.Index(inputIndex: 0, subIndex: .complete)))
     XCTAssertEqual(a.1.value, .option(.name(.long("foo"))))
-    
+
     let b = try XCTUnwrap(sut.popNext())
     XCTAssertEqual(b.0, .argumentIndex(SplitArguments.Index(inputIndex: 1, subIndex: .complete)))
     XCTAssertEqual(b.1.value, .value("bar"))
-    
+
     XCTAssertNil(sut.popNext())
   }
-  
+
   func testPeekNext() throws {
     let sut = try SplitArguments(arguments: ["--foo", "bar"])
-    
+
     let a = try XCTUnwrap(sut.peekNext())
     XCTAssertEqual(a.0, .argumentIndex(SplitArguments.Index(inputIndex: 0, subIndex: .complete)))
     XCTAssertEqual(a.1.value, .option(.name(.long("foo"))))
-    
+
     let b = try XCTUnwrap(sut.peekNext())
     XCTAssertEqual(b.0, .argumentIndex(SplitArguments.Index(inputIndex: 0, subIndex: .complete)))
     XCTAssertEqual(b.1.value, .option(.name(.long("foo"))))
   }
-  
+
   func testPeekNextWhenEmpty() throws {
     let sut = try SplitArguments(arguments: [])
     XCTAssertNil(sut.peekNext())
   }
-  
+
   func testPopNextElementIfValueAfter_1() throws {
     var sut = try SplitArguments(arguments: ["--bar", "bar", "--foo", "foo"])
-    
+
     let value = try XCTUnwrap(sut.popNextElementIfValue(after: .argumentIndex(SplitArguments.Index(inputIndex: 0, subIndex: .complete))))
     XCTAssertEqual(value.0, .argumentIndex(SplitArguments.Index(inputIndex: 1, subIndex: .complete)))
     XCTAssertEqual(value.1, "bar")
   }
-  
+
   func testPopNextElementIfValueAfter_2() throws {
     var sut = try SplitArguments(arguments: ["--bar", "bar", "--foo", "foo"])
-    
+
     let value = try XCTUnwrap(sut.popNextElementIfValue(after: .argumentIndex(SplitArguments.Index(inputIndex: 2, subIndex: .complete))))
     XCTAssertEqual(value.0, .argumentIndex(SplitArguments.Index(inputIndex: 3, subIndex: .complete)))
     XCTAssertEqual(value.1, "foo")
   }
-  
+
   func testPopNextElementIfValueAfter_3() throws {
     var sut = try SplitArguments(arguments: ["--bar", "bar", "--foo", "foo"])
     XCTAssertNil(sut.popNextElementIfValue(after: .argumentIndex(SplitArguments.Index(inputIndex: 1, subIndex: .complete))))
   }
-  
+
   func testPopNextValueAfter_1() throws {
     var sut = try SplitArguments(arguments: ["--bar", "bar", "--foo", "foo"])
-    
+
     let valueA = try XCTUnwrap(sut.popNextValue(after: .argumentIndex(SplitArguments.Index(inputIndex: 0, subIndex: .complete))))
     XCTAssertEqual(valueA.0, .argumentIndex(SplitArguments.Index(inputIndex: 1, subIndex: .complete)))
     XCTAssertEqual(valueA.1, "bar")
-    
+
     let valueB = try XCTUnwrap(sut.popNextValue(after: .argumentIndex(SplitArguments.Index(inputIndex: 0, subIndex: .complete))))
     XCTAssertEqual(valueB.0, .argumentIndex(SplitArguments.Index(inputIndex: 3, subIndex: .complete)))
     XCTAssertEqual(valueB.1, "foo")
   }
-  
+
   func testPopNextValueAfter_2() throws {
     var sut = try SplitArguments(arguments: ["--bar", "bar", "--foo", "foo"])
-    
+
     let value = try XCTUnwrap(sut.popNextValue(after: .argumentIndex(SplitArguments.Index(inputIndex: 2, subIndex: .complete))))
     XCTAssertEqual(value.0, .argumentIndex(SplitArguments.Index(inputIndex: 3, subIndex: .complete)))
     XCTAssertEqual(value.1, "foo")
-    
+
     XCTAssertNil(sut.popNextValue(after: .argumentIndex(SplitArguments.Index(inputIndex: 2, subIndex: .complete))))
   }
-  
+
   func testPopNextValueAfter_3() throws {
     var sut = try SplitArguments(arguments: ["--bar", "bar", "--foo", "foo"])
-    
+
     XCTAssertNil(sut.popNextValue(after: .argumentIndex(SplitArguments.Index(inputIndex: 3, subIndex: .complete))))
   }
-  
+
   func testPopNextElementAsValueAfter_1() throws {
     var sut = try SplitArguments(arguments: ["--bar", "bar", "--foo", "foo"])
-    
+
     let valueA = try XCTUnwrap(sut.popNextElementAsValue(after: .argumentIndex(SplitArguments.Index(inputIndex: 0, subIndex: .complete))))
     XCTAssertEqual(valueA.0, .argumentIndex(SplitArguments.Index(inputIndex: 1, subIndex: .complete)))
     XCTAssertEqual(valueA.1, "bar")
-    
+
     let valueB = try XCTUnwrap(sut.popNextElementAsValue(after: .argumentIndex(SplitArguments.Index(inputIndex: 0, subIndex: .complete))))
     XCTAssertEqual(valueB.0, .argumentIndex(SplitArguments.Index(inputIndex: 2, subIndex: .complete)))
     XCTAssertEqual(valueB.1, "--foo")
   }
-  
+
   func testPopNextElementAsValueAfter_2() throws {
     var sut = try SplitArguments(arguments: ["--bar", "bar", "--foo", "foo"])
-    
+
     XCTAssertNil(sut.popNextElementAsValue(after: .argumentIndex(SplitArguments.Index(inputIndex: 3, subIndex: .complete))))
   }
-  
+
   func testPopNextElementAsValueAfter_3() throws {
     var sut = try SplitArguments(arguments: ["--bar", "-bar"])
-    
+
     let value = try XCTUnwrap(sut.popNextElementAsValue(after: .argumentIndex(SplitArguments.Index(inputIndex: 0, subIndex: .complete))))
     XCTAssertEqual(value.0, .argumentIndex(SplitArguments.Index(inputIndex: 1, subIndex: .complete)))
     XCTAssertEqual(value.1, "-bar")
   }
-  
+
   func testPopNextElementIfValue() throws {
     var sut = try SplitArguments(arguments: ["--bar", "bar", "--foo", "foo"])
-    
+
     _ = try XCTUnwrap(sut.popNext())
-    
+
     let value = try XCTUnwrap(sut.popNextElementIfValue())
     XCTAssertEqual(value.0, .argumentIndex(SplitArguments.Index(inputIndex: 1, subIndex: .complete)))
     XCTAssertEqual(value.1, "bar")
-    
+
     XCTAssertNil(sut.popNextElementIfValue())
   }
-  
+
   func testPopNextValue() throws {
     var sut = try SplitArguments(arguments: ["--bar", "bar", "--foo", "foo"])
-    
+
     let valueA = try XCTUnwrap(sut.popNextValue())
     XCTAssertEqual(valueA.0, SplitArguments.Index(inputIndex: 1, subIndex: .complete))
     XCTAssertEqual(valueA.1, "bar")
-    
+
     let valueB = try XCTUnwrap(sut.popNextValue())
     XCTAssertEqual(valueB.0, SplitArguments.Index(inputIndex: 3, subIndex: .complete))
     XCTAssertEqual(valueB.1, "foo")
-    
+
     XCTAssertNil(sut.popNextElementIfValue())
   }
-  
+
   func testPeekNextValue() throws {
     let sut = try SplitArguments(arguments: ["--bar", "bar", "--foo", "foo"])
-    
+
     let valueA = try XCTUnwrap(sut.peekNextValue())
     XCTAssertEqual(valueA.0, SplitArguments.Index(inputIndex: 1, subIndex: .complete))
     XCTAssertEqual(valueA.1, "bar")
-    
+
     let valueB = try XCTUnwrap(sut.peekNextValue())
     XCTAssertEqual(valueB.0, SplitArguments.Index(inputIndex: 1, subIndex: .complete))
     XCTAssertEqual(valueB.1, "bar")
diff --git a/Tests/ArgumentParserUnitTests/StringSnakeCaseTests.swift b/Tests/ArgumentParserUnitTests/StringSnakeCaseTests.swift
index d0c6fd6..9bc2184 100644
--- a/Tests/ArgumentParserUnitTests/StringSnakeCaseTests.swift
+++ b/Tests/ArgumentParserUnitTests/StringSnakeCaseTests.swift
@@ -56,7 +56,7 @@ extension StringSnakeCaseTests {
       XCTAssertEqual(test.0.convertedToSnakeCase(), test.1)
     }
   }
-  
+
   func testStringSnakeCaseWithSeparator() {
     let toSnakeCaseTests = [
       ("simpleOneTwo", "simple-one-two"),
diff --git a/Tests/ArgumentParserUnitTests/StringWrappingTests.swift b/Tests/ArgumentParserUnitTests/StringWrappingTests.swift
index 710aa2b..63169f4 100644
--- a/Tests/ArgumentParserUnitTests/StringWrappingTests.swift
+++ b/Tests/ArgumentParserUnitTests/StringWrappingTests.swift
@@ -57,7 +57,7 @@ extension StringWrappingTests {
             malesuada fames ac turpis egestas sed
             tempus urna.
             """)
-    
+
     XCTAssertEqual(shortSample.wrapped(to: 80), """
             Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor
             incididunt ut labore et dolore magna aliqua. Lectus proin nibh nisl condimentum
@@ -66,7 +66,7 @@ extension StringWrappingTests {
             lacus laoreet. Netus et malesuada fames ac turpis egestas sed tempus urna.
             """)
   }
-  
+
   func testShortWithIndent() {
     XCTAssertEqual(shortSample.wrapped(to: 60, wrappingIndent: 10), """
                       Lorem ipsum dolor sit amet, consectetur
@@ -79,7 +79,7 @@ extension StringWrappingTests {
                       malesuada fames ac turpis egestas sed tempus urna.
             """)
   }
-  
+
   func testLong() {
     XCTAssertEqual(longSample.wrapped(to: 40), """
             Pretium vulputate sapien nec sagittis
@@ -102,7 +102,7 @@ extension StringWrappingTests {
             quisque.       Risus nec feugiat in
             fermentum posuere urna nec tincidunt.
             """)
-    
+
     XCTAssertEqual(longSample.wrapped(to: 80), """
             Pretium vulputate sapien nec sagittis aliquam malesuada bibendum. Ut diam quam
             nulla porttitor.
@@ -119,7 +119,7 @@ extension StringWrappingTests {
             posuere urna nec tincidunt.
             """)
   }
-  
+
   func testLongWithIndent() {
     XCTAssertEqual(longSample.wrapped(to: 60, wrappingIndent: 10), """
                       Pretium vulputate sapien nec sagittis aliquam
@@ -138,7 +138,7 @@ extension StringWrappingTests {
                       neque egestas congue quisque.       Risus nec
                       feugiat in fermentum posuere urna nec tincidunt.
             """)
-    
+
   }
 
   func testJSON() {
@@ -164,7 +164,7 @@ extension StringWrappingTests {
                       }
             """)
   }
-  
+
   func testIndent() {
     XCTAssertEqual(
       shortSample.wrapped(to: 40).indentingEachLine(by: 10),
@@ -182,7 +182,7 @@ extension StringWrappingTests {
     XCTAssertEqual("\na\n\nb\n".indentingEachLine(by: 10),
                    "\n          a\n\n          b\n")
   }
-  
+
   func testHangingIndent() {
     XCTAssertEqual(
       shortSample.wrapped(to: 40).hangingIndentingEachLine(by: 10),
@@ -190,7 +190,7 @@ extension StringWrappingTests {
     XCTAssertEqual(
       longSample.wrapped(to: 40).hangingIndentingEachLine(by: 10),
       String(longSample.wrapped(to: 50, wrappingIndent: 10).dropFirst(10)))
-    
+
     XCTAssertEqual("".hangingIndentingEachLine(by: 10), "")
     XCTAssertEqual("\n".hangingIndentingEachLine(by: 10), "\n")
     XCTAssertEqual("a\n".hangingIndentingEachLine(by: 10), "a\n")
diff --git a/Tests/ArgumentParserUnitTests/TreeTests.swift b/Tests/ArgumentParserUnitTests/TreeTests.swift
index 5196e79..44d477d 100644
--- a/Tests/ArgumentParserUnitTests/TreeTests.swift
+++ b/Tests/ArgumentParserUnitTests/TreeTests.swift
@@ -38,7 +38,7 @@ extension TreeTests {
       tree.children.flatMap { $0.children.map { $0.element } },
       [111, 112, 113, 121, 122, 123, 131, 132, 133])
   }
-  
+
   func testSearch() {
     XCTAssertEqual(
       tree.path(toFirstWhere: { $0 == 1 }).map { $0.element },
@@ -49,22 +49,28 @@ extension TreeTests {
     XCTAssertEqual(
       tree.path(toFirstWhere: { $0 == 133 }).map { $0.element },
       [1, 13, 133])
-    
+
     XCTAssertTrue(tree.path(toFirstWhere: { $0 < 0 }).isEmpty)
   }
 }
 
 extension TreeTests {
   struct A: ParsableCommand {
-    static let configuration = CommandConfiguration(subcommands: [A.self])
+    static let configuration = CommandConfiguration(
+      shouldPromptForMissing: false,
+      subcommands: [A.self])
   }
   struct Root: ParsableCommand {
-    static let configuration = CommandConfiguration(subcommands: [Sub.self])
+    static let configuration = CommandConfiguration(
+      shouldPromptForMissing: false,
+      subcommands: [Sub.self])
   }
   struct Sub: ParsableCommand {
-    static let configuration = CommandConfiguration(subcommands: [Sub.self])
+    static let configuration = CommandConfiguration(
+      shouldPromptForMissing: false,
+      subcommands: [Sub.self])
   }
-    
+
   func testInitializationWithRecursiveSubcommand() {
     XCTAssertThrowsError(try Tree(root: A.asCommand))
     XCTAssertThrowsError(try Tree(root: Root.asCommand))
diff --git a/Tests/ArgumentParserUnitTests/UsageGenerationTests.swift b/Tests/ArgumentParserUnitTests/UsageGenerationTests.swift
index 218861f..1d85b02 100644
--- a/Tests/ArgumentParserUnitTests/UsageGenerationTests.swift
+++ b/Tests/ArgumentParserUnitTests/UsageGenerationTests.swift
@@ -178,7 +178,7 @@ extension UsageGenerationTests {
     enum Color: String, EnumerableFlag {
       case green, blue, yellow
     }
-    
+
     @Flag var a: Bool = false
     @Flag var b: Bool = false
     @Flag var c: Bool = false
@@ -191,12 +191,12 @@ extension UsageGenerationTests {
     @Flag var j: Bool = false
     @Flag var k: Bool = false
     @Flag var l: Bool = false
-    
+
     @Flag(inversion: .prefixedEnableDisable)
     var optionalBool: Bool?
-    
+
     @Flag var optionalColor: Color?
-    
+
     @Option var option: Bool
     @Argument var input: String
     @Argument var output: String?
@@ -205,14 +205,14 @@ extension UsageGenerationTests {
   func testSynopsisWithTooManyOptions() {
     _testSynopsis(M.self, expected: "example [<options>] --option <option> <input> [<output>]")
   }
-  
+
   struct N: ParsableArguments {
     @Flag var a: Bool = false
     @Flag var b: Bool = false
     var title = "defaulted value"
     var decode = false
   }
-  
+
   func testNonwrappedValues() {
     _testSynopsis(N.self, expected: "example [--a] [--b]")
     _testSynopsis(N.self, visibility: .hidden, expected: "example [--a] [--b]")