test_option_parser.rb in cri-2.7.0

- old
+ new
@@ -1,294 +1,282 @@
 # encoding: utf-8
 
-class Cri::OptionParserTestCase < Cri::TestCase
+module Cri
+  class OptionParserTestCase < Cri::TestCase
+    def test_parse_without_options
+      input       = %w( foo bar baz )
+      definitions = []
 
-  def test_parse_without_options
-    input       = %w( foo bar baz )
-    definitions = []
+      parser = Cri::OptionParser.parse(input, definitions)
 
-    parser = Cri::OptionParser.parse(input, definitions)
+      assert_equal({},                      parser.options)
+      assert_equal(%w(foo bar baz), parser.arguments)
+    end
 
-    assert_equal({},                      parser.options)
-    assert_equal([ 'foo', 'bar', 'baz' ], parser.arguments)
-  end
+    def test_parse_with_invalid_option
+      input       = %w( foo -x )
+      definitions = []
 
-  def test_parse_with_invalid_option
-    input       = %w( foo -x )
-    definitions = []
+      assert_raises(Cri::OptionParser::IllegalOptionError) do
+        Cri::OptionParser.parse(input, definitions)
+      end
+    end
 
-    result = nil
+    def test_parse_with_unused_options
+      input       = %w( foo )
+      definitions = [
+        { :long => 'aaa', :short => 'a', :argument => :forbidden },
+      ]
 
-    assert_raises(Cri::OptionParser::IllegalOptionError) do
       parser = Cri::OptionParser.parse(input, definitions)
+
+      assert(!parser.options[:aaa])
     end
-  end
 
-  def test_parse_with_unused_options
-    input       = %w( foo )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :forbidden }
-    ]
+    def test_parse_with_long_valueless_option
+      input       = %w( foo --aaa bar )
+      definitions = [
+        { :long => 'aaa', :short => 'a', :argument => :forbidden },
+      ]
 
-    parser = Cri::OptionParser.parse(input, definitions)
+      parser = Cri::OptionParser.parse(input, definitions)
 
-    assert(!parser.options[:aaa])
-  end
+      assert(parser.options[:aaa])
+      assert_equal(%w(foo bar), parser.arguments)
+    end
 
-  def test_parse_with_long_valueless_option
-    input       = %w( foo --aaa bar )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :forbidden }
-    ]
+    def test_parse_with_long_valueful_option
+      input       = %w( foo --aaa xxx bar )
+      definitions = [
+        { :long => 'aaa', :short => 'a', :argument => :required },
+      ]
 
-    parser = Cri::OptionParser.parse(input, definitions)
+      parser = Cri::OptionParser.parse(input, definitions)
 
-    assert(parser.options[:aaa])
-    assert_equal([ 'foo', 'bar' ], parser.arguments)
-  end
+      assert_equal({ :aaa => 'xxx' },  parser.options)
+      assert_equal(%w(foo bar), parser.arguments)
+    end
 
-  def test_parse_with_long_valueful_option
-    input       = %w( foo --aaa xxx bar )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :required }
-    ]
+    def test_parse_with_long_valueful_equalsign_option
+      input       = %w( foo --aaa=xxx bar )
+      definitions = [
+        { :long => 'aaa', :short => 'a', :argument => :required },
+      ]
 
-    parser = Cri::OptionParser.parse(input, definitions)
+      parser = Cri::OptionParser.parse(input, definitions)
 
-    assert_equal({ :aaa => 'xxx' },  parser.options)
-    assert_equal([ 'foo', 'bar' ], parser.arguments)
-  end
+      assert_equal({ :aaa => 'xxx' },  parser.options)
+      assert_equal(%w(foo bar), parser.arguments)
+    end
 
-  def test_parse_with_long_valueful_equalsign_option
-    input       = %w( foo --aaa=xxx bar )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :required }
-    ]
+    def test_parse_with_long_valueful_option_with_missing_value
+      input       = %w( foo --aaa )
+      definitions = [
+        { :long => 'aaa', :short => 'a', :argument => :required },
+      ]
 
-    parser = Cri::OptionParser.parse(input, definitions)
+      assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
+        Cri::OptionParser.parse(input, definitions)
+      end
+    end
 
-    assert_equal({ :aaa => 'xxx' },  parser.options)
-    assert_equal([ 'foo', 'bar' ], parser.arguments)
-  end
+    def test_parse_with_two_long_valueful_options
+      input       = %w( foo --all --port 2 )
+      definitions = [
+        { :long => 'all',  :short => 'a', :argument => :required  },
+        { :long => 'port', :short => 'p', :argument => :required },
+      ]
 
-  def test_parse_with_long_valueful_option_with_missing_value
-    input       = %w( foo --aaa )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :required }
-    ]
+      assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
+        Cri::OptionParser.parse(input, definitions)
+      end
+    end
 
-    result = nil
+    def test_parse_with_long_valueless_option_with_optional_value
+      input       = %w( foo --aaa )
+      definitions = [
+        { :long => 'aaa', :short => 'a', :argument => :optional },
+      ]
 
-    assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
       parser = Cri::OptionParser.parse(input, definitions)
+
+      assert(parser.options[:aaa])
+      assert_equal(['foo'], parser.arguments)
     end
-  end
 
-  def test_parse_with_two_long_valueful_options
-    input       = %w( foo --all --port 2 )
-    definitions = [
-      { :long => 'all',  :short => 'a', :argument => :required  },
-      { :long => 'port', :short => 'p', :argument => :required }
-    ]
+    def test_parse_with_long_valueful_option_with_optional_value
+      input       = %w( foo --aaa xxx )
+      definitions = [
+        { :long => 'aaa', :short => 'a', :argument => :optional },
+      ]
 
-    result = nil
-
-    assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
       parser = Cri::OptionParser.parse(input, definitions)
+
+      assert_equal({ :aaa => 'xxx' },  parser.options)
+      assert_equal(['foo'], parser.arguments)
     end
-  end
 
-  def test_parse_with_long_valueless_option_with_optional_value
-    input       = %w( foo --aaa )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :optional }
-    ]
+    def test_parse_with_long_valueless_option_with_optional_value_and_more_options
+      input       = %w( foo --aaa -b -c )
+      definitions = [
+        { :long => 'aaa', :short => 'a', :argument => :optional  },
+        { :long => 'bbb', :short => 'b', :argument => :forbidden },
+        { :long => 'ccc', :short => 'c', :argument => :forbidden },
+      ]
 
-    parser = Cri::OptionParser.parse(input, definitions)
+      parser = Cri::OptionParser.parse(input, definitions)
 
-    assert(parser.options[:aaa])
-    assert_equal([ 'foo' ], parser.arguments)
-  end
+      assert(parser.options[:aaa])
+      assert(parser.options[:bbb])
+      assert(parser.options[:ccc])
+      assert_equal(['foo'], parser.arguments)
+    end
 
-  def test_parse_with_long_valueful_option_with_optional_value
-    input       = %w( foo --aaa xxx )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :optional }
-    ]
+    def test_parse_with_short_valueless_options
+      input       = %w( foo -a bar )
+      definitions = [
+        { :long => 'aaa', :short => 'a', :argument => :forbidden },
+      ]
 
-    parser = Cri::OptionParser.parse(input, definitions)
+      parser = Cri::OptionParser.parse(input, definitions)
 
-    assert_equal({ :aaa => 'xxx' },  parser.options)
-    assert_equal([ 'foo' ], parser.arguments)
-  end
+      assert(parser.options[:aaa])
+      assert_equal(%w(foo bar), parser.arguments)
+    end
 
-  def test_parse_with_long_valueless_option_with_optional_value_and_more_options
-    input       = %w( foo --aaa -b -c )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :optional  },
-      { :long => 'bbb', :short => 'b', :argument => :forbidden },
-      { :long => 'ccc', :short => 'c', :argument => :forbidden }
-    ]
+    def test_parse_with_short_valueful_option_with_missing_value
+      input       = %w( foo -a )
+      definitions = [
+        { :long => 'aaa', :short => 'a', :argument => :required },
+      ]
 
-    parser = Cri::OptionParser.parse(input, definitions)
+      assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
+        Cri::OptionParser.parse(input, definitions)
+      end
+    end
 
-    assert(parser.options[:aaa])
-    assert(parser.options[:bbb])
-    assert(parser.options[:ccc])
-    assert_equal([ 'foo' ], parser.arguments)
-  end
+    def test_parse_with_short_combined_valueless_options
+      input       = %w( foo -abc bar )
+      definitions = [
+        { :long => 'aaa', :short => 'a', :argument => :forbidden },
+        { :long => 'bbb', :short => 'b', :argument => :forbidden },
+        { :long => 'ccc', :short => 'c', :argument => :forbidden },
+      ]
 
-  def test_parse_with_short_valueless_options
-    input       = %w( foo -a bar )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :forbidden }
-    ]
+      parser = Cri::OptionParser.parse(input, definitions)
 
-    parser = Cri::OptionParser.parse(input, definitions)
+      assert(parser.options[:aaa])
+      assert(parser.options[:bbb])
+      assert(parser.options[:ccc])
+      assert_equal(%w(foo bar), parser.arguments)
+    end
 
-    assert(parser.options[:aaa])
-    assert_equal([ 'foo', 'bar' ], parser.arguments)
-  end
+    def test_parse_with_short_combined_valueful_options_with_missing_value
+      input       = %w( foo -abc bar )
+      definitions = [
+        { :long => 'aaa', :short => 'a', :argument => :required  },
+        { :long => 'bbb', :short => 'b', :argument => :forbidden },
+        { :long => 'ccc', :short => 'c', :argument => :forbidden },
+      ]
 
-  def test_parse_with_short_valueful_option_with_missing_value
-    input       = %w( foo -a )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :required }
-    ]
+      assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
+        Cri::OptionParser.parse(input, definitions)
+      end
+    end
 
-    result = nil
+    def test_parse_with_two_short_valueful_options
+      input       = %w( foo -a -p 2 )
+      definitions = [
+        { :long => 'all',  :short => 'a', :argument => :required  },
+        { :long => 'port', :short => 'p', :argument => :required },
+      ]
 
-    assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
-      parser = Cri::OptionParser.parse(input, definitions)
+      assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
+        Cri::OptionParser.parse(input, definitions)
+      end
     end
-  end
 
-  def test_parse_with_short_combined_valueless_options
-    input       = %w( foo -abc bar )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :forbidden },
-      { :long => 'bbb', :short => 'b', :argument => :forbidden },
-      { :long => 'ccc', :short => 'c', :argument => :forbidden }
-    ]
+    def test_parse_with_short_valueless_option_with_optional_value
+      input       = %w( foo -a )
+      definitions = [
+        { :long => 'aaa', :short => 'a', :argument => :optional },
+      ]
 
-    parser = Cri::OptionParser.parse(input, definitions)
+      parser = Cri::OptionParser.parse(input, definitions)
 
-    assert(parser.options[:aaa])
-    assert(parser.options[:bbb])
-    assert(parser.options[:ccc])
-    assert_equal([ 'foo', 'bar' ], parser.arguments)
-  end
+      assert(parser.options[:aaa])
+      assert_equal(['foo'], parser.arguments)
+    end
 
-  def test_parse_with_short_combined_valueful_options_with_missing_value
-    input       = %w( foo -abc bar )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :required  },
-      { :long => 'bbb', :short => 'b', :argument => :forbidden },
-      { :long => 'ccc', :short => 'c', :argument => :forbidden }
-    ]
+    def test_parse_with_short_valueful_option_with_optional_value
+      input       = %w( foo -a xxx )
+      definitions = [
+        { :long => 'aaa', :short => 'a', :argument => :optional },
+      ]
 
-    result = nil
-
-    assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
       parser = Cri::OptionParser.parse(input, definitions)
+
+      assert_equal({ :aaa => 'xxx' },  parser.options)
+      assert_equal(['foo'], parser.arguments)
     end
-  end
 
-  def test_parse_with_two_short_valueful_options
-    input       = %w( foo -a -p 2 )
-    definitions = [
-      { :long => 'all',  :short => 'a', :argument => :required  },
-      { :long => 'port', :short => 'p', :argument => :required }
-    ]
+    def test_parse_with_short_valueless_option_with_optional_value_and_more_options
+      input       = %w( foo -a -b -c )
+      definitions = [
+        { :long => 'aaa', :short => 'a', :argument => :optional  },
+        { :long => 'bbb', :short => 'b', :argument => :forbidden },
+        { :long => 'ccc', :short => 'c', :argument => :forbidden },
+      ]
 
-    result = nil
-
-    assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
       parser = Cri::OptionParser.parse(input, definitions)
+
+      assert(parser.options[:aaa])
+      assert(parser.options[:bbb])
+      assert(parser.options[:ccc])
+      assert_equal(['foo'], parser.arguments)
     end
-  end
 
-  def test_parse_with_short_valueless_option_with_optional_value
-    input       = %w( foo -a )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :optional }
-    ]
+    def test_parse_with_single_hyphen
+      input       = %w( foo - bar )
+      definitions = []
 
-    parser = Cri::OptionParser.parse(input, definitions)
+      parser = Cri::OptionParser.parse(input, definitions)
 
-    assert(parser.options[:aaa])
-    assert_equal([ 'foo' ], parser.arguments)
-  end
+      assert_equal({},                    parser.options)
+      assert_equal(['foo', '-', 'bar'], parser.arguments)
+    end
 
-  def test_parse_with_short_valueful_option_with_optional_value
-    input       = %w( foo -a xxx )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :optional }
-    ]
+    def test_parse_with_end_marker
+      input       = %w( foo bar -- -x --yyy -abc )
+      definitions = []
 
-    parser = Cri::OptionParser.parse(input, definitions)
+      parser = Cri::OptionParser.parse(input, definitions)
 
-    assert_equal({ :aaa => 'xxx' },  parser.options)
-    assert_equal([ 'foo' ], parser.arguments)
-  end
+      assert_equal({},                                            parser.options)
+      assert_equal(['foo', 'bar', '-x', '--yyy', '-abc'],       parser.arguments)
+      assert_equal(['foo', 'bar', '--', '-x', '--yyy', '-abc'], parser.arguments.raw)
+    end
 
-  def test_parse_with_short_valueless_option_with_optional_value_and_more_options
-    input       = %w( foo -a -b -c )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :optional  },
-      { :long => 'bbb', :short => 'b', :argument => :forbidden },
-      { :long => 'ccc', :short => 'c', :argument => :forbidden }
-    ]
+    def test_parse_with_end_marker_between_option_key_and_value
+      input       = %w( foo --aaa -- zzz )
+      definitions = [
+        { :long => 'aaa', :short => 'a', :argument => :required },
+      ]
 
-    parser = Cri::OptionParser.parse(input, definitions)
+      assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
+        Cri::OptionParser.parse(input, definitions)
+      end
+    end
 
-    assert(parser.options[:aaa])
-    assert(parser.options[:bbb])
-    assert(parser.options[:ccc])
-    assert_equal([ 'foo' ], parser.arguments)
-  end
-
-  def test_parse_with_single_hyphen
-    input       = %w( foo - bar )
-    definitions = []
-
-    parser = Cri::OptionParser.parse(input, definitions)
-
-    assert_equal({},                    parser.options)
-    assert_equal([ 'foo', '-', 'bar' ], parser.arguments)
-  end
-
-  def test_parse_with_end_marker
-    input       = %w( foo bar -- -x --yyy -abc )
-    definitions = []
-
-    parser = Cri::OptionParser.parse(input, definitions)
-
-    assert_equal({},                                            parser.options)
-    assert_equal([ 'foo', 'bar', '-x', '--yyy', '-abc' ],       parser.arguments)
-    assert_equal([ 'foo', 'bar', '--', '-x', '--yyy', '-abc' ], parser.arguments.raw)
-  end
-
-  def test_parse_with_end_marker_between_option_key_and_value
-    input       = %w( foo --aaa -- zzz )
-    definitions = [
-      { :long => 'aaa', :short => 'a', :argument => :required }
-    ]
-
-    assert_raises(Cri::OptionParser::OptionRequiresAnArgumentError) do
+    def test_parse_with_multiple_options
+      input = %w( foo -o test -o test2 -v -v -v)
+      definitions = [
+        { :long => 'long', :short => 'o', :argument => :required, :multiple => true },
+        { :long => 'verbose', :short => 'v', :multiple => true },
+      ]
       parser = Cri::OptionParser.parse(input, definitions)
+
+      assert_equal(%w(test test2), parser.options[:long])
+      assert_equal(3, parser.options[:verbose].size)
     end
   end
-
-  def test_parse_with_multiple_options
-    input = %w( foo -o test -o test2 -v -v -v)
-    definitions = [
-      { :long => 'long', :short => 'o', :argument => :required, :multiple => true },
-      { :long => 'verbose', :short => 'v', :multiple => true }
-    ]
-    parser = Cri::OptionParser.parse(input, definitions)
-
-    assert_equal(['test', 'test2'], parser.options[:long])
-    assert_equal(3, parser.options[:verbose].size)
-  end
-
 end