   end
 
   test "parses - as argument" do
-    assert OptionParser.parse(["-a", "-", "-", "-b", "-"], aliases: [b: :boo])
-           == {[boo: "-"], ["-"], [{"-a", "-"}]}
-
-    assert OptionParser.parse(["--foo", "-", "-b", "-"], strict: [foo: :boolean, boo: :string], aliases: [b: :boo])
-           == {[foo: true, boo: "-"], ["-"], []}
+    assert OptionParser.parse(["-a", "-", "-", "-b", "-"], aliases: [b: :boo]) ==
+           {[boo: "-"], ["-"], [{"-a", "-"}]}
+
+    assert OptionParser.parse(["--foo", "-", "-b", "-"], strict: [foo: :boolean, boo: :string], aliases: [b: :boo]) ==
+           {[foo: true, boo: "-"], ["-"], []}
   end
 
   test "allow nonexistent atoms" do

  end

  test "parses alias boolean option as the alias key" do
    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], [], []}
  end

  test "parses more than one boolean options as the alias" do
    assert OptionParser.parse(["-d", "--compile"], aliases: [d: :docs])
           == {[docs: true, compile: true], [], []}
  end

  test "parses --key value option" do
    assert OptionParser.parse(["--source", "form_docs/"])
           == {[source: "form_docs/"], [], []}
  end

  test "parses only to existing atoms" do

  end

  test "correctly handles negative integers" do
    assert OptionParser.parse(["arg1", "-43"]) ==
           {[], ["arg1", "-43"], []}

    assert OptionParser.parse(["arg1", "-o", "-43"], switches: [option: :integer], aliases: [o: :option]) ==
           {[option: -43], ["arg1"], []}

    assert OptionParser.parse(["arg1", "--option=-43"], switches: [option: :integer]) ==
           {[option: -43], ["arg1"], []}
  end

  test "correctly handles negative floating point numbers" do
    assert OptionParser.parse(["arg1", "-43.2"]) ==
           {[], ["arg1", "-43.2"], []}

    assert OptionParser.parse(["arg1", "-o", "-43.2"], switches: [option: :float], aliases: [o: :option]) ==
           {[option: -43.2], ["arg1"], []}

    assert OptionParser.parse(["arg1", "--option=-43.2"], switches: [option: :float]) ==
           {[option: -43.2], ["arg1"], []}
  end

  test "multi-word option" do
    config = [switches: [hello_world: :boolean]]
    assert OptionParser.next(["--hello-world"], config) ==
           {:ok, :hello_world, true, []}
    assert OptionParser.next(["--no-hello-world"], config) ==
           {:ok, :hello_world, false, []}

    assert OptionParser.next(["--hello-world"], []) ==
           {:ok, :hello_world, true, []}
    assert OptionParser.next(["--no-hello-world"], []) ==
           {:ok, :no_hello_world, true, []}
    assert OptionParser.next(["--hello_world"], []) ==
           {:invalid, "--hello_world", nil, []}
    assert OptionParser.next(["--no-hello_world"], []) ==
           {:invalid, "--no-hello_world", nil, []}

    assert OptionParser.next(["--no-hello-world"], strict: []) ==
           {:undefined, "--no-hello-world", nil, []}
    assert OptionParser.next(["--no-hello_world"], strict: []) ==
           {:undefined, "--no-hello_world", nil, []}

    config = [strict: [hello_world: :boolean]]
    assert OptionParser.next(["--hello-world"], config) ==
           {:ok, :hello_world, true, []}
    assert OptionParser.next(["--no-hello-world"], config) ==
           {:ok, :hello_world, false, []}
    assert OptionParser.next(["--hello_world"], config) ==
           {:undefined, "--hello_world", nil, []}
    assert OptionParser.next(["--no-hello_world"], config) ==
           {:undefined, "--no-hello_world", nil, []}
  end

  test "next strict: good options" do
    config = [strict: [str: :string, int: :integer, bool: :boolean]]
    assert OptionParser.next(["--str", "hello", "..."], config) ==
           {:ok, :str, "hello", ["..."]}
    assert OptionParser.next(["--int=13", "..."], config) ==
           {:ok, :int, 13, ["..."]}
    assert OptionParser.next(["--bool=false", "..."], config) ==
           {:ok, :bool, false, ["..."]}
    assert OptionParser.next(["--no-bool", "..."], config) ==
           {:ok, :bool, false, ["..."]}
    assert OptionParser.next(["--bool", "..."], config) ==
           {:ok, :bool, true, ["..."]}
    assert OptionParser.next(["..."], config) ==
           {:error, ["..."]}
  end

  test "next strict: unknown options" do
    config = [strict: [bool: :boolean]]
    assert OptionParser.next(["--str", "13", "..."], config) ==
           {:undefined, "--str", nil, ["13", "..."]}
    assert OptionParser.next(["--int=hello", "..."], config) ==
           {:undefined, "--int", "hello", ["..."]}
    assert OptionParser.next(["-no-bool=other", "..."], config) ==
           {:undefined, "-no-bool", "other", ["..."]}
  end

  test "next strict: bad type" do
    config = [strict: [str: :string, int: :integer, bool: :boolean]]
    assert OptionParser.next(["--str", "13", "..."], config) ==
           {:ok, :str, "13", ["..."]}
    assert OptionParser.next(["--int=hello", "..."], config) ==
           {:invalid, "--int", "hello", ["..."]}
    assert OptionParser.next(["--int", "hello", "..."], config) ==
           {:invalid, "--int", "hello", ["..."]}
    assert OptionParser.next(["--bool=other", "..."], config) ==
           {:invalid, "--bool", "other", ["..."]}
  end

  test "next strict: missing value" do
    config = [strict: [str: :string, int: :integer, bool: :boolean]]
    assert OptionParser.next(["--str"], config) ==
           {:invalid, "--str", nil, []}
    assert OptionParser.next(["--int"], config) ==
           {:invalid, "--int", nil, []}
    assert OptionParser.next(["--bool=", "..."], config) ==
           {:invalid, "--bool", "", ["..."]}
    assert OptionParser.next(["--no-bool=", "..."], config) ==
           {:invalid, "--no-bool", "", ["..."]}
  end

  test "split" do
    assert OptionParser.split(~S[]) ==  []
    assert OptionParser.split(~S[foo]) == ["foo"]
    assert OptionParser.split(~S[foo bar]) == ["foo", "bar"]
    assert OptionParser.split(~S[  foo  bar  ]) == ["foo", "bar"]
    assert OptionParser.split(~S[foo\ bar]) == ["foo bar"]
    assert OptionParser.split(~S[foo" bar"]) == ["foo bar"]
    assert OptionParser.split(~S[foo\" bar\"]) == ["foo\"", "bar\""]
    assert OptionParser.split(~S[foo "\ bar\""]) == ["foo", "\\ bar\""]
    assert OptionParser.split(~S[foo '\"bar"\'\ ']) == ["foo", "\\\"bar\"'\\ "]
  end

  test "to_argv" do
