   end
 
   test "parses alias boolean option as the alias key" do
-    assert OptionParser.parse(["-d"], aliases: [d: :docs]) ==
-           {[docs: true], [], []}
+    assert OptionParser.parse(["-d"], aliases: [d: :docs]) == {[docs: true], [], []}
   end
 
   test "parses more than one boolean option" do
-    assert OptionParser.parse(["--docs", "--compile"]) ==
-           {[docs: true, compile: true], [], []}
+    assert OptionParser.parse(["--docs", "--compile"]) == {[docs: true, compile: true], [], []}
   end
 
   test "parses more than one boolean options as the alias" do
     assert OptionParser.parse(["-d", "--compile"], aliases: [d: :docs]) ==
-           {[docs: true, compile: true], [], []}
+             {[docs: true, compile: true], [], []}
   end
 
   test "parses --key value option" do
-    assert OptionParser.parse(["--source", "form_docs/"]) ==
-           {[source: "form_docs/"], [], []}
+    assert OptionParser.parse(["--source", "form_docs/"]) == {[source: "form_docs/"], [], []}
   end
 
   test "parses only to existing atoms" do
     assert OptionParser.parse(["--option-key-does-not-exist"]) ==
-           {[], [], [{"--option-key-does-not-exist", nil}]}
+             {[], [], [{"--option-key-does-not-exist", nil}]}
   end
 
   test "parses --key=value option" do
     assert OptionParser.parse(["--source=form_docs/", "other"]) ==
-           {[source: "form_docs/"], ["other"], []}
+             {[source: "form_docs/"], ["other"], []}
   end
 
   test "parses alias --key value option as the alias" do
     assert OptionParser.parse(["-s", "from_docs/"], aliases: [s: :source]) ==
-           {[source: "from_docs/"], [], []}
+             {[source: "from_docs/"], [], []}
   end
 
   test "parses alias --key=value option as the alias" do
     assert OptionParser.parse(["-s=from_docs/", "other"], aliases: [s: :source]) ==
-           {[source: "from_docs/"], ["other"], []}
+             {[source: "from_docs/"], ["other"], []}
   end
 
   test "does not interpret undefined options with value as boolean" do
-    assert OptionParser.parse(["--no-bool"]) ==
-           {[no_bool: true], [], []}
-    assert OptionParser.parse(["--no-bool"], strict: []) ==
-           {[], [], [{"--no-bool", nil}]}
-    assert OptionParser.parse(["--no-bool=...", "other"]) ==
-           {[no_bool: "..."], ["other"], []}
+    assert OptionParser.parse(["--no-bool"]) == {[no_bool: true], [], []}
+    assert OptionParser.parse(["--no-bool"], strict: []) == {[], [], [{"--no-bool", nil}]}
+    assert OptionParser.parse(["--no-bool=...", "other"]) == {[no_bool: "..."], ["other"], []}
   end
 
   test "does not parse -- as an alias" do
     assert OptionParser.parse(["--s=from_docs/"], aliases: [s: :source]) ==
-           {[s: "from_docs/"], [], []}
+             {[s: "from_docs/"], [], []}
   end
 
   test "parses -ab as -a -b" do
     aliases = [a: :first, b: :second]
 
-    assert OptionParser.parse(["-ab"], aliases: aliases) ==
-           {[first: true, second: true], [], []}
+    assert OptionParser.parse(["-ab"], aliases: aliases) == {[first: true, second: true], [], []}
 
     assert OptionParser.parse(["-ab=1"], aliases: aliases, switches: [second: :integer]) ==
-           {[first: true, second: 1], [], []}
+             {[first: true, second: 1], [], []}
 
     assert OptionParser.parse(["-ab", "1"], aliases: aliases, switches: [second: :integer]) ==
-           {[first: true, second: 1], [], []}
+             {[first: true, second: 1], [], []}
   end
 
   test "parses configured booleans" do
     assert OptionParser.parse(["--docs=false"], switches: [docs: :boolean]) ==
-           {[docs: false], [], []}
+             {[docs: false], [], []}
+
     assert OptionParser.parse(["--docs=true"], switches: [docs: :boolean]) ==
-           {[docs: true], [], []}
+             {[docs: true], [], []}
+
     assert OptionParser.parse(["--docs=other"], switches: [docs: :boolean]) ==
-           {[], [], [{"--docs", "other"}]}
+             {[], [], [{"--docs", "other"}]}
+
     assert OptionParser.parse(["--docs="], switches: [docs: :boolean]) ==
-           {[], [], [{"--docs", ""}]}
+             {[], [], [{"--docs", ""}]}
 
     assert OptionParser.parse(["--docs", "foo"], switches: [docs: :boolean]) ==
-           {[docs: true], ["foo"], []}
+             {[docs: true], ["foo"], []}
+
     assert OptionParser.parse(["--no-docs", "foo"], switches: [docs: :boolean]) ==
-           {[docs: false], ["foo"], []}
+             {[docs: false], ["foo"], []}
+
     assert OptionParser.parse(["--no-docs=foo", "bar"], switches: [docs: :boolean]) ==
-           {[], ["bar"], [{"--no-docs", "foo"}]}
+             {[], ["bar"], [{"--no-docs", "foo"}]}
+
     assert OptionParser.parse(["--no-docs=", "bar"], switches: [docs: :boolean]) ==
-           {[], ["bar"], [{"--no-docs", ""}]}
+             {[], ["bar"], [{"--no-docs", ""}]}
   end
 
   test "does not set unparsed booleans" do
-    assert OptionParser.parse(["foo"], switches: [docs: :boolean]) ==
-           {[], ["foo"], []}
+    assert OptionParser.parse(["foo"], switches: [docs: :boolean]) == {[], ["foo"], []}
   end
 
   test "keeps options on configured keep" do
     argv = ["--require", "foo", "--require", "bar", "baz"]
+
     assert OptionParser.parse(argv, switches: [require: :keep]) ==
-           {[require: "foo", require: "bar"], ["baz"], []}
+             {[require: "foo", require: "bar"], ["baz"], []}
 
     assert OptionParser.parse(["--require"], switches: [require: :keep]) ==
-           {[], [], [{"--require", nil}]}
+             {[], [], [{"--require", nil}]}
   end
 
   test "parses configured strings" do
     assert OptionParser.parse(["--value", "1", "foo"], switches: [value: :string]) ==
-           {[value: "1"], ["foo"], []}
+             {[value: "1"], ["foo"], []}
+
     assert OptionParser.parse(["--value=1", "foo"], switches: [value: :string]) ==
-           {[value: "1"], ["foo"], []}
+             {[value: "1"], ["foo"], []}
+
     assert OptionParser.parse(["--value"], switches: [value: :string]) ==
-           {[], [], [{"--value", nil}]}
+             {[], [], [{"--value", nil}]}
+
     assert OptionParser.parse(["--no-value"], switches: [value: :string]) ==
-           {[no_value: true], [], []}
+             {[no_value: true], [], []}
   end
 
   test "parses configured counters" do
     assert OptionParser.parse(["--verbose"], switches: [verbose: :count]) ==
-           {[verbose: 1], [], []}
+             {[verbose: 1], [], []}
+
     assert OptionParser.parse(["--verbose", "--verbose"], switches: [verbose: :count]) ==
-           {[verbose: 2], [], []}
-    assert OptionParser.parse(["--verbose", "-v", "-v", "--", "bar"],
-                              aliases: [v: :verbose], strict: [verbose: :count]) ==
-           {[verbose: 3], ["bar"], []}
+             {[verbose: 2], [], []}
+
+    argv = ["--verbose", "-v", "-v", "--", "bar"]
+    opts = [aliases: [v: :verbose], strict: [verbose: :count]]
+    assert OptionParser.parse(argv, opts) == {[verbose: 3], ["bar"], []}
   end
 
   test "parses configured integers" do
     assert OptionParser.parse(["--value", "1", "foo"], switches: [value: :integer]) ==
-           {[value: 1], ["foo"], []}
+             {[value: 1], ["foo"], []}
+
     assert OptionParser.parse(["--value=1", "foo"], switches: [value: :integer]) ==
-           {[value: 1], ["foo"], []}
+             {[value: 1], ["foo"], []}
+
     assert OptionParser.parse(["--value", "WAT", "foo"], switches: [value: :integer]) ==
-           {[], ["foo"], [{"--value", "WAT"}]}
+             {[], ["foo"], [{"--value", "WAT"}]}
   end
 
   test "parses configured integers with keep" do
     argv = ["--value", "1", "--value", "2", "foo"]
+
     assert OptionParser.parse(argv, switches: [value: [:integer, :keep]]) ==
-           {[value: 1, value: 2], ["foo"], []}
+             {[value: 1, value: 2], ["foo"], []}
 
     argv = ["--value=1", "foo", "--value=2", "bar"]
+
     assert OptionParser.parse(argv, switches: [value: [:integer, :keep]]) ==
-           {[value: 1, value: 2], ["foo", "bar"], []}
+             {[value: 1, value: 2], ["foo", "bar"], []}
   end
 
   test "parses configured floats" do
     assert OptionParser.parse(["--value", "1.0", "foo"], switches: [value: :float]) ==
-           {[value: 1.0], ["foo"], []}
+             {[value: 1.0], ["foo"], []}
+
     assert OptionParser.parse(["--value=1.0", "foo"], switches: [value: :float]) ==
-           {[value: 1.0], ["foo"], []}
+             {[value: 1.0], ["foo"], []}
+
     assert OptionParser.parse(["--value", "WAT", "foo"], switches: [value: :float]) ==
-           {[], ["foo"], [{"--value", "WAT"}]}
+             {[], ["foo"], [{"--value", "WAT"}]}
   end
 
   test "overrides options by default" do
     assert OptionParser.parse(["--require", "foo", "--require", "bar", "baz"]) ==
-           {[require: "bar"], ["baz"], []}
+             {[require: "bar"], ["baz"], []}
   end
 
   test "parses mixed options" do
     argv = ["--source", "from_docs/", "--compile", "-x"]
+
     assert OptionParser.parse(argv, aliases: [x: :x]) ==
-           {[source: "from_docs/", compile: true, x: true], [], []}
+             {[source: "from_docs/", compile: true, x: true], [], []}
   end
 
   test "stops on first non-option arguments" do
     argv = ["--source", "from_docs/", "test/enum_test.exs", "--verbose"]
+
     assert OptionParser.parse_head(argv) ==
-           {[source: "from_docs/"], ["test/enum_test.exs", "--verbose"], []}
+             {[source: "from_docs/"], ["test/enum_test.exs", "--verbose"], []}
   end
 
   test "stops on --" do

  end

  test "to_argv" do
    assert OptionParser.to_argv([foo_bar: "baz"]) ==
           ["--foo-bar", "baz"]

    assert OptionParser.to_argv([bool: true, bool: false, discarded: nil]) ==
           ["--bool", "--no-bool"]
  end

  test ":count switch type can be translated back" do
    original = ["--counter", "--counter"]
    {opts, [], []} = OptionParser.parse(original,  [switches: [counter: :count]])
    assert original == OptionParser.to_argv(opts, [switches: [counter: :count]])
  end
end


  test "goes beyond the first non-option arguments" do
    argv = ["--source", "from_docs/", "test/enum_test.exs", "--verbose"]

    assert OptionParser.parse(argv) ==
             {[source: "from_docs/", verbose: true], ["test/enum_test.exs"], []}
  end

  test "parses more than one key/value options" do
    assert OptionParser.parse(["--source", "from_docs/", "--docs", "show"]) ==
             {[source: "from_docs/", docs: "show"], [], []}
  end

  test "collects multiple invalid options" do
    argv = ["--bad", "opt", "foo", "-o", "bad", "bar"]

    assert OptionParser.parse(argv, switches: [bad: :integer]) ==
             {[], ["foo", "bar"], [{"--bad", "opt"}, {"-o", "bad"}]}
  end

  test "parses more than one key/value options using strict" do
    opts = [
      strict: [
        source: :string,
        docs: :string
      ]
    ]

    options = OptionParser.parse(["--source", "from_docs/", "--docs", "show"], opts)
    assert options == {[source: "from_docs/", docs: "show"], [], []}

    options = OptionParser.parse(["--source", "from_docs/", "--doc", "show"], opts)
    assert options == {[source: "from_docs/"], ["show"], [{"--doc", nil}]}

    options = OptionParser.parse(["--source", "from_docs/", "--doc=show"], opts)
    assert options == {[source: "from_docs/"], [], [{"--doc", nil}]}
  end

  test "parse/2 raises when using both options: switches and strict" do
