getopt 1.5.1 → 1.6.0

data/test/test_getopt_long.rb

@@ -1,265 +0,0 @@
-#####################################################################
-# tc_getopt_long.rb
-#
-# Test suite for the getopt-long package. You should run this test
-# via the 'rake test' rake task.
-#####################################################################
-require 'test-unit'
-require 'getopt/long'
-include Getopt
-
-class TC_Getopt_Long < Test::Unit::TestCase
-  def setup
-    @opts = nil
-  end
-
-  def test_version
-    assert_equal('1.5.1', Long::VERSION)
-    assert_true(Long::VERSION.frozen?)
-  end
-
-  def test_constants
-    assert_not_nil(BOOLEAN)
-    assert_not_nil(OPTIONAL)
-    assert_not_nil(REQUIRED)
-    assert_not_nil(INCREMENT)
-  end
-
-  def test_getopts_basic
-    assert_respond_to(Long, :getopts)
-    assert_nothing_raised{
-      Long.getopts(["--test"],["--help"],["--foo"])
-    }
-    assert_nothing_raised{
-      Long.getopts(["--test", "-x"],["--help", "-y"],["--foo", "-z"])
-    }
-    assert_nothing_raised{
-      Long.getopts(
-        ["--test", "-x", BOOLEAN],
-        ["--help", "-y", REQUIRED],
-        ["--foo",  "-z", OPTIONAL],
-        ["--more", "-m", INCREMENT]
-      )
-    }
-    assert_kind_of(Hash, Long.getopts("--test"))
-  end
-
-  def test_getopts_using_equals
-    ARGV.push("--foo=hello","-b","world")
-    assert_nothing_raised{
-      @opts = Long.getopts(
-        ["--foo", "-f", REQUIRED],
-        ["--bar", "-b", OPTIONAL]
-      )
-    }
-    assert_equal("hello", @opts["foo"])
-    assert_equal("hello", @opts["f"])
-    assert_equal("world", @opts["bar"])
-    assert_equal("world", @opts["b"])
-  end
-
-  def test_getopts_long_embedded_hyphens
-    ARGV.push('--foo-bar', 'hello', '--test1-test2-test3', 'world')
-    assert_nothing_raised{
-      @opts = Long.getopts(
-        ['--foo-bar', '-f', REQUIRED],
-        ['--test1-test2-test3', '-t', REQUIRED]
-      )
-    }
-    assert_equal('hello', @opts['foo-bar'])
-    assert_equal('hello', @opts['f'])
-    assert_equal('world', @opts['test1-test2-test3'])
-    assert_equal('world', @opts['t'])
-  end
-
-  def test_getopts_long_embedded_hyphens_using_equals_sign
-    ARGV.push('--foo-bar=hello', '--test1-test2-test3=world')
-    assert_nothing_raised{
-      @opts = Long.getopts(
-        ['--foo-bar', '-f', REQUIRED],
-        ['--test1-test2-test3', '-t', REQUIRED]
-      )
-    }
-    assert_equal('hello', @opts['foo-bar'])
-    assert_equal('hello', @opts['f'])
-    assert_equal('world', @opts['test1-test2-test3'])
-    assert_equal('world', @opts['t'])
-  end
-
-  def test_getopts_short_switch_squished
-    ARGV.push("-f", "hello", "-bworld")
-    assert_nothing_raised{
-      @opts = Long.getopts(
-        ["--foo", "-f", REQUIRED],
-        ["--bar", "-b", OPTIONAL]
-      )
-    }
-    assert_equal("hello", @opts["f"])
-    assert_equal("world", @opts["b"])
-  end
-
-  def test_getopts_increment_type
-    ARGV.push("-m","-m")
-    assert_nothing_raised{
-      @opts = Long.getopts(["--more", "-m", INCREMENT])
-    }
-    assert_equal(2, @opts["more"])
-    assert_equal(2, @opts["m"])
-  end
-
-  def test_switches_exist
-    ARGV.push("--verbose","--test","--foo")
-    assert_nothing_raised{ @opts = Long.getopts("--verbose --test --foo") }
-    assert_equal(true, @opts.has_key?("verbose"))
-    assert_equal(true, @opts.has_key?("test"))
-    assert_equal(true, @opts.has_key?("foo"))
-  end
-
-  def test_short_switch_synonyms
-    ARGV.push("--verbose","--test","--foo")
-    assert_nothing_raised{ @opts = Long.getopts("--verbose --test --foo") }
-    assert_equal(true, @opts.has_key?("v"))
-    assert_equal(true, @opts.has_key?("t"))
-    assert_equal(true, @opts.has_key?("f"))
-  end
-
-  def test_short_switch_synonyms_with_explicit_types
-    ARGV.push("--verbose", "--test", "hello", "--foo")
-    assert_nothing_raised{
-      @opts = Long.getopts(
-        ["--verbose", BOOLEAN],
-        ["--test", REQUIRED],
-        ["--foo", BOOLEAN]
-      )
-    }
-    assert(@opts.has_key?("v"))
-    assert(@opts.has_key?("t"))
-    assert(@opts.has_key?("f"))
-  end
-
-  def test_switches_with_required_arguments
-    ARGV.push("--foo","1","--bar","hello")
-    assert_nothing_raised{
-      @opts = Long.getopts(
-        ["--foo", "-f", REQUIRED],
-        ["--bar", "-b", REQUIRED]
-      )
-    }
-    assert_equal({"foo"=>"1", "bar"=>"hello", "f"=>"1", "b"=>"hello"}, @opts)
-  end
-
-  def test_compressed_switches
-    ARGV.push("-fb")
-    assert_nothing_raised{
-      @opts = Long.getopts(
-        ["--foo", "-f", BOOLEAN],
-        ["--bar", "-b", BOOLEAN]
-      )
-    }
-    assert_equal({"foo"=>true, "f"=>true, "b"=>true, "bar"=>true}, @opts)
-  end
-
-  def test_compress_switches_with_required_arg
-    ARGV.push("-xf", "foo.txt")
-    assert_nothing_raised{
-      @opts = Long.getopts(
-        ["--expand", "-x", BOOLEAN],
-        ["--file", "-f", REQUIRED]
-      )
-    }
-    assert_equal(
-      {"x"=>true, "expand"=>true, "f"=>"foo.txt", "file"=>"foo.txt"}, @opts
-    )
-  end
-
-  def test_compress_switches_with_compressed_required_arg
-    ARGV.push("-xffoo.txt")
-    assert_nothing_raised{
-      @opts = Long.getopts(
-        ["--expand", "-x", BOOLEAN],
-        ["--file", "-f", REQUIRED]
-      )
-    }
-    assert_equal(
-     {"x"=>true, "expand"=>true, "f"=>"foo.txt", "file"=>"foo.txt"}, @opts
-    )
-  end
-
-  def test_compress_switches_with_optional_arg_not_defined
-    ARGV.push("-xf")
-    assert_nothing_raised{
-      @opts = Long.getopts(
-        ["--expand", "-x", BOOLEAN],
-        ["--file", "-f", OPTIONAL]
-      )
-    }
-    assert_equal(
-      {"x"=>true, "expand"=>true, "f"=>nil, "file"=>nil}, @opts
-    )
-  end
-
-  def test_compress_switches_with_optional_arg
-    ARGV.push("-xf", "boo.txt")
-    assert_nothing_raised{
-      @opts = Long.getopts(
-        ["--expand", "-x", BOOLEAN],
-        ["--file", "-f", OPTIONAL]
-      )
-    }
-    assert_equal(
-      {"x"=>true, "expand"=>true, "f"=>"boo.txt", "file"=>"boo.txt"}, @opts
-    )
-  end
-
-  def test_compress_switches_with_compressed_optional_arg
-    ARGV.push("-xfboo.txt")
-    assert_nothing_raised{
-      @opts = Long.getopts(
-        ["--expand", "-x", BOOLEAN],
-        ["--file", "-f", OPTIONAL]
-      )
-    }
-    assert_equal(
-     {"x"=>true, "expand"=>true, "f"=>"boo.txt", "file"=>"boo.txt"}, @opts
-    )
-  end
-
-  def test_compressed_short_and_long_mixed
-    ARGV.push("-xb", "--file", "boo.txt", "-v")
-    assert_nothing_raised{
-      @opts = Long.getopts(
-        ["--expand", "-x", BOOLEAN],
-        ["--verbose", "-v", BOOLEAN],
-        ["--file", "-f", REQUIRED],
-        ["--bar", "-b", OPTIONAL]
-      )
-      assert_equal(
-        { "x"=>true, "expand"=>true,
-          "v"=>true, "verbose"=>true,
-          "f"=>"boo.txt", "file"=>"boo.txt",
-          "b"=>nil, "bar"=>nil
-        },
-        @opts
-      )
-    }
-  end
-
-  def test_multiple_similar_long_switches_with_no_short_switches
-    ARGV.push('--to','1','--too','2','--tooo','3')
-    assert_nothing_raised{
-      @opts = Long.getopts(
-        ["--to",  REQUIRED],
-        ["--too", REQUIRED],
-        ["--tooo", REQUIRED]
-      )
-    }
-    assert_equal('1', @opts['to'])
-    assert_equal('2', @opts['too'])
-    assert_equal('3', @opts['tooo'])
-  end
-
-  def teardown
-    @opts = nil
-    ARGV.clear
-  end
-end

data/test/test_getopt_std.rb

@@ -1,125 +0,0 @@
-###################################################################
-# test_getopt_std.rb
-#
-# Test suite for the Getopt::Std class. You should run this test
-# via the 'rake test' task.
-###################################################################
-require 'test-unit'
-require 'getopt/std'
-include Getopt
-
-class TC_Getopt_Std < Test::Unit::TestCase
-  def test_version
-    assert_equal('1.5.1', Std::VERSION)
-    assert_true(Std::VERSION.frozen?)
-  end
-
-  def test_getopts_basic
-    assert_respond_to(Std, :getopts)
-    assert_nothing_raised{ Std.getopts("ID") }
-    assert_kind_of(Hash, Std.getopts("ID"))
-  end
-
-  def test_getopts_separated_switches
-    ARGV.push("-I", "-D")
-    assert_equal({"I"=>true, "D"=>true}, Std.getopts("ID"))
-  end
-
-  # Inspired by RF bug #23477
-  def test_getopts_arguments_that_match_switch_are_ok
-    ARGV.push("-d", "d")
-    assert_equal({"d" => "d"}, Std.getopts("d:"))
-
-    ARGV.push("-d", "ad")
-    assert_equal({"d" => "ad"}, Std.getopts("d:"))
-
-    ARGV.push("-a", "ad")
-    assert_equal({"a" => "ad"}, Std.getopts("d:a:"))
-
-    ARGV.push("-a", "da")
-    assert_equal({"a" => "da"}, Std.getopts("d:a:"))
-
-    ARGV.push("-a", "d")
-    assert_equal({"a" => "d"}, Std.getopts("d:a:"))
-
-    ARGV.push("-a", "dad")
-    assert_equal({"a" => "dad"}, Std.getopts("d:a:"))
-
-    ARGV.push("-d", "d", "-a", "a")
-    assert_equal({"d" => "d", "a" => "a"}, Std.getopts("d:a:"))
-  end
-
-  def test_getopts_joined_switches
-    ARGV.push("-ID")
-    assert_equal({"I"=>true, "D"=>true}, Std.getopts("ID"))
-  end
-
-  def test_getopts_separated_switches_with_mandatory_arg
-    ARGV.push("-o", "hello", "-I", "-D")
-    assert_equal({"o"=>"hello", "I"=>true, "D"=>true}, Std.getopts("o:ID"))
-  end
-
-  def test_getopts_joined_switches_with_mandatory_arg
-    ARGV.push("-IDo", "hello")
-    assert_equal({"o"=>"hello", "I"=>true, "D"=>true}, Std.getopts("o:ID"))
-  end
-
-  def test_getopts_no_args
-    assert_nothing_raised{ Std.getopts("ID") }
-    assert_equal({}, Std.getopts("ID"))
-    assert_nil(Std.getopts("ID")["I"])
-    assert_nil(Std.getopts("ID")["D"])
-  end
-
-  # If a switch that accepts an argument appears more than once, the values
-  # are rolled into an array.
-  def test_getopts_switch_repeated
-    ARGV.push("-I", "-I", "-o", "hello", "-o", "world")
-    assert_equal({"o" => ["hello","world"], "I"=>true}, Std.getopts("o:ID"))
-  end
-
-  # EXPECTED ERRORS
-
-  def test_getopts_expected_errors_passing_switch_to_another_switch
-    ARGV.push("-d", "-d")
-    assert_raise(Getopt::Std::Error){ Std.getopts("d:a:") }
-
-    ARGV.push("-d", "-a")
-    assert_raise(Getopt::Std::Error){ Std.getopts("d:a:") }
-
-    ARGV.push("-a", "-d")
-    assert_raise(Getopt::Std::Error){ Std.getopts("d:a:") }
-
-    ARGV.push("-d", "-d")
-    assert_raise_message("cannot use switch '-d' as argument to another switch"){ Std.getopts("d:a:") }
-  end
-
-  def test_getopts_expected_errors_missing_arg
-    ARGV.push("-ID")
-    assert_raises(Std::Error){ Std.getopts("I:D") }
-
-    ARGV.push("-ID")
-    assert_raises(Std::Error){ Std.getopts("ID:") }
-  end
-
-  def test_getopts_expected_errors_extra_arg
-    ARGV.push("-I", "-D", "-X")
-    assert_raises(Std::Error){ Std.getopts("ID") }
-
-    ARGV.push("-IDX")
-    assert_raises(Std::Error){ Std.getopts("ID") }
-
-    ARGV.push("-IDX")
-    assert_raise_message("invalid option 'X'"){ Std.getopts("ID") }
-  end
-
-  def test_getopts_expected_errors_basic
-    assert_raises(ArgumentError){ Std.getopts }
-    assert_raises(NoMethodError){ Std.getopts(0) }
-    assert_raises(NoMethodError){ Std.getopts(nil) }
-  end
-
-  def teardown
-    ARGV.clear
-  end
-end