cli-option_parser.rb 0.5.2

data/test/optparse/test_load.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: false
+require 'test/unit'
+require 'optparse'
+require 'tmpdir'
+
+class ::OptionParserLoad < Test::Unit::TestCase
+  def setup
+    @tmpdir = Dir.mktmpdir("optparse_test-")
+    @basename = File.basename($0, '.*')
+    @envs = %w[HOME XDG_CONFIG_HOME XDG_CONFIG_DIRS].each_with_object({}) do |v, h|
+      h[v] = ENV.delete(v)
+    end
+  end
+
+  def teardown
+    ENV.update(@envs)
+    FileUtils.rm_rf(@tmpdir)
+  end
+
+  def new_parser
+    @result = nil
+    CLI::OptionParser.new do |opt|
+      opt.on("--test=arg") {|v| @result = v}
+    end
+  end
+
+  def assert_load(result)
+    assert new_parser.load
+    assert_equal(result, @result)
+    assert new_parser.load(into: into = {})
+    assert_equal({test: result}, into)
+  end
+
+  def setup_options(env, dir, suffix = nil)
+    optdir = File.join(@tmpdir, dir)
+    FileUtils.mkdir_p(optdir)
+    file = File.join(optdir, [@basename, suffix].join(""))
+    File.write(file, "--test=#{dir}")
+    ENV.update(env)
+    if block_given?
+      begin
+        yield dir, optdir
+      ensure
+        File.unlink(file)
+        Dir.rmdir(optdir) rescue nil
+      end
+    else
+      return dir, optdir
+    end
+  end
+
+  def setup_options_home(&block)
+    setup_options({'HOME'=>@tmpdir}, ".options", &block)
+  end
+
+  def setup_options_xdg_config_home(&block)
+    setup_options({'XDG_CONFIG_HOME'=>@tmpdir+"/xdg"}, "xdg", ".options", &block)
+  end
+
+  def setup_options_home_config(&block)
+    setup_options({'HOME'=>@tmpdir}, ".config", ".options", &block)
+  end
+
+  def setup_options_xdg_config_dirs(&block)
+    setup_options({'XDG_CONFIG_DIRS'=>@tmpdir+"/xdgconf"}, "xdgconf", ".options", &block)
+  end
+
+  def setup_options_home_config_settings(&block)
+    setup_options({'HOME'=>@tmpdir}, "config/settings", ".options", &block)
+  end
+
+  def test_load_home_options
+    result, = setup_options_home
+    assert_load(result)
+
+    setup_options_xdg_config_home do
+      assert_load(result)
+    end
+
+    setup_options_home_config do
+      assert_load(result)
+    end
+
+    setup_options_xdg_config_dirs do
+      assert_load(result)
+    end
+
+    setup_options_home_config_settings do
+      assert_load(result)
+    end
+  end
+
+  def test_load_xdg_config_home
+    result, = setup_options_xdg_config_home
+    assert_load(result)
+
+    setup_options_home_config do
+      assert_load(result)
+    end
+
+    setup_options_xdg_config_dirs do
+      assert_load(result)
+    end
+
+    setup_options_home_config_settings do
+      assert_load(result)
+    end
+  end
+
+  def test_load_home_config
+    result, = setup_options_home_config
+    assert_load(result)
+
+    setup_options_xdg_config_dirs do
+      assert_load(result)
+    end
+
+    setup_options_home_config_settings do
+      assert_load(result)
+    end
+  end
+
+  def test_load_xdg_config_dirs
+    result, = setup_options_xdg_config_dirs
+    assert_load(result)
+
+    setup_options_home_config_settings do
+      assert_load(result)
+    end
+  end
+
+  def test_load_home_config_settings
+    result, = setup_options_home_config_settings
+    assert_load(result)
+  end
+
+  def test_load_nothing
+    assert !new_parser.load
+    assert_nil @result
+  end
+end

data/test/optparse/test_noarg.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: false
+require_relative 'test_optparse'
+
+module ::OptionParserNoArg
+  def setup
+    super
+    @opt.def_option "--with_underscore" do |x| @flag = x end
+    @opt.def_option "--with-hyphen" do |x| @flag = x end
+  end
+
+  class Def1 < ::OptionParser
+    include ::OptionParserNoArg
+    def setup
+      super
+      @opt.def_option("-x") {|x| @flag = x}
+      @opt.def_option("--option") {|x| @flag = x}
+    end
+  end
+  class Def2 < ::OptionParser
+    include ::OptionParserNoArg
+    def setup
+      super
+      @opt.def_option("-x", "--option") {|x| @flag = x}
+    end
+  end
+
+  def test_short
+    assert_raise(CLI::OptionParser::InvalidOption) {@opt.parse!(%w"-xq")}
+    assert_equal(%w"", no_error {@opt.parse!(%w"-x")})
+    assert_equal(true, @flag)
+    @flag = nil
+    assert_equal(%w"foo", no_error {@opt.parse!(%w"-x foo")})
+    assert_equal(true, @flag)
+  end
+
+  def test_abbrev
+    assert_raise(CLI::OptionParser::InvalidOption) {@opt.parse!(%w"-oq")}
+    assert_equal(%w"", no_error {@opt.parse!(%w"-o")})
+    assert_equal(true, @flag)
+    @flag = nil
+    assert_raise(CLI::OptionParser::InvalidOption) {@opt.parse!(%w"-O")}
+    assert_nil(@flag)
+    @flag = nil
+    assert_equal(%w"foo", no_error {@opt.parse!(%w"-o foo")})
+    assert_equal(true, @flag)
+  end
+
+  def test_long
+    assert_raise(CLI::OptionParser::NeedlessArgument) {@opt.parse!(%w"--option=x")}
+    assert_equal(%w"", no_error {@opt.parse!(%w"--opt")})
+    assert_equal(true, @flag)
+    @flag = nil
+    assert_equal(%w"foo", no_error {@opt.parse!(%w"--opt foo")})
+    assert_equal(true, @flag)
+  end
+
+  def test_ambiguous
+    @opt.def_option("--open") {|x|}
+    assert_raise(CLI::OptionParser::AmbiguousOption) {@opt.parse!(%w"--op")}
+    assert_raise(CLI::OptionParser::AmbiguousOption) {@opt.parse!(%w"-o")}
+    assert_equal(%w"", no_error {@opt.parse!(%w"--opt")})
+    assert_equal(true, @flag)
+  end
+
+  def test_hyphenize
+    @flag = nil
+    assert_equal(%w"", no_error {@opt.parse!(%w"--with_underscore")})
+    assert_equal(true, @flag)
+    @flag = nil
+    assert_equal(%w"", no_error {@opt.parse!(%w"--with-underscore")})
+    assert_equal(true, @flag)
+    @flag = nil
+    assert_equal(%w"", no_error {@opt.parse!(%w"--with-hyphen")})
+    assert_equal(true, @flag)
+    @flag = nil
+    assert_equal(%w"", no_error {@opt.parse!(%w"--with_hyphen")})
+    assert_equal(true, @flag)
+  end
+end

data/test/optparse/test_optarg.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: false
+require_relative 'test_optparse'
+
+class ::OptionParserOptArg < ::OptionParser
+  def setup
+    super
+    @opt.def_option("-x[VAL]") {|x| @flag = x}
+    @opt.def_option("--option[=VAL]") {|x| @flag = x}
+    @opt.def_option("--regexp[=REGEXP]", Regexp) {|x| @reopt = x}
+    @opt.def_option "--with_underscore[=VAL]" do |x| @flag = x end
+    @opt.def_option "--with-hyphen[=VAL]" do |x| @flag = x end
+    @reopt = nil
+  end
+
+  def test_short
+    assert_equal(%w"", no_error {@opt.parse!(%w"-x")})
+    assert_equal(nil, @flag)
+    @flag = false
+    assert_equal(%w"foo", no_error {@opt.parse!(%w"-x foo")})
+    assert_equal(nil, @flag)
+    assert_equal(%w"", no_error {@opt.parse!(%w"-xfoo")})
+    assert_equal("foo", @flag)
+    assert_equal(%w"", no_error {@opt.parse!(%w"-x=")})
+    assert_equal("=", @flag)
+  end
+
+  def test_abbrev
+    assert_equal(%w"", no_error {@opt.parse!(%w"-o")})
+    assert_equal(nil, @flag)
+    @flag = false
+    assert_equal(%w"foo", no_error {@opt.parse!(%w"-o foo")})
+    assert_equal(nil, @flag)
+    assert_equal(%w"", no_error {@opt.parse!(%w"-ofoo")})
+    assert_equal("foo", @flag)
+    assert_equal(%w"", no_error {@opt.parse!(%w"-o=")})
+    assert_equal("=", @flag)
+  end
+
+  def test_long
+    assert_equal(%w"", no_error {@opt.parse!(%w"--opt")})
+    assert_equal(nil, @flag)
+    assert_equal(%w"foo", no_error {@opt.parse!(%w"--opt= foo")})
+    assert_equal("", @flag)
+    assert_equal(%w"", no_error {@opt.parse!(%w"--opt=foo")})
+    assert_equal("foo", @flag)
+    assert_equal(%w"foo", no_error {@opt.parse!(%w"--opt foo")})
+    assert_equal(nil, @flag)
+  end
+
+  def test_hyphenize
+    assert_equal(%w"", no_error {@opt.parse!(%w"--with_underscore=foo1")})
+    assert_equal("foo1", @flag)
+    assert_equal(%w"", no_error {@opt.parse!(%w"--with-underscore=foo2")})
+    assert_equal("foo2", @flag)
+    assert_equal(%w"", no_error {@opt.parse!(%w"--with-hyphen=foo3")})
+    assert_equal("foo3", @flag)
+    assert_equal(%w"", no_error {@opt.parse!(%w"--with_hyphen=foo4")})
+    assert_equal("foo4", @flag)
+  end
+end

data/test/optparse/test_optparse.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: false
+require 'test/unit'
+require 'cli-option_parser'
+
+class ::OptionParserTest < Test::Unit::TestCase
+  def setup
+    @opt = CLI::OptionParser.new
+    @flag = self.class		# cannot set by option
+  end
+
+  class DummyOutput < String
+    alias write concat
+  end
+  def assert_no_error(*args)
+    $stderr, stderr = DummyOutput.new, $stderr
+    assert_nothing_raised(*args) {return yield}
+  ensure
+    stderr, $stderr = $stderr, stderr
+    $!.backtrace.delete_if {|e| /\A#{Regexp.quote(__FILE__)}:#{__LINE__-2}/o =~ e} if $!
+    assert_empty(stderr)
+  end
+  alias no_error assert_no_error
+
+  def test_permute
+    assert_equal(%w"", no_error {@opt.permute!(%w"")})
+    assert_equal(self.class, @flag)
+    assert_equal(%w"foo bar", no_error {@opt.permute!(%w"foo bar")})
+    assert_equal(self.class, @flag)
+    assert_equal(%w"- foo bar", no_error {@opt.permute!(%w"- foo bar")})
+    assert_equal(self.class, @flag)
+    assert_equal(%w"foo bar", no_error {@opt.permute!(%w"-- foo bar")})
+    assert_equal(self.class, @flag)
+    assert_equal(%w"foo - bar", no_error {@opt.permute!(%w"foo - bar")})
+    assert_equal(self.class, @flag)
+    assert_equal(%w"foo bar", no_error {@opt.permute!(%w"foo -- bar")})
+    assert_equal(self.class, @flag)
+    assert_equal(%w"foo --help bar", no_error {@opt.permute!(%w"foo -- --help bar")})
+    assert_equal(self.class, @flag)
+  end
+
+  def test_order
+    assert_equal(%w"", no_error {@opt.order!(%w"")})
+    assert_equal(self.class, @flag)
+    assert_equal(%w"foo bar", no_error {@opt.order!(%w"foo bar")})
+    assert_equal(self.class, @flag)
+    assert_equal(%w"- foo bar", no_error {@opt.order!(%w"- foo bar")})
+    assert_equal(self.class, @flag)
+    assert_equal(%w"foo bar", no_error {@opt.permute!(%w"-- foo bar")})
+    assert_equal(self.class, @flag)
+    assert_equal(%w"foo - bar", no_error {@opt.order!(%w"foo - bar")})
+    assert_equal(self.class, @flag)
+    assert_equal(%w"foo -- bar", no_error {@opt.order!(%w"foo -- bar")})
+    assert_equal(self.class, @flag)
+    assert_equal(%w"foo -- --help bar", no_error {@opt.order!(%w"foo -- --help bar")})
+    assert_equal(self.class, @flag)
+  end
+
+  def test_regexp
+    return unless defined?(@reopt)
+    assert_equal(%w"", no_error {@opt.parse!(%w"--regexp=/foo/")})
+    assert_equal(/foo/, @reopt)
+    assert_equal(%w"", no_error {@opt.parse!(%w"--regexp=/foo/i")})
+    assert_equal(/foo/i, @reopt)
+    assert_equal(%w"", no_error {@opt.parse!(%w"--regexp=/foo/n")})
+    assert_equal(/foo/n, @reopt)
+    assert_equal(%w"", no_error {@opt.parse!(%W"--regexp=/\u{3042}/s")})
+    assert_equal(Encoding::Windows_31J, @reopt.encoding)
+    assert_equal("\x82\xa0".force_encoding(Encoding::Windows_31J), @reopt.source)
+  end
+
+  def test_into
+    @opt.def_option "-h", "--host=HOST", "hostname"
+    @opt.def_option "-p", "--port=PORT", "port", Integer
+    @opt.def_option "-v", "--verbose" do @verbose = true end
+    @opt.def_option "-q", "--quiet" do @quiet = true end
+    result = {}
+    @opt.parse %w(--host localhost --port 8000 -v), into: result
+    assert_equal({
+      h: "localhost", host: "localhost",
+      p: 8000, port: 8000,
+      v: true, verbose: true
+    }, result)
+    assert_equal(true, @verbose)
+  end
+
+  def test_require_exact
+    @opt.def_option('-F', '--zrs=IRS', 'zrs')
+    %w(--zrs --zr --z -zfoo -z -F -Ffoo).each do |arg|
+      result = {}
+      @opt.parse([arg, 'foo'], into: result)
+      assert_equal({F: 'foo', zrs: 'foo'}, result)
+    end
+
+    @opt.require_exact = true
+    %w(--zrs -F -Ffoo).each do |arg|
+      result = {}
+      @opt.parse([arg, 'foo'], into: result)
+      assert_equal({F: 'foo', zrs: 'foo'}, result)
+    end
+
+    assert_raise(CLI::OptionParser::InvalidOption) {@opt.parse(%w(--zr foo))}
+    assert_raise(CLI::OptionParser::InvalidOption) {@opt.parse(%w(--z foo))}
+    assert_raise(CLI::OptionParser::InvalidOption) {@opt.parse(%w(-zrs foo))}
+    assert_raise(CLI::OptionParser::InvalidOption) {@opt.parse(%w(-zr foo))}
+    assert_raise(CLI::OptionParser::InvalidOption) {@opt.parse(%w(-z foo))}
+  end
+
+  def test_raise_unknown
+    @opt.def_option('--my-foo [ARG]') {|arg| @foo = arg}
+    assert @opt.raise_unknown
+
+    @opt.raise_unknown = false
+    assert_equal(%w[--my-bar], @opt.parse(%w[--my-foo --my-bar]))
+    assert_nil(@foo)
+
+    assert_equal(%w[--my-bar], @opt.parse(%w[--my-foo x --my-bar]))
+    assert_equal("x", @foo)
+  end
+
+  def test_nonopt_pattern
+    @opt.def_option(/^[^-]/) do |arg|
+      assert(false, "Never gets called")
+    end
+    e = assert_raise(CLI::OptionParser::InvalidOption) {@opt.parse(%w(-t))}
+    assert_equal(["-t"], e.args)
+  end
+end

data/test/optparse/test_placearg.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: false
+require_relative 'test_optparse'
+
+class ::OptionParserPlaceArg < ::OptionParser
+  def setup
+    super
+    @opt.def_option("-x [VAL]") {|x| @flag = x}
+    @opt.def_option("--option [VAL]") {|x| @flag = x}
+    @opt.def_option("-T [level]", /^[0-4]$/, Integer) {|x| @topt = x}
+    @topt = nil
+    @opt.def_option("-n") {}
+    @opt.def_option("--regexp [REGEXP]", Regexp) {|x| @reopt = x}
+    @reopt = nil
+    @opt.def_option "--with_underscore=VAL" do |x| @flag = x end
+    @opt.def_option "--with-hyphen=VAL" do |x| @flag = x end
+  end
+
+  def test_short
+    assert_equal(%w"", no_error {@opt.parse!(%w"-x -n")})
+    assert_equal(nil, @flag)
+    assert_equal(%w"", no_error {@opt.parse!(%w"-x -")})
+    assert_equal("-", @flag)
+    @flag = false
+    assert_equal(%w"", no_error {@opt.parse!(%w"-x foo")})
+    assert_equal("foo", @flag)
+    assert_equal(%w"", no_error {@opt.parse!(%w"-xbar")})
+    assert_equal("bar", @flag)
+    assert_equal(%w"", no_error {@opt.parse!(%w"-x=")})
+    assert_equal("=", @flag)
+  end
+
+  def test_abbrev
+    assert_equal(%w"", no_error {@opt.parse!(%w"-o -n")})
+    assert_equal(nil, @flag)
+    assert_equal(%w"", no_error {@opt.parse!(%w"-o -")})
+    assert_equal("-", @flag)
+    @flag = false
+    assert_equal(%w"", no_error {@opt.parse!(%w"-o foo")})
+    assert_equal("foo", @flag)
+    assert_equal(%w"", no_error {@opt.parse!(%w"-obar")})
+    assert_equal("bar", @flag)
+    assert_equal(%w"", no_error {@opt.parse!(%w"-o=")})
+    assert_equal("=", @flag)
+  end
+
+  def test_long
+    assert_equal(%w"", no_error {@opt.parse!(%w"--opt -n")})
+    assert_equal(nil, @flag)
+    assert_equal(%w"", no_error {@opt.parse!(%w"--opt -")})
+    assert_equal("-", @flag)
+    assert_equal(%w"foo", no_error {@opt.parse!(%w"--opt= foo")})
+    assert_equal("", @flag)
+    assert_equal(%w"", no_error {@opt.parse!(%w"--opt=foo")})
+    assert_equal("foo", @flag)
+    assert_equal(%w"", no_error {@opt.parse!(%w"--opt bar")})
+    assert_equal("bar", @flag)
+  end
+
+  def test_hyphenize
+    assert_equal(%w"", no_error {@opt.parse!(%w"--with_underscore=foo1")})
+    assert_equal("foo1", @flag)
+    assert_equal(%w"", no_error {@opt.parse!(%w"--with-underscore=foo2")})
+    assert_equal("foo2", @flag)
+    assert_equal(%w"", no_error {@opt.parse!(%w"--with-hyphen=foo3")})
+    assert_equal("foo3", @flag)
+    assert_equal(%w"", no_error {@opt.parse!(%w"--with_hyphen=foo4")})
+    assert_equal("foo4", @flag)
+  end
+
+  def test_conv
+    assert_equal(%w"te.rb", no_error('[ruby-dev:38333]') {@opt.parse!(%w"-T te.rb")})
+    assert_nil(@topt)
+    assert_equal(%w"te.rb", no_error('[ruby-dev:38333]') {@opt.parse!(%w"-T1 te.rb")})
+    assert_equal(1, @topt)
+  end
+end

data/test/optparse/test_reqarg.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: false
+require_relative 'test_optparse'
+
+module ::OptionParserReqArg
+  def setup
+    super
+    @opt.def_option "--with_underscore=VAL" do |x| @flag = x end
+    @opt.def_option "--with-hyphen=VAL" do |x| @flag = x end
+  end
+
+  class Def1 < ::OptionParser
+    include ::OptionParserReqArg
+    def setup
+      super
+      @opt.def_option("-xVAL") {|x| @flag = x}
+      @opt.def_option("--option=VAL") {|x| @flag = x}
+      @opt.def_option("--regexp=REGEXP", Regexp) {|x| @reopt = x}
+      @reopt = nil
+    end
+  end
+  class Def2 < ::OptionParser
+    include ::OptionParserReqArg
+    def setup
+      super
+      @opt.def_option("-x", "--option=VAL") {|x| @flag = x}
+    end
+  end
+  class Def3 < ::OptionParser
+    include ::OptionParserReqArg
+    def setup
+      super
+      @opt.def_option("--option=VAL", "-x") {|x| @flag = x}
+    end
+  end
+  class Def4 < ::OptionParser
+    include ::OptionParserReqArg
+    def setup
+      super
+      @opt.def_option("-xVAL", "--option=VAL") {|x| @flag = x}
+    end
+  end
+
+  def test_short
+    assert_raise(CLI::OptionParser::MissingArgument) {@opt.parse!(%w"-x")}
+    assert_equal(%w"", no_error {@opt.parse!(%w"-x foo")})
+    assert_equal("foo", @flag)
+    assert_equal(%w"", no_error {@opt.parse!(%w"-xbar")})
+    assert_equal("bar", @flag)
+    assert_equal(%w"", no_error {@opt.parse!(%w"-x=")})
+    assert_equal("=", @flag)
+  end
+
+  def test_abbrev
+    assert_raise(CLI::OptionParser::MissingArgument) {@opt.parse!(%w"-o")}
+    assert_equal(%w"", no_error {@opt.parse!(%w"-o foo")})
+    assert_equal("foo", @flag)
+    assert_equal(%w"", no_error {@opt.parse!(%w"-obar")})
+    assert_equal("bar", @flag)
+    assert_equal(%w"", no_error {@opt.parse!(%w"-o=")})
+    assert_equal("=", @flag)
+  end
+
+  def test_long
+    assert_raise(CLI::OptionParser::MissingArgument) {@opt.parse!(%w"--opt")}
+    assert_equal(%w"", no_error {@opt.parse!(%w"--opt foo")})
+    assert_equal("foo", @flag)
+    assert_equal(%w"foo", no_error {@opt.parse!(%w"--opt= foo")})
+    assert_equal("", @flag)
+    assert_equal(%w"", no_error {@opt.parse!(%w"--opt=foo")})
+    assert_equal("foo", @flag)
+  end
+
+  def test_hyphenize
+    assert_equal(%w"", no_error {@opt.parse!(%w"--with_underscore foo1")})
+    assert_equal("foo1", @flag)
+    assert_equal(%w"", no_error {@opt.parse!(%w"--with-underscore foo2")})
+    assert_equal("foo2", @flag)
+    assert_equal(%w"", no_error {@opt.parse!(%w"--with-hyphen foo3")})
+    assert_equal("foo3", @flag)
+    assert_equal(%w"", no_error {@opt.parse!(%w"--with_hyphen foo4")})
+    assert_equal("foo4", @flag)
+  end
+
+  class ::OptionParser::WithPattern < ::OptionParser
+    def test_pattern
+      pat = num = nil
+      @opt.def_option("--pattern=VAL", /(\w+)(?:\s*:\s*(\w+))?/) {|x, y, z| pat = [x, y, z]}
+      @opt.def_option("-T NUM", /\A[1-4]\z/) {|n| num = n}
+      no_error {@opt.parse!(%w"--pattern=key:val")}
+      assert_equal(%w"key:val key val", pat, '[ruby-list:45645]')
+      no_error {@opt.parse!(%w"-T 4")}
+      assert_equal("4", num, '[ruby-dev:37514]')
+    end
+  end
+end

data/test/optparse/test_summary.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: false
+require_relative 'test_optparse'
+
+class ::OptionParserSummaryTest < ::OptionParser
+  def test_short_clash
+    r = nil
+    o = CLI::OptionParser.new do |opts|
+      opts.on("-f", "--first-option", "description 1", "description 2"){r = "first-option"}
+      opts.on("-t", "--test-option"){r = "test-option"}
+      opts.on("-t", "--another-test-option"){r = "another-test-option"}
+      opts.separator "this is\nseparator"
+      opts.on("-l", "--last-option"){r = "last-option"}
+    end
+    s = o.summarize
+    o.parse("-t")
+    assert_match(/--#{r}/, s.grep(/^\s*-t,/)[0])
+    assert_match(/first-option/, s[0])
+    assert_match(/description 1/, s[0])
+    assert_match(/description 2/, s[1])
+    assert_match(/last-option/, s[-1])
+  end
+
+  def test_banner
+    o = CLI::OptionParser.new("foo bar")
+    assert_equal("foo bar", o.banner)
+  end
+
+  def test_banner_from_progname
+    o = CLI::OptionParser.new
+    o.program_name = "foobar"
+    assert_equal("Usage: foobar [options]\n", o.help)
+  end
+
+  def test_summary
+    o = CLI::OptionParser.new("foo\nbar")
+    assert_equal("foo\nbar\n", o.to_s)
+    assert_equal(["foo\n", "bar"], o.to_a)
+  end
+
+  def test_summary_containing_space
+    # test for r35467. CLI::OptionParser#to_a shouldn't split str by spaces.
+    bug6348 = '[ruby-dev:45568]'
+    o = CLI::OptionParser.new("foo bar")
+    assert_equal("foo bar\n", o.to_s, bug6348)
+    assert_equal(["foo bar"], o.to_a, bug6348)
+  end
+
+  def test_ver
+    o = CLI::OptionParser.new("foo bar")
+    o.program_name = "foo"
+    assert_warning('') {assert_nil(o.version)}
+    assert_warning('') {assert_nil(o.release)}
+    o.version = [0, 1]
+    assert_equal "foo 0.1", o.ver
+    o.release = "rel"
+    assert_equal "foo 0.1 (rel)", o.ver
+  end
+
+  # https://github.com/ruby/optparse/issues/37
+  def test_very_long_without_short
+    o = CLI::OptionParser.new do |opts|
+      # This causes TypeError
+      opts.on('',   '--long-long-option-param-without-short', "Error desc") { options[:long_long_option_param_without_short] = true }
+      opts.on('',   '--long-option-param', "Long desc") { options[:long_option_param_without_short] = true }
+      opts.on('-a', '--long-long-option-param-with-short', "Normal description") { options[:long_long_option_param_with_short] = true }
+
+      opts.on('',   '--long-long-option-param-without-short-but-with-desc', 'Description of the long long param') { options[:long_long_option_param_without_short_but_with_desc] = true }
+    end
+
+    s = o.summarize
+
+    assert_match(/^\s*--long-long-option-param-without-short$/, s[0])
+    assert_match(/^\s*Error desc$/, s[1])
+    assert_match(/^\s*--long-option-param\s+Long desc$/, s[2])
+    assert_match(/^\s*-a\s+Normal description$/, s[3])
+    assert_match(/^\s*--long-long-option-param-with-short$/, s[4])
+
+    assert_match(/^\s*--long-long-option-param-without-short-but-with-desc$/, s[5])
+    assert_match(/^\s*Description of the long long param$/, s[6])
+  end
+end

data/test/optparse/test_zsh_completion.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: false
+require 'test/unit'
+require 'optparse'
+
+class ::OptionParserZshCompletion < Test::Unit::TestCase
+  def setup
+    @opt = CLI::OptionParser.new
+    @opt.define("-z", "zzz") {}
+    @opt.define("--foo") {}
+    @opt.define("--bar=BAR") {}
+    @opt.define("--for=TYPE", [:hello, :help, :zot]) {}
+  end
+
+  def test_compsys
+    compsys = @opt.compsys("", "zshcompsys")
+    assert_match(/\"-z\[zzz\]\"/, compsys)
+    assert_match(/\"--foo\[\]\"/, compsys)
+    assert_match(/\"--bar\[\]\"/, compsys)
+    assert_match(/\"--for\[\]\"/, compsys)
+  end
+end