trollop 2.1.2 → 2.1.3

data/test/support/assert_helpers.rb

@@ -0,0 +1,46 @@
+module Minitest::Assertions
+  def assert_parses_correctly(parser, commandline, expected_opts,
+                              expected_leftovers)
+    opts = parser.parse commandline
+    assert_equal expected_opts, opts
+    assert_equal expected_leftovers, parser.leftovers
+  end
+
+  def assert_stderr(str = nil, msg = nil)
+    msg = "#{msg}.\n" if msg
+
+    old_stderr, $stderr = $stderr, StringIO.new('')
+    yield
+    assert_match str, $stderr.string, msg if str
+  ensure
+    $stderr = old_stderr
+  end
+
+  def assert_stdout(str = nil, msg = nil)
+    msg = "#{msg}.\n" if msg
+
+    old_stdout, $stdout = $stdout, StringIO.new('')
+    yield
+    assert_match str, $stdout.string, msg if str
+  ensure
+    $stdout = old_stdout
+  end
+
+  # like assert raises, but if it does raise, it checks status
+  # NOTE: this does not ensure the exception is raised
+  def assert_system_exit *exp
+    msg = "#{exp.pop}.\n" if String === exp.last
+    status = exp.first
+
+    begin
+      yield
+    rescue SystemExit => e
+      assert_equal status, e.status {
+        exception_details(e, "#{msg}#{mu_pp(exp)} exception expected, not")
+      } if status
+      return true
+    end
+    flunk "#{msg}#{mu_pp(exp)} SystemExit expected but nothing was raised."
+  end
+end
+

data/test/test_helper.rb

@@ -3,7 +3,9 @@ $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 unless ENV['MUTANT']
   begin
   require "coveralls"
-  Coveralls.wear!
+  Coveralls.wear! do
+    add_filter '/test/'
+  end
   rescue LoadError
   end
 end
@@ -15,4 +17,6 @@ end
 
 require 'minitest/autorun'
 
+Dir[File.expand_path('../support/**/*.rb', __FILE__)].each { |f| require f }
+
 require 'trollop'

data/test/trollop/command_line_error_test.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+module Trollop
+  class CommandlineErrorTest < ::MiniTest::Test
+    def test_class
+      assert_kind_of Exception, cle("message")
+    end
+
+    def test_message
+      assert "message", cle("message").message
+    end
+
+    def test_error_code_default
+      assert_nil cle("message").error_code
+    end
+
+    def test_error_code_custom
+      assert_equal(-3, cle("message", -3).error_code)
+    end
+
+    private
+
+    def cle(*args)
+      CommandlineError.new(*args)
+    end
+  end
+end

data/test/trollop/help_needed_test.rb

@@ -0,0 +1,19 @@
+require 'test_helper'
+
+module Trollop
+  class HelpNeededTest < ::MiniTest::Test
+    def test_class
+      assert_kind_of Exception, hn("message")
+    end
+
+    def test_message
+      assert "message", hn("message").message
+    end
+
+    private
+
+    def hn(*args)
+      HelpNeeded.new(*args)
+    end
+  end
+end

data/test/trollop/parser_educate_test.rb

@@ -0,0 +1,175 @@
+require 'stringio'
+require 'test_helper'
+
+module Trollop
+  class ParserEduateTest < ::MiniTest::Test
+    def setup
+    end
+
+    def test_no_arguments_to_stdout
+      assert_stdout(/Options:/) do
+        parser.educate
+      end
+    end
+
+    def test_argument_to_stringio
+      assert_educates(/Options:/)
+    end
+
+    def test_no_headers
+      assert_educates(/^Options:/)
+    end
+
+    def test_usage
+      parser.usage("usage string")
+      assert_educates(/^Usage: \w* usage string\n\nOptions:/)
+    end
+
+    def test_usage_synopsis_version
+    end
+
+    # def test_banner
+    # def test_text
+
+      # width, legacy_width
+      # wrap
+      # wrap_lines
+
+############
+# convert these into multiple tests
+# pulled out of trollop_test for now
+  def test_help_has_default_banner
+    @p = Parser.new
+    sio = StringIO.new "w"
+    @p.parse []
+    @p.educate sio
+    help = sio.string.split "\n"
+    assert help[0] =~ /options/i
+    assert_equal 2, help.length # options, then -h
+
+    @p = Parser.new
+    @p.version "my version"
+    sio = StringIO.new "w"
+    @p.parse []
+    @p.educate sio
+    help = sio.string.split "\n"
+    assert help[0] =~ /my version/i
+    assert_equal 4, help.length # version, options, -h, -v
+
+    @p = Parser.new
+    @p.banner "my own banner"
+    sio = StringIO.new "w"
+    @p.parse []
+    @p.educate sio
+    help = sio.string.split "\n"
+    assert help[0] =~ /my own banner/i
+    assert_equal 2, help.length # banner, -h
+
+    @p = Parser.new
+    @p.text "my own text banner"
+    sio = StringIO.new "w"
+    @p.parse []
+    @p.educate sio
+    help = sio.string.split "\n"
+    assert help[0] =~ /my own text banner/i
+    assert_equal 2, help.length # banner, -h
+  end
+
+  def test_help_has_optional_usage
+    @p = Parser.new
+    @p.usage "OPTIONS FILES"
+    sio = StringIO.new "w"
+    @p.parse []
+    @p.educate sio
+    help = sio.string.split "\n"
+    assert help[0] =~ /OPTIONS FILES/i
+    assert_equal 4, help.length # line break, options, then -h
+  end
+
+  def test_help_has_optional_synopsis
+    @p = Parser.new
+    @p.synopsis "About this program"
+    sio = StringIO.new "w"
+    @p.parse []
+    @p.educate sio
+    help = sio.string.split "\n"
+    assert help[0] =~ /About this program/i
+    assert_equal 4, help.length # line break, options, then -h
+  end
+
+  def test_help_has_specific_order_for_usage_and_synopsis
+    @p = Parser.new
+    @p.usage "OPTIONS FILES"
+    @p.synopsis "About this program"
+    sio = StringIO.new "w"
+    @p.parse []
+    @p.educate sio
+    help = sio.string.split "\n"
+    assert help[0] =~ /OPTIONS FILES/i
+    assert help[1] =~ /About this program/i
+    assert_equal 5, help.length # line break, options, then -h
+  end
+
+  def test_help_preserves_positions
+    parser.opt :zzz, "zzz"
+    parser.opt :aaa, "aaa"
+    sio = StringIO.new "w"
+    parser.educate sio
+
+    help = sio.string.split "\n"
+    assert help[1] =~ /zzz/
+    assert help[2] =~ /aaa/
+  end
+
+  def test_help_includes_option_types
+    parser.opt :arg1, 'arg', :type => :int
+    parser.opt :arg2, 'arg', :type => :ints
+    parser.opt :arg3, 'arg', :type => :string
+    parser.opt :arg4, 'arg', :type => :strings
+    parser.opt :arg5, 'arg', :type => :float
+    parser.opt :arg6, 'arg', :type => :floats
+    parser.opt :arg7, 'arg', :type => :io
+    parser.opt :arg8, 'arg', :type => :ios
+    parser.opt :arg9, 'arg', :type => :date
+    parser.opt :arg10, 'arg', :type => :dates
+    sio = StringIO.new "w"
+    parser.educate sio
+
+    help = sio.string.split "\n"
+    assert help[1] =~ /<i>/
+    assert help[2] =~ /<i\+>/
+    assert help[3] =~ /<s>/
+    assert help[4] =~ /<s\+>/
+    assert help[5] =~ /<f>/
+    assert help[6] =~ /<f\+>/
+    assert help[7] =~ /<filename\/uri>/
+    assert help[8] =~ /<filename\/uri\+>/
+    assert help[9] =~ /<date>/
+    assert help[10] =~ /<date\+>/
+  end
+
+  def test_help_has_grammatical_default_text
+    parser.opt :arg1, 'description with period.', :default => 'hello'
+    parser.opt :arg2, 'description without period', :default => 'world'
+    sio = StringIO.new 'w'
+    parser.educate sio
+
+    help = sio.string.split "\n"
+    assert help[1] =~ /Default/
+    assert help[2] =~ /default/
+  end
+############
+
+    private
+
+    def parser
+      @p ||= Parser.new
+    end
+
+    def assert_educates(output)
+      str = StringIO.new
+      parser.educate str
+      assert_match output, str.string
+    end
+  end
+end

data/test/trollop/parser_opt_test.rb

@@ -0,0 +1,14 @@
+require 'stringio'
+require 'test_helper'
+
+module Trollop
+
+  class ParserOptTest < ::MiniTest::Test
+
+    private
+
+    def parser
+      @p ||= Parser.new
+    end
+  end
+end

data/test/trollop/parser_parse_test.rb

@@ -0,0 +1,79 @@
+require 'stringio'
+require 'test_helper'
+
+module Trollop
+  class ParserParseTest < ::MiniTest::Test
+
+  # TODO: parse
+    # resolve_default_short_options!
+    # parse_date_parameter
+    # parse_integer_parameter(param, arg)
+    # parse_float_parameter(param, arg)
+    # parse_io_parameter(param, arg)
+    # each_arg
+      # collect_argument_parameters
+
+  def test_help_needed
+    parser.opt "arg"
+    assert_raises(HelpNeeded) { parser.parse %w(-h) }
+    assert_raises(HelpNeeded) { parser.parse %w(--help) }
+  end
+
+  def test_help_overridden
+    parser.opt :arg1, "desc", :long => "help"
+    assert parser.parse(%w(-h))[:arg1]
+    assert parser.parse(%w(--help))[:arg1]
+  end
+
+  def test_help_with_other_args
+    parser.opt :arg1
+    assert_raises(HelpNeeded) { @p.parse %w(--arg1 --help) }
+  end
+
+  def test_help_with_arg_error
+    parser.opt :arg1, :type => String
+    assert_raises(HelpNeeded) { @p.parse %w(--arg1 --help) }
+  end
+
+  def test_version_needed_unset
+    parser.opt "arg"
+    assert_raises(CommandlineError) { parser.parse %w(-v) }
+  end
+
+  def test_version_needed
+    parser.version "trollop 5.2.3"
+    assert_raises(VersionNeeded) { parser.parse %w(-v) }
+    assert_raises(VersionNeeded) { parser.parse %w(--version) }
+  end
+
+  def test_version_overridden
+    parser.opt "version"
+    assert parser.parse(%w(-v))["version"]
+    assert parser.parse(%w(-v))[:version_given]
+  end
+
+  def test_version_only_appears_if_set
+    parser.opt "arg"
+    assert_raises(CommandlineError) { parser.parse %w(-v) }
+  end
+
+  def test_version_with_other_args
+    parser.opt :arg1
+    parser.version "1.1"
+    assert_raises(VersionNeeded) { parser.parse %w(--arg1 --version) }
+  end
+
+  def test_version_with_arg_error
+    parser.opt :arg1, :type => String
+    parser.version "1.1"
+    assert_raises(VersionNeeded) { parser.parse %w(--arg1 --version) }
+  end
+
+
+  private
+
+    def parser
+      @p ||= Parser.new
+    end
+  end
+end

data/test/{test_trollop.rb → trollop/parser_test.rb}

@@ -2,18 +2,48 @@ require 'stringio'
 require 'test_helper'
 
 module Trollop
-module Test
 
-class Trollop < ::MiniTest::Unit::TestCase
+class ParserTest < ::MiniTest::Test
   def setup
     @p = Parser.new
   end
 
-  def test_die_without_options_ever_run
-    ::Trollop.send(:instance_variable_set, "@last_parser", nil)
-    assert_raises(ArgumentError) { ::Trollop.die 'hello' }
+  def parser
+    @p ||= Parser.new
   end
 
+  # initialize
+  # cloaker
+
+  def test_version
+    assert_nil parser.version
+    assert_equal "trollop 5.2.3", parser.version("trollop 5.2.3")
+    assert_equal "trollop 5.2.3", parser.version
+  end
+
+  def test_usage
+    assert_nil parser.usage
+
+    assert_equal "usage string", parser.usage("usage string")
+    assert_equal "usage string", parser.usage
+  end
+
+  def test_synopsis
+    assert_nil parser.synopsis
+
+    assert_equal "synopsis string", parser.synopsis("synopsis string")
+    assert_equal "synopsis string", parser.synopsis
+  end
+
+  # def test_depends
+  # def test_conflicts
+  # def test_stop_on
+  # def test_stop_on_unknown
+
+  # die
+  # def test_die_educate_on_error
+
+
   def test_unknown_arguments
     assert_raises(CommandlineError) { @p.parse(%w(--arg)) }
     @p.opt "arg"
@@ -88,7 +118,7 @@ class Trollop < ::MiniTest::Unit::TestCase
     opts = @p.parse(%w(--argsi=4))
     assert_equal 4, opts["argsi"]
     opts = @p.parse(%w(--argsi=-4))
-    assert_equal -4, opts["argsi"]
+    assert_equal( -4, opts["argsi"])
 
     assert_raises(CommandlineError) { @p.parse(%w(--argsi 4.2)) }
     assert_raises(CommandlineError) { @p.parse(%w(--argsi hello)) }
@@ -338,7 +368,6 @@ class Trollop < ::MiniTest::Unit::TestCase
 
     ## specifying turns them all on, regardless of default
     opts = @p.parse %w(--no-default-false --no-default-true --no-default-none)
-    p opts
     assert_equal true, opts[:no_default_none]
     assert_equal true, opts[:no_default_false]
     assert_equal true, opts[:no_default_true]
@@ -353,12 +382,6 @@ class Trollop < ::MiniTest::Unit::TestCase
     assert_raises(CommandlineError) { @p.parse %w(--no-no-default-true) }
   end
 
-  def test_special_flags_work
-    @p.version "asdf fdas"
-    assert_raises(VersionNeeded) { @p.parse(%w(-v)) }
-    assert_raises(HelpNeeded) { @p.parse(%w(-h)) }
-  end
-
   def test_short_options_combine
     @p.opt :arg1, "desc", :short => "a"
     @p.opt :arg2, "desc", :short => "b"
@@ -383,13 +406,6 @@ class Trollop < ::MiniTest::Unit::TestCase
     assert_raises(CommandlineError) { @p.parse %w(-cba 4) }
   end
 
-  def test_version_only_appears_if_set
-    @p.opt "arg"
-    assert_raises(CommandlineError) { @p.parse %w(-v) }
-    @p.version "trollop 1.2.3.4"
-    assert_raises(VersionNeeded) { @p.parse %w(-v) }
-  end
-
   def test_doubledash_ends_option_processing
     @p.opt :arg1, "desc", :short => "a", :default => 0
     @p.opt :arg2, "desc", :short => "b", :default => 0
@@ -442,6 +458,18 @@ Options:
     EOM
   end
 
+  def test_integer_formatting
+    @p.opt :arg, "desc", :type => :integer, :short => "i"
+    opts = @p.parse %w(-i 5)
+    assert_equal 5, opts[:arg]
+  end
+
+  def test_integer_formatting
+    @p.opt :arg, "desc", :type => :integer, :short => "i", :default => 3
+    opts = @p.parse %w(-i)
+    assert_equal 3, opts[:arg]
+  end
+
   def test_floating_point_formatting
     @p.opt :arg, "desc", :type => :float, :short => "f"
     opts = @p.parse %w(-f 1)
@@ -471,6 +499,12 @@ Options:
     assert_raises(CommandlineError) { @p.parse %w(-f -.) }
   end
 
+  def test_floating_point_formatting_default
+    @p.opt :arg, "desc", :type => :float, :short => "f", :default => 5.5
+    opts = @p.parse %w(-f)
+    assert_equal 5.5, opts[:arg]
+  end
+
   def test_date_formatting
     @p.opt :arg, "desc", :type => :date, :short => 'd'
     opts = @p.parse(['-d', 'Jan 4, 2007'])
@@ -483,7 +517,7 @@ Options:
     assert_raises(ArgumentError) { @p.opt :arg, "desc", :short => "-1" }
     @p.opt :a1b, "desc"
     @p.opt :a2b, "desc"
-    assert @p.specs[:a2b][:short].to_i == 0
+    assert @p.specs[:a2b].short.to_i == 0
   end
 
   def test_short_options_can_be_weird
@@ -660,7 +694,7 @@ Options:
 
   def test_auto_generated_long_names_convert_underscores_to_hyphens
     @p.opt :hello_there
-    assert_equal "hello-there", @p.specs[:hello_there][:long]
+    assert_equal "hello-there", @p.specs[:hello_there].long
   end
 
   def test_arguments_passed_through_block
@@ -672,139 +706,6 @@ Options:
     assert_equal @goat, boat
   end
 
-  def test_help_has_default_banner
-    @p = Parser.new
-    sio = StringIO.new "w"
-    @p.parse []
-    @p.educate sio
-    help = sio.string.split "\n"
-    assert help[0] =~ /options/i
-    assert_equal 2, help.length # options, then -h
-
-    @p = Parser.new
-    @p.version "my version"
-    sio = StringIO.new "w"
-    @p.parse []
-    @p.educate sio
-    help = sio.string.split "\n"
-    assert help[0] =~ /my version/i
-    assert_equal 4, help.length # version, options, -h, -v
-
-    @p = Parser.new
-    @p.banner "my own banner"
-    sio = StringIO.new "w"
-    @p.parse []
-    @p.educate sio
-    help = sio.string.split "\n"
-    assert help[0] =~ /my own banner/i
-    assert_equal 2, help.length # banner, -h
-  end
-
-  def test_help_has_optional_usage
-    @p = Parser.new
-    @p.usage "OPTIONS FILES"
-    sio = StringIO.new "w"
-    @p.parse []
-    @p.educate sio
-    help = sio.string.split "\n"
-    assert help[0] =~ /OPTIONS FILES/i
-    assert_equal 4, help.length # line break, options, then -h
-  end
-
-  def test_help_has_optional_synopsis
-    @p = Parser.new
-    @p.synopsis "About this program"
-    sio = StringIO.new "w"
-    @p.parse []
-    @p.educate sio
-    help = sio.string.split "\n"
-    assert help[0] =~ /About this program/i
-    assert_equal 4, help.length # line break, options, then -h
-  end
-
-  def test_help_has_specific_order_for_usage_and_synopsis
-    @p = Parser.new
-    @p.usage "OPTIONS FILES"
-    @p.synopsis "About this program"
-    sio = StringIO.new "w"
-    @p.parse []
-    @p.educate sio
-    help = sio.string.split "\n"
-    assert help[0] =~ /OPTIONS FILES/i
-    assert help[1] =~ /About this program/i
-    assert_equal 5, help.length # line break, options, then -h
-  end
-
-  def test_help_preserves_positions
-    @p.opt :zzz, "zzz"
-    @p.opt :aaa, "aaa"
-    sio = StringIO.new "w"
-    @p.educate sio
-
-    help = sio.string.split "\n"
-    assert help[1] =~ /zzz/
-    assert help[2] =~ /aaa/
-  end
-
-  def test_help_includes_option_types
-    @p.opt :arg1, 'arg', :type => :int
-    @p.opt :arg2, 'arg', :type => :ints
-    @p.opt :arg3, 'arg', :type => :string
-    @p.opt :arg4, 'arg', :type => :strings
-    @p.opt :arg5, 'arg', :type => :float
-    @p.opt :arg6, 'arg', :type => :floats
-    @p.opt :arg7, 'arg', :type => :io
-    @p.opt :arg8, 'arg', :type => :ios
-    @p.opt :arg9, 'arg', :type => :date
-    @p.opt :arg10, 'arg', :type => :dates
-    sio = StringIO.new "w"
-    @p.educate sio
-
-    help = sio.string.split "\n"
-    assert help[1] =~ /<i>/
-    assert help[2] =~ /<i\+>/
-    assert help[3] =~ /<s>/
-    assert help[4] =~ /<s\+>/
-    assert help[5] =~ /<f>/
-    assert help[6] =~ /<f\+>/
-    assert help[7] =~ /<filename\/uri>/
-    assert help[8] =~ /<filename\/uri\+>/
-    assert help[9] =~ /<date>/
-    assert help[10] =~ /<date\+>/
-  end
-
-  def test_help_has_grammatical_default_text
-    @p.opt :arg1, 'description with period.', :default => 'hello'
-    @p.opt :arg2, 'description without period', :default => 'world'
-    sio = StringIO.new 'w'
-    @p.educate sio
-
-    help = sio.string.split "\n"
-    assert help[1] =~ /Default/
-    assert help[2] =~ /default/
-  end
-
-  def test_version_and_help_short_args_can_be_overridden
-    @p.opt :verbose, "desc", :short => "-v"
-    @p.opt :hello, "desc", :short => "-h"
-    @p.version "version"
-
-    @p.parse(%w(-v))
-    assert_raises(VersionNeeded) { @p.parse(%w(--version)) }
-    @p.parse(%w(-h))
-    assert_raises(HelpNeeded) { @p.parse(%w(--help)) }
-  end
-
-  def test_version_and_help_long_args_can_be_overridden
-    @p.opt :asdf, "desc", :long => "help"
-    @p.opt :asdf2, "desc2", :long => "version"
-    @p.parse %w()
-    @p.parse %w(--help)
-    @p.parse %w(--version)
-    @p.parse %w(-h)
-    @p.parse %w(-v)
-  end
-
   def test_version_and_help_override_errors
     @p.opt :asdf, "desc", :type => String
     @p.version "version"
@@ -975,13 +876,6 @@ Options:
     assert_equal @q.leftovers, []
   end
 
-  def assert_parses_correctly(parser, commandline, expected_opts,
-                              expected_leftovers)
-    opts = parser.parse commandline
-    assert_equal expected_opts, opts
-    assert_equal expected_leftovers, parser.leftovers
-  end
-
   def test_unknown_subcommand
     @p.opt :global_flag, "Global flag", :short => "-g", :type => :flag
     @p.opt :global_param, "Global parameter", :short => "-p", :default => 5
@@ -1035,6 +929,9 @@ Options:
     opts = @p.parse %w(--arg2 5/1/2010)
     assert_kind_of Date, opts[:arg2]
     assert_equal Date.new(2010, 5, 1), opts[:arg2]
+
+    opts = @p.parse %w(--arg3)
+    assert_equal temp, opts[:arg3]
   end
 
   def test_unknown_arg_class_type
@@ -1180,64 +1077,75 @@ Options:
   end
 
   def test_simple_interface_handles_help
-    ARGV.clear
-    ARGV.unshift "-h"
-    assert_raises(SystemExit) do
-      ::Trollop::options do
-        opt :potato
+    assert_stdout(/Options:/) do
+      assert_raises(SystemExit) do
+        ::Trollop::options(%w(-h)) do
+          opt :potato
+        end
+      end
+    end
+
+    # ensure regular status is returned
+
+    assert_stdout do
+      begin
+        ::Trollop::options(%w(-h)) do
+          opt :potato
+        end
+      rescue SystemExit => e
+        assert_equal 0, e.status
       end
     end
   end
 
   def test_simple_interface_handles_version
-    ARGV.clear
-    ARGV.unshift "-v"
-    assert_raises(SystemExit) do
-      ::Trollop::options do
-        version "1.2"
-        opt :potato
+    assert_stdout(/1.2/) do
+      assert_raises(SystemExit) do
+        ::Trollop::options(%w(-v)) do
+          version "1.2"
+          opt :potato
+        end
       end
     end
   end
 
   def test_simple_interface_handles_regular_usage
-    ARGV.clear
-    ARGV.unshift "--potato"
-    opts = ::Trollop::options do
+    opts = ::Trollop::options(%w(--potato)) do
       opt :potato
     end
     assert opts[:potato]
   end
 
   def test_simple_interface_handles_die
-    old_stderr, $stderr = $stderr, StringIO.new('w')
-    ARGV.clear
-    ARGV.unshift "--potato"
-    ::Trollop::options do
-      opt :potato
+    assert_stderr do
+      ::Trollop::options(%w(--potato)) do
+        opt :potato
+      end
+      assert_raises(SystemExit) { ::Trollop::die :potato, "is invalid" }
     end
-    assert_raises(SystemExit) { ::Trollop::die :potato, "is invalid" }
-  ensure
-    $stderr = old_stderr
   end
 
   def test_simple_interface_handles_die_without_message
-    old_stderr, $stderr = $stderr, StringIO.new('w')
-    ARGV.clear
-    ARGV.unshift "--potato"
-    opts = ::Trollop::options do
-      opt :potato
+    assert_stderr(/Error:/) do
+      ::Trollop::options(%w(--potato)) do
+        opt :potato
+      end
+      assert_raises(SystemExit) { ::Trollop::die :potato }
     end
-    assert_raises(SystemExit) { ::Trollop::die :potato }
-    assert $stderr.string =~ /Error:/
-  ensure
-    $stderr = old_stderr
   end
 
-  def test_with_standard_exception_handling
-    assert_raises(SystemExit) do
-      ::Trollop.with_standard_exception_handling(@p) do
-        raise ::Trollop::CommandlineError.new('cl error')
+  def test_invalid_option_with_simple_interface
+    assert_stderr do
+      assert_raises(SystemExit) do
+        ::Trollop.options(%w(--potato))
+      end
+    end
+
+    assert_stderr do
+      begin
+        ::Trollop.options(%w(--potato))
+      rescue SystemExit => e
+        assert_equal(-1, e.status)
       end
     end
   end
@@ -1257,7 +1165,56 @@ Options:
       @p.parse(%w(--cb1))
     end
   end
-end
 
+  def test_ignore_invalid_options
+    @p.opt :arg1, "desc", :type => String
+    @p.opt :b, "desc", :type => String
+    @p.opt :c, "desc", :type => :flag
+    @p.opt :d, "desc", :type => :flag
+    @p.ignore_invalid_options = true
+    opts = @p.parse %w{unknown -S param --arg1 potato -fb daisy --foo -ecg --bar baz -z}
+    assert_equal "potato", opts[:arg1]
+    assert_equal "daisy", opts[:b]
+    assert opts[:c]
+    refute opts[:d]
+    assert_equal %w{unknown -S param -f --foo -eg --bar baz -z}, @p.leftovers
+  end
+
+  def test_ignore_invalid_options_stop_on_unknown_long
+    @p.opt :arg1, "desc", :type => String
+    @p.ignore_invalid_options = true
+    @p.stop_on_unknown
+    opts = @p.parse %w{--unk --arg1 potato}
+    refute opts[:arg1]
+    assert_equal %w{--unk --arg1 potato}, @p.leftovers
+  end
+
+  def test_ignore_invalid_options_stop_on_unknown_short
+    @p.opt :arg1, "desc", :type => String
+    @p.ignore_invalid_options = true
+    @p.stop_on_unknown
+    opts = @p.parse %w{-ua potato}
+    refute opts[:arg1]
+    assert_equal %w{-ua potato}, @p.leftovers
+  end
+
+  def test_ignore_invalid_options_stop_on_unknown_partial_end_short
+    @p.opt :arg1, "desc", :type => :flag
+    @p.ignore_invalid_options = true
+    @p.stop_on_unknown
+    opts = @p.parse %w{-au potato}
+    assert opts[:arg1]
+    assert_equal %w{-u potato}, @p.leftovers
+  end
+
+  def test_ignore_invalid_options_stop_on_unknown_partial_mid_short
+    @p.opt :arg1, "desc", :type => :flag
+    @p.ignore_invalid_options = true
+    @p.stop_on_unknown
+    opts = @p.parse %w{-abu potato}
+    assert opts[:arg1]
+    assert_equal %w{-bu potato}, @p.leftovers
+  end
 end
+
 end