RubyGems - benry-cmdopt - Versions diffs - 1.0.0 → 2.0.0 - Mend

benry-cmdopt 1.0.0 → 2.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (15) hide show

data/test/cmdopt_test.rb CHANGED Viewed

@@ -1,921 +1,1612 @@
 # -*- coding: utf-8 -*-
-require 'minitest/spec'
-require 'minitest/autorun'
-require 'minitest/ok'
+require 'oktest'
 require 'benry/cmdopt'
-def new_sample_schema()
-  sc = Benry::Cmdopt::Schema.new
-  sc.add(:help   , "-h, --help"            , "show help message.")
-  sc.add(:version, "--version"             , "print version")
-  sc.add(:file   , "-f, --file=<FILE>"     , "filename")
-  sc.add(:indent , "-i, --indent[=<WIDTH>]", "enable indent", type: Integer)
-  sc.add(:mode   , "-m, --mode=<MODE>"     , "mode", enum: ['verbose', 'quiet'])
-  sc.add(:libpath, "-I, --path=<PATH>"     , "library path (multiple ok)") do |optdef, key, val|
-    File.directory?(val)  or raise "directory not exist."
-    arr = optdef[key] || []
-    arr << val
-    arr
+Oktest.scope do
+  def new_sample_schema()
+    sc = Benry::CmdOpt::Schema.new
+    sc.add(:help   , "-h, --help"            , "show help message.")
+    sc.add(:version, "--version"             , "print version")
+    sc.add(:file   , "-f, --file=<FILE>"     , "filename")
+    sc.add(:indent , "-i, --indent[=<WIDTH>]", "enable indent", type: Integer)
+    sc.add(:mode   , "-m, --mode=<MODE>"     , "mode", enum: ['verbose', 'quiet'])
+    sc.add(:libpath, "-I, --path=<PATH>"     , "library path (multiple ok)") do |optdef, key, val|
+      File.directory?(val)  or raise "Directory not exist."
+      arr = optdef[key] || []
+      arr << val
+      arr
+    end
+    sc
   end
-  sc
-end
-class Benry::Cmdopt::Schema::Test < MiniTest::Test
+  topic Benry::CmdOpt::Schema do
-  describe "#parse()" do
+    topic '#parse()' do
-    before do
-      @schema = Benry::Cmdopt::Schema.new
-    end
+      before do
+        @schema = Benry::CmdOpt::Schema.new
+      end
-    it "[!qw0ac] parses command option definition string." do
-      sc = @schema
-      tuple = sc.__send__(:parse_optdef, "-h, --help")
-      ok {tuple} == ['h', 'help', nil, false]
-      tuple = sc.__send__(:parse_optdef, "-h")
-      ok {tuple} == ['h', nil, nil, false]
-      tuple = sc.__send__(:parse_optdef, "--help")
-      ok {tuple} == [nil, 'help', nil, false]
-    end
+      spec "[!qw0ac] parses command option definition string." do
+        sc = @schema
+        tuple = sc.__send__(:parse_optdef, "-h, --help")
+        ok {tuple} == ['h', 'help', nil, nil]
+        tuple = sc.__send__(:parse_optdef, "-h")
+        ok {tuple} == ['h', nil, nil, nil]
+        tuple = sc.__send__(:parse_optdef, "--help")
+        ok {tuple} == [nil, 'help', nil, nil]
+      end
-    it "[!ae733] parses command option definition which has a required param." do
-      sc = @schema
-      tuple = sc.__send__(:parse_optdef, "-f, --file=<FILE>")
-      ok {tuple} == ['f', 'file', '<FILE>', false]
-      tuple = sc.__send__(:parse_optdef, "-f <FILE>")
-      ok {tuple} == ['f', nil, '<FILE>', false]
-      tuple = sc.__send__(:parse_optdef, "--file=<FILE>")
-      ok {tuple} == [nil, 'file', '<FILE>', false]
-    end
+      spec "[!ae733] parses command option definition which has a required param." do
+        sc = @schema
+        tuple = sc.__send__(:parse_optdef, "-f, --file=<FILE>")
+        ok {tuple} == ['f', 'file', '<FILE>', true]
+        tuple = sc.__send__(:parse_optdef, "-f <FILE>")
+        ok {tuple} == ['f', nil, '<FILE>', true]
+        tuple = sc.__send__(:parse_optdef, "--file=<FILE>")
+        ok {tuple} == [nil, 'file', '<FILE>', true]
+      end
+      spec "[!4h05c] parses command option definition which has an optional param." do
+        sc = @schema
+        tuple = sc.__send__(:parse_optdef, "-i, --indent[=<WIDTH>]")
+        ok {tuple} == ['i', 'indent', '<WIDTH>', false]
+        tuple = sc.__send__(:parse_optdef, "-i[<WIDTH>]")
+        ok {tuple} == ['i', nil, '<WIDTH>', false]
+        tuple = sc.__send__(:parse_optdef, "--indent[=<WIDTH>]")
+        ok {tuple} == [nil, 'indent', '<WIDTH>', false]
+      end
+      spec "[!b7jo3] raises SchemaError when command option definition is invalid." do
+        sc = @schema
+        pr = proc {
+          tuple = sc.__send__(:parse_optdef, "-i, --indent <WIDTH>")
+        }
+        ok {pr}.raise?(Benry::CmdOpt::SchemaError,
+                       "-i, --indent <WIDTH>: Invalid option definition (use '=--indent' instead of ' --indent').")
+      end
-    it "[!4h05c] parses command option definition which has an optional param." do
-      sc = @schema
-      tuple = sc.__send__(:parse_optdef, "-i, --indent[=<WIDTH>]")
-      ok {tuple} == ['i', 'indent', '<WIDTH>', true]
-      tuple = sc.__send__(:parse_optdef, "-i[<WIDTH>]")
-      ok {tuple} == ['i', nil, '<WIDTH>', true]
-      tuple = sc.__send__(:parse_optdef, "--indent[=<WIDTH>]")
-      ok {tuple} == [nil, 'indent', '<WIDTH>', true]
     end
-    it "[!b7jo3] raises SchemaError when command option definition is invalid." do
-      sc = @schema
-      pr = proc {
-        tuple = sc.__send__(:parse_optdef, "-i, --indent <WIDTH>")
-      }
-      ok {pr}.raise?(Benry::Cmdopt::SchemaError,
-                     "-i, --indent <WIDTH>: invalid option definition (use '=--indent' instead of ' --indent').")
+    topic '#dup()' do
+      before do
+        @schema = Benry::CmdOpt::Schema.new
+        @schema.add(:help   , "-h" , "print help")
+      end
+      spec "[!lxb0o] copies self object." do
+        this  = @schema
+        other = @schema.dup()
+        #
+        this_items  = this.instance_variable_get(:@items)
+        other_items = other.instance_variable_get(:@items)
+        ok {this_items} != nil
+        ok {other_items} != nil
+        ok {other_items} == this_items
+        ok {other_items.object_id} != this_items.object_id
+        #
+        this.add(:silent, "-s", "silent")
+        other.add(:quiet, "-q", "quiet")
+        ok {this.option_help()}  == ("  -h       : print help\n" +
+                                     "  -s       : silent\n")
+        ok {other.option_help()} == ("  -h       : print help\n" +
+                                     "  -q       : quiet\n")
+      end
     end
-  end
+    topic '#copy_from()' do
+      before do
+        @schema1 = Benry::CmdOpt::Schema.new
+        @schema1.add(:help, "-h" , "print help")
+        @schema2 = Benry::CmdOpt::Schema.new
+        @schema2.add(:version, "-v" , "print version")
+        @schema2.add(:debug  , "-D" , "debug mode")
+      end
+      spec "[!6six3] copy schema items from others." do
+        @schema1.copy_from(@schema2)
+        tuples = @schema1.each.collect {|x| [x.key, x.optdef, x.desc] }
+        ok {tuples} == [
+          [:help   , "-h", "print help"],
+          [:version, "-v", "print version"],
+          [:debug  , "-D", "debug mode"],
+        ]
+      end
+      spec "[!vt88s] copy schema items except items specified by 'except:' kwarg." do
+        @schema1.copy_from(@schema2, except: [:debug])
+        tuples = @schema1.each.collect {|x| [x.key, x.optdef, x.desc] }
+        ok {tuples} == [
+          [:help,    "-h", "print help"],
+          [:version, "-v", "print version"],
+        ]
+      end
-  describe "#add()" do
-    before do
-      @schema = Benry::Cmdopt::Schema.new
-    end
-    it "[!7hi2d] takes command option definition string." do
-      sc = @schema
-      sc.add(:indent, "-i, --indent=<WIDTH>", "print help")
-      items = sc.instance_eval { @items }
-      ok {items.length} == 1
-      ok {items[0]}.is_a?(Benry::Cmdopt::SchemaItem)
-      ok {items[0].key} == :indent
-      ok {items[0].short} == 'i'
-      ok {items[0].long} == 'indent'
-      ok {items[0].param} == '<WIDTH>'
-      ok {items[0].optional} == false
-      ok {items[0].type} == nil
-      ok {items[0].pattern} == nil
-      ok {items[0].enum} == nil
-      ok {items[0].callback} == nil
-    end
-    it "[!p9924] option key is omittable only when long option specified." do
-      sc = @schema
-      sc.add(nil, "-m, --max-num=<N>", nil)
-      items = sc.instance_eval { @items }
-      ok {items[0].key} == :max_num
-    end
-    it "[!jtp7z] raises SchemaError when key is nil and no long option." do
-      sc = @schema
-      pr = proc { sc.add(nil, "-i <N>", nil) }
-      msg = "add(nil, \"-i <N>\"): long option required when option key (1st arg) not specified."
-      ok {pr}.raise?(Benry::Cmdopt::SchemaError, msg)
-    end
-    it "[!yht0v] keeps command option definitions." do
-      sc = @schema
-      sc.add(:indent, "-i, --indent[=<WIDTH>]", "indent width",
-                      type: Integer, pattern: /\A\d+\z/, enum: ['2', '4', '8']) {|v| v.to_i }
-      items = sc.instance_eval { @items }
-      ok {items.length} == 1
-      ok {items[0]}.is_a?(Benry::Cmdopt::SchemaItem)
-      ok {items[0].key} == :indent
-      ok {items[0].short} == 'i'
-      ok {items[0].long} == 'indent'
-      ok {items[0].param} == '<WIDTH>'
-      ok {items[0].optional} == true
-      ok {items[0].type} == Integer
-      ok {items[0].pattern} == /\A\d+\z/
-      ok {items[0].enum} == ['2', '4', '8']
-      ok {items[0].callback}.is_a?(Proc)
-      ok {items[0].callback.arity} == 1
-    end
-    it "[!rhhji] raises SchemaError when key is not a Symbol." do
-      sc = @schema
-      pr = proc {
-        sc.add("-i, --indent[=<WIDTH>]", "indent width", nil)
-      }
-      ok {pr}.raise?(Benry::Cmdopt::SchemaError,
-                     'add("-i, --indent[=<WIDTH>]"): 1st arg should be a Symbol as an option key.')
-    end
-    it "[!vq6eq] raises SchemaError when help message is missing." do
-      sc = @schema
-      pr = proc {
-        begin
-          sc.add(:indent, "-i, --indent[=<WIDTH>]", type: Array)   # Ruby 2
-        rescue ArgumentError
-          sc.add(:indent, "-i, --indent[=<WIDTH>]", {type: Array}) # Ruby 3
-        end
-      }
-      ok {pr}.raise?(Benry::Cmdopt::SchemaError,
-                     'add(:indent, "-i, --indent[=<WIDTH>]"): help message required as 3rd argument.')
-    end
-    it "[!7xmr5] raises SchemaError when type is not registered." do
-      sc = @schema
-      pr = proc {
-        sc.add(:indent, "-i, --indent[=<WIDTH>]", "indent width", type: Array)
-      }
-      ok {pr}.raise?(Benry::Cmdopt::SchemaError,
-                     "Array: unregistered type.")
-    end
-    it "[!s2aaj] raises SchemaError when option has no params but type specified." do
-      sc = @schema
-      pr = proc {
-        sc.add(:indent, "-i, --indent", "indent width", type: Integer)
-      }
-      ok {pr}.raise?(Benry::Cmdopt::SchemaError,
-                     "Integer: type specified in spite of option has no params.")
-    end
-    it "[!bi2fh] raises SchemaError when pattern is not a regexp." do
-      sc = @schema
-      pr = proc {
-        sc.add(:indent, "-x, --indent[=<WIDTH>]", "indent width", pattern: '\A\d+\z')
-      }
-      ok {pr}.raise?(Benry::Cmdopt::SchemaError,
-                     '"\\\\A\\\\d+\\\\z": regexp expected.')
-    end
-    it "[!01fmt] raises SchmeaError when option has no params but pattern specified." do
-      sc = @schema
-      pr = proc {
-        sc.add(:indent, "-i, --indent", "indent width", pattern: /\A\d+\z/)
-      }
-      ok {pr}.raise?(Benry::Cmdopt::SchemaError,
-                     '/\A\d+\z/: pattern specified in spite of option has no params.')
-    end
-    it "[!melyd] raises SchmeaError when enum is not a Array nor Set." do
-      sc = @schema
-      sc.add(:indent, "-i <N>", "indent width", enum: ["2", "4", "8"])
-      sc.add(:indent, "-i <N>", "indent width", enum: Set.new(["2", "4", "8"]))
-      pr = proc {
-        sc.add(:indent, "-i <N>", "indent width", enum: "2,4,8")
-      }
-      ok {pr}.raise?(Benry::Cmdopt::SchemaError,
-                     '"2,4,8": array or set expected.')
-    end
-    it "[!xqed8] raises SchemaError when enum specified for no param option." do
-      sc = @schema
-      pr = proc {
-        sc.add(:indent, "-i", "enable indent", enum: [2, 4, 8])
-      }
-      ok {pr}.raise?(Benry::Cmdopt::SchemaError,
-                     "[2, 4, 8]: enum specified in spite of option has no params.")
     end
-  end
+    topic '#add()' do
+      before do
+        @schema = Benry::CmdOpt::Schema.new
+      end
+      spec "[!7hi2d] takes command option definition string." do
+        sc = @schema
+        sc.add(:indent, "-i, --indent=<WIDTH>", "print help")
+        items = sc.instance_eval { @items }
+        ok {items.length} == 1
+        ok {items[0]}.is_a?(Benry::CmdOpt::SchemaItem)
+        ok {items[0].key} == :indent
+        ok {items[0].short} == 'i'
+        ok {items[0].long} == 'indent'
+        ok {items[0].param} == '<WIDTH>'
+        ok {items[0].required?} == true
+        ok {items[0].type} == nil
+        ok {items[0].rexp} == nil
+        ok {items[0].enum} == nil
+        ok {items[0].callback} == nil
+      end
+      spec "[!p9924] option key is omittable only when long option specified." do
+        sc = @schema
+        sc.add(nil, "-m, --max-num=<N>", nil)
+        items = sc.instance_eval { @items }
+        ok {items[0].key} == :max_num
+      end
+      spec "[!jtp7z] raises SchemaError when key is nil and no long option." do
+        sc = @schema
+        pr = proc { sc.add(nil, "-i <N>", nil) }
+        msg = "add(nil, \"-i <N>\"): Long option required when option key (1st arg) not specified."
+        ok {pr}.raise?(Benry::CmdOpt::SchemaError, msg)
+      end
+      spec "[!rpl98] when long option is 'foo-bar' then key name is ':foo_bar'." do
+        sc = @schema
+        sc.add(nil, "--foo-bar", nil)
+        items = sc.instance_eval { @items }
+        ok {items[0].key} == :foo_bar
+      end
+      spec "[!97sn0] raises SchemaError when ',' is missing between short and long options." do
+        sc = @schema
+        pr = proc { sc.add(:exec, '-x --exec=ARG', "exec") }
+        msg = "add(:exec, \"-x --exec=ARG\"): Missing ',' between short option and long options."
+        ok {pr}.raise?(Benry::CmdOpt::SchemaError, msg)
+      end
+      spec "[!yht0v] keeps command option definitions." do
+        sc = @schema
+        sc.add(:indent, "-i, --indent[=<WIDTH>]", "indent width",
+                        range: (1..2), value: 8, detail: "(description)", tag: :ab,
+                        type: Integer, rexp: /\A\d+\z/, enum: [2, 4, 8]) {|v| v.to_i }
+        items = sc.instance_eval { @items }
+        ok {items.length} == 1
+        ok {items[0]}.is_a?(Benry::CmdOpt::SchemaItem)
+        ok {items[0].key} == :indent
+        ok {items[0].short} == 'i'
+        ok {items[0].long} == 'indent'
+        ok {items[0].param} == '<WIDTH>'
+        ok {items[0].required?} == false
+        ok {items[0].type} == Integer
+        ok {items[0].rexp} == /\A\d+\z/
+        ok {items[0].enum} == [2, 4, 8]
+        ok {items[0].range} == (1..2)
+        ok {items[0].detail} == "(description)"
+        ok {items[0].value} == 8
+        ok {items[0].tag} == :ab
+        ok {items[0].callback}.is_a?(Proc)
+        ok {items[0].callback.arity} == 1
+      end
+      spec "[!kuhf9] type, rexp, enum, and range are can be passed as positional args as well as keyword args." do
+        sc = @schema
+        sc.add(:key, "--optdef=xx", "desc", Integer, /\A\d+\z/, [2,4,8], (2..8))
+        item = sc.each.first
+        ok {item.type} == Integer
+        ok {item.rexp} == /\A\d+\z/
+        ok {item.enum} == [2,4,8]
+        ok {item.range} == (2..8)
+      end
+      spec "[!e3emy] raises error when positional arg is not one of class, regexp, array, nor range." do
+        sc = @schema
+        pr = proc { sc.add(:key, "--optdef=xx", "desc", "value") }
+        ok {pr}.raise?(Benry::CmdOpt::SchemaError,
+                       '"value": Expected one of class, regexp, array or range, but got String.')
+      end
+      spec "[!rhhji] raises SchemaError when key is not a Symbol." do
+        sc = @schema
+        pr = proc {
+          sc.add("-i, --indent[=<WIDTH>]", "indent width", nil)
+        }
+        ok {pr}.raise?(Benry::CmdOpt::SchemaError,
+                       'add("-i, --indent[=<WIDTH>]", "indent width"): The first arg should be a Symbol as an option key.')
+      end
+      spec "[!vq6eq] raises SchemaError when help message is missing." do
+        sc = @schema
+        pr = proc {
+          begin
+            sc.add(:indent, "-i, --indent[=<WIDTH>]", type: Array)   # Ruby 2
+          rescue ArgumentError
+            sc.add(:indent, "-i, --indent[=<WIDTH>]", {type: Array}) # Ruby 3
+          end
+        }
+        ok {pr}.raise?(Benry::CmdOpt::SchemaError,
+                       'add(:indent, "-i, --indent[=<WIDTH>]"): Help message required as 3rd argument.')
+      end
-  describe '#build_option_help()' do
-    before do
-      sc = Benry::Cmdopt::Schema.new
-      sc.add(:help   , "-h, --help"            , "show help message.")
-      sc.add(:version, "    --version"         , "print version")
-      sc.add(:file   , "-f, --file=<FILE>"     , "filename")
-      sc.add(:indent , "-i, --indent[=<WIDTH>]", "enable indent", type: Integer)
-      sc.add(:debug  , "-d, --debug"           , nil)
-      @schema = sc
     end
-    it "[!0aq0i] can take integer as width." do
-      help = @schema.build_option_help(41)
-      ok {help} == <<END
-  -h, --help                               : show help message.
-      --version                            : print version
-  -f, --file=<FILE>                        : filename
-  -i, --indent[=<WIDTH>]                   : enable indent
+    topic '#option_help()' do
+      before do
+        sc = Benry::CmdOpt::Schema.new
+        sc.add(:help   , "-h, --help"            , "show help message.")
+        sc.add(:version, "    --version"         , "print version")
+        sc.add(:file   , "-f, --file=<FILE>"     , "filename")
+        sc.add(:indent , "-i, --indent[=<WIDTH>]", "enable indent", type: Integer)
+        sc.add(:debug  , "-d, --debug"           , nil)
+        @schema = sc
+      end
+      spec "[!0aq0i] can take integer as width." do
+        helpmsg = @schema.option_help(41)
+        ok {helpmsg} == <<END
+  -h, --help                                : show help message.
+      --version                             : print version
+  -f, --file=<FILE>                         : filename
+  -i, --indent[=<WIDTH>]                    : enable indent
 END
-      s = help.each_line.first.split(':')[0]
-      ok {s.length} == 41+2
-    end
+        s = helpmsg.each_line.first.split(':')[0]
+        ok {s.length} == 41+3
+      end
-    it "[!pcsah] can take format string." do
-      help = @schema.build_option_help("%-42s: %s")
-      ok {help} == <<END
+      spec "[!pcsah] can take format string." do
+        helpmsg = @schema.option_help("%-42s: %s")
+        ok {helpmsg} == <<END
 -h, --help                                : show help message.
     --version                             : print version
 -f, --file=<FILE>                         : filename
 -i, --indent[=<WIDTH>]                    : enable indent
 END
-      s = help.each_line.first.split(':')[0]
-      ok {s.length} == 42+0
-    end
+        s = helpmsg.each_line.first.split(':')[0]
+        ok {s.length} == 42+0
+      end
-    it "[!dndpd] detects option width automatically when nothing specified." do
-      help = @schema.build_option_help()
-      ok {help} == <<END
+      spec "[!dndpd] detects option width automatically when nothing specified." do
+        helpmsg = @schema.option_help()
+        ok {helpmsg} == <<END
   -h, --help             : show help message.
       --version          : print version
   -f, --file=<FILE>      : filename
   -i, --indent[=<WIDTH>] : enable indent
 END
-      s = help.each_line.to_a.last.split(':')[0]
-      ok {s.length} == 25
-    end
+        s = helpmsg.each_line.to_a.last.split(':')[0]
+        ok {s.length} == 25
+      end
-    it "[!v7z4x] skips option help if help message is not specified." do
-      help = @schema.build_option_help()
-      ok {help} !~ /debug/
-    end
+      spec "[!v7z4x] skips option help if help message is not specified." do
+        helpmsg = @schema.option_help()
+        ok {helpmsg} !~ /debug/
+      end
-    it "[!to1th] includes all option help when `all` is true." do
-      help = @schema.build_option_help(nil, all: true)
-      ok {help} =~ /debug/
-      ok {help} == <<END
+      spec "[!to1th] includes all option help when `all` is true." do
+        helpmsg = @schema.option_help(nil, all: true)
+        ok {helpmsg} =~ /debug/
+        ok {helpmsg} == <<END
   -h, --help             : show help message.
       --version          : print version
   -f, --file=<FILE>      : filename
   -i, --indent[=<WIDTH>] : enable indent
   -d, --debug            :
 END
-    end
+      end
-    it "[!848rm] supports multi-lines help message." do
-      sc = Benry::Cmdopt::Schema.new
-      sc.add(:mode, "-m, --mode=<MODE>", <<END)
-output mode
+      spec "[!848rm] supports multi-lines help message." do
+        sc = Benry::CmdOpt::Schema.new
+        sc.add(:mode, "-m, --mode=<MODE>", "output mode",
+                      detail: <<"END")
   v, verbose: print many output
   q, quiet:   print litte output
   c, compact: print summary output
 END
-      actual = sc.build_option_help()
-      expected = <<END
+        actual = sc.option_help()
+        expected = <<END
   -m, --mode=<MODE>    : output mode
                            v, verbose: print many output
                            q, quiet:   print litte output
                            c, compact: print summary output
 END
-      ok {actual} == expected
+        ok {actual} == expected
+      end
+      spec "[!a4qe4] option should not be hidden if description is empty string." do
+        sc = Benry::CmdOpt::Schema.new
+        sc.add(:debug , "-D", nil)       # hidden
+        sc.add(:_trace, "-T", "trace")   # hidden
+        sc.add(:what  , "-W", "")        # NOT hidden!
+        ok {sc.option_help()} == <<END
+  -W             :
+END
+      end
     end
-  end
+    topic '#_default_format()' do
-  describe '#_default_format()' do
+      before do
+        sc = Benry::CmdOpt::Schema.new
+        sc.add(:help   , "-h, --help"            , "show help message.")
+        sc.add(:version, "    --version"         , "print version")
+        sc.add(:file   , "-f, --file=<FILE>"     , "filename")
+        sc.add(:indent , "-i, --indent[=<WIDTH>]", "enable indent", type: Integer)
+        sc.add(:debug  , "-d, --debug"           , nil)
+        @schema = sc
+      end
-    before do
-      sc = Benry::Cmdopt::Schema.new
-      sc.add(:help   , "-h, --help"            , "show help message.")
-      sc.add(:version, "    --version"         , "print version")
-      sc.add(:file   , "-f, --file=<FILE>"     , "filename")
-      sc.add(:indent , "-i, --indent[=<WIDTH>]", "enable indent", type: Integer)
-      sc.add(:debug  , "-d, --debug"           , nil)
-      @schema = sc
-    end
+      spec "[!kkh9t] returns format string." do
+        ret = @schema.__send__(:_default_format)
+        ok {ret} == "  %-22s : %s"
+      end
-    it "[!kkh9t] returns format string." do
-      ret = @schema.__send__(:_default_format)
-      ok {ret} == "  %-22s : %s"
-    end
+      spec "[!hr45y] detects preffered option width." do
+        ret = @schema.__send__(:_default_format, 10, 20)
+        ok {ret} == "  %-20s : %s"
+        ret = @schema.__send__(:_default_format, 30, 40)
+        ok {ret} == "  %-30s : %s"
+        ret = @schema.__send__(:_default_format, 10, 40)
+        ok {ret} == "  %-22s : %s"
+      end
+      spec "[!bmr7d] changes min_with according to options." do
+        sc = Benry::CmdOpt::Schema.new
+        sc.add(:help   , '-h', "help")
+        sc.add(:version, '-v', "version")
+        ok {sc.__send__(:_default_format, nil, 40)} == "  %-8s : %s"
+        #
+        sc.add(:file   , '-f <FILE>', "filename")
+        ok {sc.__send__(:_default_format, nil, 40)} == "  %-14s : %s"
+        #
+        sc.add(:force  , '--force', "forcedly")
+        ok {sc.__send__(:_default_format, nil, 40)} == "  %-14s : %s"
+        #
+        sc.add(:mode   , '-m, --mode=<MODE>', "verbose/quiet")
+        ok {sc.__send__(:_default_format, nil, 40)} == "  %-20s : %s"
+      end
-    it "[!hr45y] detects preffered option width." do
-      ret = @schema.__send__(:_default_format, 10, 20)
-      ok {ret} == "  %-20s : %s"
-      ret = @schema.__send__(:_default_format, 30, 40)
-      ok {ret} == "  %-30s : %s"
-      ret = @schema.__send__(:_default_format, 10, 40)
-      ok {ret} == "  %-22s : %s"
     end
-  end
+    topic '#_preferred_option_width()' do
-  describe '#each_option_help()' do
+      spec "[!kl91t] shorten option help min width when only single options which take no arg." do
+        sc = Benry::CmdOpt::Schema.new
+        sc.add(:help   , '-h', "help")
+        sc.add(:version, '-v', "version")
+        ok {sc.__send__(:_preferred_option_width)} == 8
+      end
+      spec "[!0koqb] widen option help min width when any option takes an arg." do
+        sc = Benry::CmdOpt::Schema.new
+        sc.add(:help   , '-h', "help")
+        sc.add(:indent , '-i[<N>]', "indent")
+        ok {sc.__send__(:_preferred_option_width)} == 14
+      end
+      spec "[!kl91t] widen option help min width when long option exists." do
+        sc = Benry::CmdOpt::Schema.new
+        sc.add(:help   , '-h', "help")
+        sc.add(:version, '-v, --version', "version")
+        ok {sc.__send__(:_preferred_option_width)} == 14
+        #
+        sc.add(:file, '--file=<FILE>', "filename")
+        ok {sc.__send__(:_preferred_option_width)} == 20
+      end
-    before do
-      sc = Benry::Cmdopt::Schema.new
-      sc.add(:help, "-h, --help", "show help message")
-      sc.add(:version, "    --version", "print version")
-      @schema = sc
     end
-    it "[!4b911] yields each optin definition str and help message." do
-      sc = @schema
-      arr = []
-      sc.each_option_help do |opt, help|
-        arr << [opt, help]
+    topic '#to_s()' do
+      spec "[!rrapd] '#to_s' is an alias to '#option_help()'." do
+        schema = Benry::CmdOpt::Schema.new
+        schema.add(:help   , "-h, --help"        , "show help message")
+        schema.add(:version, "    --version"     , "print version")
+        ok {schema.to_s} == schema.option_help()
       end
-      ok {arr} == [
-        ["-h, --help", "show help message"],
-        ["    --version", "print version"],
-      ]
     end
-    it "[!zbxyv] returns self." do
-      sc = @schema
-      ret = sc.each_option_help { nil }
-      ok {ret}.same? sc
+    topic '#each_option_and_desc()' do
+      before do
+        sc = Benry::CmdOpt::Schema.new
+        sc.add(:help, "-h, --help", "show help message")
+        sc.add(:version, "    --version", "print version")
+        sc.add(:debug  , "-d, --debug"  , nil)            # hidden
+        sc.add(:_DEBUG , "-D, --DEBUG"  , "debug mode")   # hidden
+        @schema = sc
+      end
+      spec "[!4b911] yields each optin definition str and help message." do
+        pairs = []
+        @schema.each_option_and_desc {|opt, desc| pairs << [opt, desc] }
+        ok {pairs} == [
+          ["-h, --help"    , "show help message"],  # not hiddden
+          ["    --version" , "print version"],      # not hidden
+        ]
+      end
+      spec "[!cl8zy] when 'all' flag is false, not yield hidden items." do
+        pairs = []
+        @schema.each_option_and_desc(all: false) {|opt, desc| pairs << [opt, desc] }
+        ok {pairs} == [
+          ["-h, --help"    , "show help message"],  # not hiddden
+          ["    --version" , "print version"],      # not hidden
+        ]
+      end
+      spec "[!tc4bk] when 'all' flag is true, yields even hidden items." do
+        pairs = []
+        @schema.each_option_and_desc(all: true) {|opt, desc| pairs << [opt, desc] }
+        ok {pairs} == [
+          ["-h, --help"    , "show help message"],  # not hiddden
+          ["    --version" , "print version"],      # not hidden
+          ["-d, --debug"   , nil],                  # hidden
+          ["-D, --DEBUG"   , "debug mode"],         # hidden
+        ]
+      end
+      spec "[!03sux] returns enumerator object if block not given." do
+        ## when 'all: true'
+        xs = @schema.each_option_and_desc(all: true)
+        ok {xs}.is_a?(Enumerator)
+        ok {xs.collect {|x, _| x }} == ["-h, --help", "    --version", "-d, --debug", "-D, --DEBUG"]
+        ## when 'all: false'
+        xs = @schema.each_option_and_desc(all: false)
+        ok {xs}.is_a?(Enumerator)
+        ok {xs.collect {|x, _| x }} == ["-h, --help", "    --version"]
+      end
+      spec "[!zbxyv] returns self." do
+        ret = @schema.each_option_and_desc { nil }
+        ok {ret}.same? @schema
+      end
     end
-  end
+    topic '#each()' do
-  describe '#find_short_option()' do
+      before do
+        @schema = Benry::CmdOpt::Schema.new
+        @schema.add(:help   , "-h, --help"   , "help message")
+        @schema.add(:version, "    --version", "print version")
+      end
+      spec "[!y4k1c] yields each option item." do
+        items = []
+        @schema.each {|x| items << x }
+        ok {items.length} == 2
+        ok {items[0]}.is_a?(Benry::CmdOpt::SchemaItem)
+        ok {items[1]}.is_a?(Benry::CmdOpt::SchemaItem)
+        ok {items[0].key} == :help
+        ok {items[1].key} == :version
+        keys = @schema.each.collect {|x| x.key }
+        ok {keys} == [:help, :version]
+      end
-    before do
-      @schema = new_sample_schema()
     end
-    it "[!b4js1] returns option definition matched to short name." do
-      x = @schema.find_short_option('h')
-      ok {x.key} == :help
-      x = @schema.find_short_option('f')
-      ok {x.key} == :file
-      x = @schema.find_short_option('i')
-      ok {x.key} == :indent
+    topic '#empty?()' do
+      spec "[!um8am] returns false if any item exists, else returns true." do
+        schema = Benry::CmdOpt::Schema.new
+        ok {schema.empty?()} == true
+        schema.add(:help   , "-h, --help"   , "help message")
+        ok {schema.empty?()} == false
+      end
+      spec "[!icvm1] ignores hidden items if 'all: false' kwarg specified." do
+        schema = Benry::CmdOpt::Schema.new
+        schema.add(:debug , "-D", nil)
+        schema.add(:_trace, "-T", "trace")
+        ok {schema.empty?()} == false
+        ok {schema.empty?(all: true)} == false
+        ok {schema.empty?(all: false)} == true
+      end
     end
-    it "[!s4d1y] returns nil when nothing found." do
-      ok {@schema.find_short_option('v')} == nil
+    topic '#get()' do
+      before do
+        @schema = Benry::CmdOpt::Schema.new
+        @schema.add(:help   , "-h, --help"   , "help message")
+        @schema.add(:version, "    --version", "print version")
+      end
+      spec "[!3wjfp] finds option item object by key." do
+        item = @schema.get(:help)
+        ok {item.key} == :help
+        item = @schema.get(:version)
+        ok {item.key} == :version
+      end
+      spec "[!0spll] returns nil if key not found." do
+        ok {@schema.get(:debug)} == nil
+      end
     end
-  end
+    topic '#delete()' do
+      before do
+        @schema = Benry::CmdOpt::Schema.new
+        @schema.add(:help   , "-h, --help"   , "help message")
+        @schema.add(:version, "    --version", "print version")
+      end
+      spec "[!l86rb] deletes option item corresponding to key." do
+        keys = @schema.each.collect {|x| x.key }
+        ok {keys} == [:help, :version]
+        @schema.delete(:help)
+        keys = @schema.each.collect {|x| x.key }
+        ok {keys} == [:version]
+      end
-  describe '#find_long_option()' do
+      spec "[!rq0aa] returns deleted item." do
+        item = @schema.delete(:version)
+        ok {item} != nil
+        ok {item.key} == :version
+      end
-    before do
-      @schema = new_sample_schema()
     end
-    it "[!atmf9] returns option definition matched to long name." do
-      x = @schema.find_long_option('help')
-      ok {x.key} == :help
-      x = @schema.find_long_option('file')
-      ok {x.key} == :file
-      x = @schema.find_long_option('indent')
-      ok {x.key} == :indent
+    topic '#find_short_option()' do
+      before do
+        @schema = new_sample_schema()
+      end
+      spec "[!b4js1] returns option definition matched to short name." do
+        x = @schema.find_short_option('h')
+        ok {x.key} == :help
+        x = @schema.find_short_option('f')
+        ok {x.key} == :file
+        x = @schema.find_short_option('i')
+        ok {x.key} == :indent
+      end
+      spec "[!s4d1y] returns nil when nothing found." do
+        ok {@schema.find_short_option('v')} == nil
+      end
     end
-    it "[!6haoo] returns nil when nothing found." do
-      ok {@schema.find_long_option('lib')} == nil
+    topic '#find_long_option()' do
+      before do
+        @schema = new_sample_schema()
+      end
+      spec "[!atmf9] returns option definition matched to long name." do
+        x = @schema.find_long_option('help')
+        ok {x.key} == :help
+        x = @schema.find_long_option('file')
+        ok {x.key} == :file
+        x = @schema.find_long_option('indent')
+        ok {x.key} == :indent
+      end
+      spec "[!6haoo] returns nil when nothing found." do
+        ok {@schema.find_long_option('lib')} == nil
+      end
     end
   end
-end
+  topic Benry::CmdOpt::SchemaItem do
+    ITEMS = [
+      Benry::CmdOpt::SchemaItem.new(:help, "-h, --help", "help msg",
+                                    "h", "help", nil, nil),
+      Benry::CmdOpt::SchemaItem.new(:file, "-f, --file=<file>", "filename",
+                                    "f", "file", "<file>", true),
+      Benry::CmdOpt::SchemaItem.new(:indent, "-i, --indent[=<N>]", "indent width",
+                                    "i", "indent", "<N>", false),
+    ]
-class Benry::Cmdopt::SchemaItem::Test < MiniTest::Test
+    topic '#initialize()' do
-  describe '#validate_and_convert()' do
+      before do
+        @schema = Benry::CmdOpt::Schema.new
+      end
-    def new_item(key, optstr, short, long, param, help,
-                 optional: nil, type: nil, pattern: nil, enum: nil, &callback)
-      return Benry::Cmdopt::SchemaItem.new(key, optstr, short, long, param, help,
-                 optional: optional, type: type, pattern: pattern, enum: enum, &callback)
-    end
+      spec "[!nn4cp] freezes enum object." do
+        item = Benry::CmdOpt::SchemaItem.new(:foo, "--foo", "desc", nil, "foo", "<val>",
+                                             true, enum: ["x", "y", "z"])
+        ok {item.enum} == ["x", "y", "z"]
+        ok {item.enum}.frozen?
+      end
-    it "[!h0s0o] raises RuntimeError when value not matched to pattern." do
-      x = new_item(:indent, "", "i", "indent", "<WIDTH>", "indent width", pattern: /\A\d+\z/)
-      optdict = {}
-      pr = proc { x.validate_and_convert("abc", optdict) }
-      ok {pr}.raise?(RuntimeError, "pattern unmatched.")
-    end
+      case_when "[!wy2iv] when 'type:' specified..." do
-    it "[!5jrdf] raises RuntimeError when value not in enum." do
-      x = new_item(:indent, "", "i", "indent", "<WIDTH>", "indent width", enum: ['2', '4', '8'])
-      optdict = {}
-      pr = proc { x.validate_and_convert("10", optdict) }
-      ok {pr}.raise?(RuntimeError, "expected one of 2/4/8.")
-    end
+        spec "[!7xmr5] raises SchemaError when type is not registered." do
+          sc = @schema
+          pr = proc {
+            sc.add(:indent, "-i, --indent[=<WIDTH>]", "indent width", type: Array)
+          }
+          ok {pr}.raise?(Benry::CmdOpt::SchemaError,
+                         "Array: Unregistered type.")
+        end
-    it "[!j4fuz] calls type-specific callback when type specified." do
-      x = new_item(:indent, "", "i", "indent", "<WIDTH>", "indent width", type: Integer)
-      optdict = {}
-      pr = proc { x.validate_and_convert("abc", optdict) }
-      ok {pr}.raise?(RuntimeError, "integer expected.")
-    end
+        spec "[!s2aaj] raises SchemaError when option has no params but type specified." do
+          sc = @schema
+          pr = proc {
+            sc.add(:indent, "-i, --indent", "indent width", type: Integer)
+          }
+          ok {pr}.raise?(Benry::CmdOpt::SchemaError,
+                         "Integer: Type specified in spite of option has no params.")
+        end
-    it "[!jn9z3] calls callback when callback specified." do
-      called = false
-      x = new_item(:indent, "", "i", "indent", "<WIDTH>", "indent width") {|va|
-        called = true
-      }
-      optdict = {}
-      x.validate_and_convert("abc", optdict)
-      ok {called} == true
-    end
+        spec "[!sz8x2] not raise error when no params but value specified." do
+          sc = @schema
+          pr = proc {
+            sc.add(:indent, "-i, --indent", "indent width", type: Integer, value: 0)
+          }
+          ok {pr}.NOT.raise?(Exception)
+        end
-    it "[!iqalh] calls callback with different number of args according to arity." do
-      args1 = nil
-      x = new_item(:indent, "", "i", "indent", "<WIDTH>", nil) {|val|
-        args1 = val
-      }
-      optdict = {}
-      x.validate_and_convert("123", optdict)
-      ok {args1} == "123"
-      #
-      args2 = nil
-      x = new_item(:indent, "", "i", "indent", "<WIDTH>", nil) {|optdict, key, val|
-        args2 = [optdict, key, val]
-      }
-      optdict = {}
-      x.validate_and_convert("123", optdict)
-      ok {args2} == [optdict, :indent, "123"]
-    end
+        spec "[!70ogf] not raise error when no params but TrueClass specified." do
+          sc = @schema
+          pr = proc {
+            sc.add(:indent, "-i, --indent", "indent width", type: TrueClass)
+          }
+          ok {pr}.NOT.raise?(Exception)
+        end
-    it "[!x066l] returns new value." do
-      x = new_item(:indent, "", "i", "indent", "<WIDTH>", nil, type: Integer)
-      ok {x.validate_and_convert("123", {})} == 123
-      #
-      x = new_item(:indent, "", "i", "indent", "<WIDTH>", nil, type: Integer) {|val|
-        val * 2
-      }
-      ok {x.validate_and_convert("123", {})} == 246
-    end
+      end
-  end
+      case_when "[!6y8s2] when 'rexp:' specified..." do
-end
+        spec "[!bi2fh] raises SchemaError when pattern is not a regexp." do
+          sc = @schema
+          pr = proc {
+            sc.add(:indent, "-x, --indent[=<WIDTH>]", "indent width", rexp: '\A\d+\z')
+          }
+          ok {pr}.raise?(Benry::CmdOpt::SchemaError,
+                         '"\\\\A\\\\d+\\\\z": Regexp pattern expected.')
+        end
+        spec "[!01fmt] raises SchmeaError when option has no params but pattern specified." do
+          sc = @schema
+          pr = proc {
+            sc.add(:indent, "-i, --indent", "indent width", rexp: /\A\d+\z/)
+          }
+          ok {pr}.raise?(Benry::CmdOpt::SchemaError,
+                         '/\A\d+\z/: Regexp pattern specified in spite of option has no params.')
+        end
+      end
-class Benry::Cmdopt::Parser::Test < MiniTest::Test
+      case_when "[!5nrvq] when 'enum:' specified..." do
+        spec "[!melyd] raises SchemaError when enum is not an Array nor Set." do
+          sc = @schema
+          sc.add(:indent, "-i <N>", "indent width", enum: ["2", "4", "8"])
+          sc.add(:indent, "-i <N>", "indent width", enum: Set.new(["2", "4", "8"]))
+          pr = proc {
+            sc.add(:indent, "-i <N>", "indent width", enum: "2,4,8")
+          }
+          ok {pr}.raise?(Benry::CmdOpt::SchemaError,
+                         '"2,4,8": Array or set expected.')
+        end
+        spec "[!xqed8] raises SchemaError when enum specified for no param option." do
+          sc = @schema
+          pr = proc {
+            sc.add(:indent, "-i", "enable indent", enum: [2, 4, 8])
+          }
+          ok {pr}.raise?(Benry::CmdOpt::SchemaError,
+                         "[2, 4, 8]: Enum specified in spite of option has no params.")
+        end
-  describe '#parse_options()' do
+        spec "[!zuthh] raises SchemaError when enum element value is not instance of type class." do
+          sc = @schema
+          pr = proc {
+            sc.add(:indent, "-i <N>", "enable indent", type: Integer, enum: ['2', '4', '8'])
+          }
+          ok {pr}.raise?(Benry::CmdOpt::SchemaError,
+                         '["2", "4", "8"]: Enum element value should be instance of Integer, but "2" is not.')
+        end
-    before do
-      @parser = Benry::Cmdopt::Parser.new(new_sample_schema())
-    end
+      end
-    it "[!3wmsy] returns command option values as a dict." do
-      argv = ["-h", "--version"]
-      d = @parser.parse(argv)
-      ok {d} == {help: true, version: true}
-    end
+      case_when "[!hk4nw] when 'range:' specified..." do
-    it "[!uh7j8] parses long options." do
-      argv = ["--help", "--file=foo.png", "--indent=10"]
-      d = @parser.parse(argv)
-      ok {d} == {help: true, file: "foo.png", indent: 10}
-    end
+        spec "[!z20ky] raises SchemaError when range is not a Range object." do
+          pr = proc {
+            @schema.add(:indent, "-i <N>", "indent", type: Integer, range: [1,8])
+          }
+          ok {pr}.raise?(Benry::CmdOpt::SchemaError,
+                         "[1, 8]: Range object expected.")
+        end
-    it "[!nwnjc] parses short options." do
-      argv = ["-h", "-f", "foo.png", "-i10"]
-      d = @parser.parse(argv)
-      ok {d} == {help: true, file: "foo.png", indent: 10}
-    end
+        spec "[!gp025] raises SchemaError when range specified with `type: TrueClass`." do
+          pr = proc {
+            @schema.add(:indent, "-i <N>", "indent", type: TrueClass, range: 0..1)
+          }
+          ok {pr}.raise?(Benry::CmdOpt::SchemaError,
+                         "0..1: Range is not available with `type: TrueClass`.")
+        end
-    it "[!y04um] skips rest options when '--' found in argv." do
-      argv = ["-h", "--", "-f", "foo.png", "-i10"]
-      d = @parser.parse(argv)
-      ok {d} == {help: true}
-      ok {argv} == ["-f", "foo.png", "-i10"]
-    end
+        spec "[!7njd5] range beginning/end value should be expected type." do
+          pr = proc {
+            @schema.add(:indent, "-i <N>", "indent", range: (1..8))
+          }
+          ok {pr}.raise?(Benry::CmdOpt::SchemaError,
+                         "1..8: Range value should be String, but not.")
+          pr = proc {
+            @schema.add(:indent, "-i <N>", "indent", type: Date, range: (1..8))
+          }
+          ok {pr}.raise?(Benry::CmdOpt::SchemaError,
+                         "1..8: Range value should be Date, but not.")
+        end
+        spec "[!uymig] range object can be endless." do
+          begin
+            range1 = eval "(1..)"    # Ruby >= 2.6
+            range2 = eval "(..3)"    # Ruby >= 2.6
+          rescue SyntaxError
+            range1 = nil             # Ruby < 2.6
+            range2 = nil             # Ruby < 2.6
+          end
+          if range1
+            pr = proc {
+              @schema.add(:indent1, "-i <N>", "indent", type: Integer, range: range1)
+              @schema.add(:indent2, "-j <N>", "indent", type: Integer, range: range2)
+            }
+            pr.call
+            ok {pr}.NOT.raise?(Exception)
+          end
+        end
-    it "[!qpuxh] handles only OptionError when block given." do
-      errmsg = nil
-      errcls = nil
-      @parser.parse(["-ix"]) {|err|
-        errmsg = err.message
-        errcls = err.class
-      }
-      ok {errmsg} == "-ix: integer expected."
-      ok {errcls} == Benry::Cmdopt::OptionError
-      #
-      sc = Benry::Cmdopt::Schema.new
-      sc.add(:file, "--file=<FILE>", "file") do |val|
-        File.open(val) {|f| f.read }
       end
-      parser = Benry::Cmdopt::Parser.new(sc)
-      pr = proc { parser.parse(["--file=/foo/bar/baz.png"]) }
-      ok {pr}.raise?(Errno::ENOENT, /No such file or directory/)
-    end
-    it "[!dhpw1] returns nil when OptionError handled." do
-      ret = @parser.parse(["-dx"]) {|err| 1 }
-      ok {ret} == nil
-    end
+      case_when "[!a0g52] when 'value:' specified..." do
-  end
+        spec "[!435t6] raises SchemaError when 'value:' is specified on argument-required option." do
+          sc = @schema
+          pr = proc {
+            sc.add(:flag, "--flag=<on|off>", "flag", type: TrueClass, value: true)
+          }
+          ok {pr}.raise?(Benry::CmdOpt::SchemaError,
+                         "true: 'value:' is meaningless when option has required argument (hint: change to optional argument instead).")
+        end
+        spec "[!6vwqv] raises SchemaError when type is TrueClass but value is not true nor false." do
+          sc = @schema
+          pr = proc {
+            sc.add(:flag, "--flag[=<on|off>]", "flag", type: TrueClass, value: 0)
+          }
+          ok {pr}.raise?(Benry::CmdOpt::SchemaError,
+                         "0: Value should be true or false when `type: TrueClass` specified.")
+        end
-  describe '#parse_long_option()' do
+        spec "[!c6i2o] raises SchemaError when value is not a kind of type." do
+          sc = @schema
+          pr = proc {
+            sc.add(:flag, "--flag[=<on|off>]", "flag", type: Integer, value: false)
+          }
+          ok {pr}.raise?(Benry::CmdOpt::SchemaError,
+                         "Type mismatched between `type: Integer` and `value: false`.")
+        end
-    before do
-      @parser = Benry::Cmdopt::Parser.new(new_sample_schema())
-    end
+        spec "[!lnhp6] not raise error when type is not specified." do
+          sc = @schema
+          pr = proc {
+            sc.add(:flag, "--flag[=<on|off>]", "flag", value: false)
+          }
+          ok {pr}.NOT.raise?(Exception)
+        end
-    it "[!3i994] raises OptionError when invalid long option format." do
-      argv = ["--f/o/o"]
-      pr = proc { @parser.parse(argv) }
-      ok {pr}.raise?(Benry::Cmdopt::OptionError, "--f/o/o: invalid long option.")
-    end
+        spec "[!6xb8o] value should be included in enum values." do
+          sc = @schema
+          pr = proc {
+            sc.add(:lang, "--lang[=<en|fr|it>]", "language", enum: ["en", "fr", "it"], value: "ja")
+          }
+          ok {pr}.raise?(Benry::CmdOpt::SchemaError,
+                         "ja: Value should be included in enum values, but not.")
+        end
-    it "[!er7h4] raises OptionError when unknown long option." do
-      argv = ["--foo"]
-      pr = proc { @parser.parse(argv) }
-      ok {pr}.raise?(Benry::Cmdopt::OptionError, "--foo: unknown long option.")
-    end
+      end
-    it "[!2jd9w] raises OptionError when no arguments specified for arg required long option." do
-      argv = ["--file"]
-      pr = proc { @parser.parse(argv) }
-      ok {pr}.raise?(Benry::Cmdopt::OptionError, "--file: argument required.")
     end
-    it "[!qyq8n] raises optionError when an argument specified for no arg long option." do
-      argv = ["--version=1.0.0"]
-      pr = proc { @parser.parse(argv) }
-      ok {pr}.raise?(Benry::Cmdopt::OptionError, "--version=1.0.0: unexpected argument.")
-    end
-    it "[!o596x] validates argument value." do
-      argv = ["--indent=abc"]
-      pr = proc { @parser.parse(argv) }
-      ok {pr}.raise?(Benry::Cmdopt::OptionError, "--indent=abc: integer expected.")
-      #
-      argv = ["--path=/foo/bar"]
-      pr = proc { @parser.parse(argv) }
-      ok {pr}.raise?(Benry::Cmdopt::OptionError, "--path=/foo/bar: directory not exist.")
+    topic '#required?' do
+      spec "[!svxny] returns nil if option takes no arguments." do
+        item, _, _ = ITEMS
+        ok {item.required?} == nil
+      end
+      spec "[!togcx] returns true if argument is required." do
+        _, item, _ = ITEMS
+        ok {item.required?} == true
+      end
+      spec "[!uwbgc] returns false if argument is optional." do
+        _, _, item = ITEMS
+        ok {item.required?} == false
+      end
     end
-  end
+    topic '#arg_requireness()' do
-  describe '#parse_short_option()' do
+      spec "[!kmo28] returns :none if option takes no arguments." do
+        item, _, _ = ITEMS
+        ok {item.arg_requireness()} == :none
+      end
-    before do
-      @parser = Benry::Cmdopt::Parser.new(new_sample_schema())
-    end
+      spec "[!s8gxl] returns :required if argument is required." do
+        _, item, _ = ITEMS
+        ok {item.arg_requireness()} == :required
+      end
-    it "[!4eh49] raises OptionError when unknown short option specified." do
-      argv = ["-hxf", "foo.png"]
-      pr = proc { @parser.parse(argv) }
-      ok {pr}.raise?(Benry::Cmdopt::OptionError, "-x: unknown option.")
-    end
+      spec "[!owpba] returns :optional if argument is optional." do
+        _, _, item = ITEMS
+        ok {item.arg_requireness()} == :optional
+      end
-    it "[!utdbf] raises OptionError when argument required but not specified." do
-      argv = ["-hf"]
-      pr = proc { @parser.parse(argv) }
-      ok {pr}.raise?(Benry::Cmdopt::OptionError, "-f: argument required.")
     end
-    it "[!f63hf] short option arg can be specified without space separator." do
-      argv = ["-hfabc.png", "xx"]
-      d = @parser.parse(argv)
-      ok {d} == {help: true, file: "abc.png"}
-      ok {argv} == ["xx"]
-    end
-    it "[!yjq6b] optional arg should be specified without space separator." do
-      argv = ["-hi123", "xx"]
-      d = @parser.parse(argv)
-      ok {d} == {help: true, indent: 123}
-      ok {argv} == ['xx']
-    end
+    topic '#hidden?()' do
-    it "[!wape4] otpional arg can be omit." do
-      argv = ["-hi", "xx"]
-      d = @parser.parse(argv)
-      ok {d} == {help: true, indent: true}
-      ok {argv} == ['xx']
-    end
+      spec "[!h0uxs] returns true if desc is nil." do
+        desc = nil
+        item = Benry::CmdOpt::SchemaItem.new(:debug, "-D", desc, "D", nil, nil, nil)
+        ok {item.hidden?} == true
+      end
+      spec "[!su00g] returns true if key starts with '_'." do
+        desc = "debug mode"
+        item = Benry::CmdOpt::SchemaItem.new(:_debug, "-D", desc, "D", nil, nil, nil)
+        ok {item.hidden?} == true
+      end
+      spec "[!28vzx] returns false if else." do
+        desc = "debug mode"
+        item = Benry::CmdOpt::SchemaItem.new(:debug, "-D", desc, "D", nil, nil, nil)
+        ok {item.hidden?} == false
+      end
-    it "[!yu0kc] validates short option argument." do
-      argv = ["-iaaa"]
-      pr = proc { @parser.parse(argv) }
-      ok {pr}.raise?(Benry::Cmdopt::OptionError, "-iaaa: integer expected.")
-      #
-      argv = ["-I", "/foo/bar"]
-      pr = proc { @parser.parse(argv) }
-      ok {pr}.raise?(Benry::Cmdopt::OptionError, "-I /foo/bar: directory not exist.")
     end
-  end
+    topic '#validate_and_convert()' do
+      def new_item(key, optstr, desc, short, long, param, required,
+                   type: nil, rexp: nil, enum: nil, range: nil, value: nil, &callback)
+        return Benry::CmdOpt::SchemaItem.new(key, optstr, desc, short, long, param, required,
+                   type: type, rexp: rexp, enum: enum, range: range, value: value, &callback)
+      end
+      spec "[!h0s0o] raises RuntimeError when value not matched to pattern." do
+        x = new_item(:indent, "", "indent width", "i", "indent", "<WIDTH>", false, rexp: /\A\d+\z/)
+        optdict = {}
+        pr = proc { x.validate_and_convert("abc", optdict) }
+        ok {pr}.raise?(RuntimeError, "Pattern unmatched.")
+      end
+      spec "[!5jrdf] raises RuntimeError when value not in enum." do
+        x = new_item(:indent, "", "indent width", "i", "indent", "<WIDTH>", false, enum: ['2', '4', '8'])
+        optdict = {}
+        pr = proc { x.validate_and_convert("10", optdict) }
+        ok {pr}.raise?(RuntimeError, "Expected one of 2/4/8.")
+      end
-  describe '#new_options_dict()' do
+      spec "[!5falp] raise RuntimeError when value not in range." do
+        x = new_item(:indent, "-i[=<N>]", "indent", "i", nil, "<N>", false,
+                     type: Integer, range: 2..8)
+        optdict = {}
+        pr = proc { x.validate_and_convert("1", optdict) }
+        ok {pr}.raise?(RuntimeError, "Too small (min: 2)")
+        pr = proc { x.validate_and_convert("9", optdict) }
+        ok {pr}.raise?(RuntimeError, "Too large (max: 8)")
+        ## when min==0
+        x = new_item(:indent, "-i[=<N>]", "indent", "i", nil, "<N>", false,
+                     type: Integer, range: 0..8)
+        optdict = {}
+        pr = proc { x.validate_and_convert("-1", optdict) }
+        ok {pr}.raise?(RuntimeError, "Positive value (>= 0) expected.")
+        ## when min==1
+        x = new_item(:indent, "-i[=<N>]", "indent", "i", nil, "<N>", false,
+                     type: Integer, range: 1..8)
+        optdict = {}
+        pr = proc { x.validate_and_convert("0", optdict) }
+        ok {pr}.raise?(RuntimeError, "Positive value (>= 1) expected.")
+      end
+      spec "[!a0rej] supports endless range." do
+        begin
+          range1 = eval "(2..)"     # Ruby >= 2.6
+          range2 = eval "(..8)"
+        rescue SyntaxError
+          range1 = nil              # Ruby < 2.6
+          range2 = nil
+        end
+        if range1
+          x = new_item(:indent, "-i[=<N>]", "indent", "i", nil, "<N>", false,
+                       type: Integer, range: range1)
+          optdict = {}
+          pr = proc { x.validate_and_convert("1", optdict) }
+          ok {pr}.raise?(RuntimeError, "Too small (min: 2)")
+          pr = proc { x.validate_and_convert("9", optdict) }
+          ok {pr}.NOT.raise?(RuntimeError)
+        end
+        if range2
+          x = new_item(:indent, "-i[=<N>]", "indent", "i", nil, "<N>", false,
+                       type: Integer, range: range2)
+          optdict = {}
+          pr = proc { x.validate_and_convert("1", optdict) }
+          ok {pr}.NOT.raise?(RuntimeError)
+          pr = proc { x.validate_and_convert("9", optdict) }
+          ok {pr}.raise?(RuntimeError, "Too large (max: 8)")
+        end
+      end
+      spec "[!j4fuz] calls type-specific callback when type specified." do
+        x = new_item(:indent, "", "indent width", "i", "indent", "<WIDTH>", false, type: Integer)
+        optdict = {}
+        pr = proc { x.validate_and_convert("abc", optdict) }
+        ok {pr}.raise?(RuntimeError, "Integer expected.")
+      end
+      spec "[!jn9z3] calls callback when callback specified." do
+        called = false
+        x = new_item(:indent, "", "indent width", "i", "indent", "<WIDTH>", false) {|va|
+          called = true
+        }
+        optdict = {}
+        x.validate_and_convert("abc", optdict)
+        ok {called} == true
+      end
+      spec "[!iqalh] calls callback with different number of args according to arity." do
+        args1 = nil
+        x = new_item(:indent, "", "indent width", "i", "indent", "<WIDTH>", false) {|val|
+          args1 = val
+        }
+        optdict = {}
+        x.validate_and_convert("123", optdict)
+        ok {args1} == "123"
+        #
+        args2 = nil
+        x = new_item(:indent, "", "indent width", "i", "indent", "<WIDTH>", false) {|optdict, key, val|
+          args2 = [optdict, key, val]
+        }
+        optdict = {}
+        x.validate_and_convert("123", optdict)
+        ok {args2} == [optdict, :indent, "123"]
+      end
+      spec "[!x066l] returns new value." do
+        x = new_item(:indent, "", "indent width", "i", "indent", "<WIDTH>", false, type: Integer)
+        ok {x.validate_and_convert("123", {})} == 123
+        #
+        x = new_item(:indent, "", "indent width", "i", "indent", "<WIDTH>", false, type: Integer) {|val|
+          val * 2
+        }
+        ok {x.validate_and_convert("123", {})} == 246
+      end
+      spec "[!eafem] returns default value (if specified) instead of true value." do
+        x1 = new_item(:flag, "", "desc", "f", "flag", nil, false, value: nil)
+        ok {x1.validate_and_convert(true, {})} == true
+        x2 = new_item(:flag, "", "desc", "f", "flag", nil, false, value: "blabla")
+        ok {x2.validate_and_convert(true, {})} == "blabla"
+        x3 = new_item(:flag, "", "desc", "f", "flag", nil, false, value: false)
+        ok {x3.validate_and_convert(true, {})} == false
+      end
-    it "[!vm6h0] returns new hash object." do
-      parser = Benry::Cmdopt::Parser.new(new_sample_schema())
-      ret = parser.__send__(:new_options_dict)
-      ok {ret}.is_a?(Hash)
-      ok {ret} == {}
     end
   end
-end
+  topic Benry::CmdOpt::Parser do
-class Benry::Cmdopt::Test < MiniTest::Test
+    topic '#parse_options()' do
+      before do
+        @parser = Benry::CmdOpt::Parser.new(new_sample_schema())
+      end
-  describe 'PARAM_TYPES[Integer]' do
+      spec "[!3wmsy] returns command option values as a dict." do
+        argv = ["-h", "--version"]
+        d = @parser.parse(argv)
+        ok {d} == {help: true, version: true}
+      end
-    before do
-      sc = Benry::Cmdopt::Schema.new
-      sc.add(:indent, "-i, --indent[=<N>]", "indent width", type: Integer)
-      @parser = Benry::Cmdopt::Parser.new(sc)
-    end
+      spec "[!uh7j8] parses long options." do
+        argv = ["--help", "--file=foo.png", "--indent=10"]
+        d = @parser.parse(argv)
+        ok {d} == {help: true, file: "foo.png", indent: 10}
+      end
-    it "[!6t8cs] converts value into integer." do
-      d = @parser.parse(['-i20'])
-      ok {d[:indent]} == 20
-      #
-      d = @parser.parse(['--indent=12'])
-      ok {d[:indent]} == 12
-    end
+      spec "[!nwnjc] parses short options." do
+        argv = ["-h", "-f", "foo.png", "-i10"]
+        d = @parser.parse(argv)
+        ok {d} == {help: true, file: "foo.png", indent: 10}
+      end
+      spec "[!5s5b6] treats '-' as an argument, not an option." do
+        argv = ["-h", "-", "xxx", "yyy"]
+        d = @parser.parse(argv)
+        ok {d} == {help: true}
+        ok {argv} == ["-", "xxx", "yyy"]
+      end
+      spec "[!q8356] parses options even after arguments when `all: true`." do
+        argv = ["-h", "arg1", "-f", "foo.png", "arg2", "-i10", "arg3"]
+        d = @parser.parse(argv, all: true)
+        ok {d} == {help: true, file: "foo.png", indent: 10}
+        ok {argv} == ["arg1", "arg2", "arg3"]
+        #
+        argv = ["-h", "arg1", "-f", "foo.png", "arg2", "-i10", "arg3"]
+        d = @parser.parse(argv)
+        ok {d} == {help: true, file: "foo.png", indent: 10}
+        ok {argv} == ["arg1", "arg2", "arg3"]
+      end
+      spec "[!ryra3] doesn't parse options after arguments when `all: false`." do
+        argv = ["-h", "arg1", "-f", "foo.png", "arg2", "-i10", "arg3"]
+        d = @parser.parse(argv, all: false)
+        ok {d} == {help: true}
+        ok {argv} == ["arg1", "-f", "foo.png", "arg2", "-i10", "arg3"]
+      end
+      spec "[!y04um] skips rest options when '--' found in argv." do
+        argv = ["-h", "--", "-f", "foo.png", "-i10"]
+        d = @parser.parse(argv)
+        ok {d} == {help: true}
+        ok {argv} == ["-f", "foo.png", "-i10"]
+      end
+      spec "[!qpuxh] handles only OptionError when block given." do
+        errmsg = nil
+        errcls = nil
+        @parser.parse(["-ix"]) {|err|
+          errmsg = err.message
+          errcls = err.class
+        }
+        ok {errmsg} == "-ix: Integer expected."
+        ok {errcls} == Benry::CmdOpt::OptionError
+        #
+        sc = Benry::CmdOpt::Schema.new
+        sc.add(:file, "--file=<FILE>", "file") do |val|
+          File.open(val) {|f| f.read }
+        end
+        parser = Benry::CmdOpt::Parser.new(sc)
+        pr = proc { parser.parse(["--file=/foo/bar/baz.png"]) }
+        ok {pr}.raise?(Errno::ENOENT, /No such file or directory/)
+      end
+      spec "[!dhpw1] returns nil when OptionError handled." do
+        ret = @parser.parse(["-dx"]) {|err| 1 }
+        ok {ret} == nil
+      end
-    it "[!nzwc9] raises error when failed to convert value into integer." do
-      pr = proc { @parser.parse(['-i2.1']) }
-      ok {pr}.raise?(Benry::Cmdopt::OptionError, "-i2.1: integer expected.")
-      #
-      pr = proc { @parser.parse(['--indent=2.2']) }
-      ok {pr}.raise?(Benry::Cmdopt::OptionError, "--indent=2.2: integer expected.")
     end
-  end
+    topic '#parse_long_option()' do
+      before do
+        @parser = Benry::CmdOpt::Parser.new(new_sample_schema())
+      end
+      spec "[!3i994] raises OptionError when invalid long option format." do
+        argv = ["--f/o/o"]
+        pr = proc { @parser.parse(argv) }
+        ok {pr}.raise?(Benry::CmdOpt::OptionError, "--f/o/o: Invalid long option.")
+      end
+      spec "[!1ab42] invokes error handler method when unknown long option." do
+        def @parser.handle_unknown_long_option(optstr, name, val)
+          (@_called_ ||= []) << [optstr, name, val]
+        end
+        ret = @parser.parse(["--xx=XX", "--yy=YY", "--zz"])
+        ok {ret} == {}
+        ok {@parser.instance_variable_get('@_called_')} == [
+          ["--xx=XX", "xx", "XX"],
+          ["--yy=YY", "yy", "YY"],
+          ["--zz"   , "zz", nil],
+        ]
+      end
+      spec "[!er7h4] default behavior is to raise OptionError when unknown long option." do
+        argv = ["--foo"]
+        pr = proc { @parser.parse(argv) }
+        ok {pr}.raise?(Benry::CmdOpt::OptionError, "--foo: Unknown long option.")
+      end
+      spec "[!2jd9w] raises OptionError when no arguments specified for arg required long option." do
+        argv = ["--file"]
+        pr = proc { @parser.parse(argv) }
+        ok {pr}.raise?(Benry::CmdOpt::OptionError, "--file: Argument required.")
+      end
+      spec "[!qyq8n] raises optionError when an argument specified for no arg long option." do
+        argv = ["--version=1.0.0"]
+        pr = proc { @parser.parse(argv) }
+        ok {pr}.raise?(Benry::CmdOpt::OptionError, "--version=1.0.0: Unexpected argument.")
+      end
-  describe 'PARAM_TYPES[Float]' do
+      spec "[!o596x] validates argument value." do
+        argv = ["--indent=abc"]
+        pr = proc { @parser.parse(argv) }
+        ok {pr}.raise?(Benry::CmdOpt::OptionError, "--indent=abc: Integer expected.")
+        #
+        argv = ["--path=/foo/bar"]
+        pr = proc { @parser.parse(argv) }
+        ok {pr}.raise?(Benry::CmdOpt::OptionError, "--path=/foo/bar: Directory not exist.")
+      end
-    before do
-      sc = Benry::Cmdopt::Schema.new
-      sc.add(:ratio, "-r, --ratio=<RATIO>", "ratio", type: Float)
-      @parser = Benry::Cmdopt::Parser.new(sc)
     end
-    it "[!gggy6] converts value into float." do
-      d = @parser.parse(['-r', '1.25'])
-      ok {d[:ratio]} == 1.25
-      #
-      d = @parser.parse(['--ratio=1.25'])
-      ok {d[:ratio]} == 1.25
+    topic '#parse_short_option()' do
+      before do
+        @parser = Benry::CmdOpt::Parser.new(new_sample_schema())
+      end
+      spec "[!4eh49] raises OptionError when unknown short option specified." do
+        argv = ["-hxf", "foo.png"]
+        pr = proc { @parser.parse(argv) }
+        ok {pr}.raise?(Benry::CmdOpt::OptionError, "-x: Unknown option.")
+      end
+      spec "[!utdbf] raises OptionError when argument required but not specified." do
+        argv = ["-hf"]
+        pr = proc { @parser.parse(argv) }
+        ok {pr}.raise?(Benry::CmdOpt::OptionError, "-f: Argument required.")
+      end
+      spec "[!f63hf] short option arg can be specified without space separator." do
+        argv = ["-hfabc.png", "xx"]
+        d = @parser.parse(argv)
+        ok {d} == {help: true, file: "abc.png"}
+        ok {argv} == ["xx"]
+      end
+      spec "[!yjq6b] optional arg should be specified without space separator." do
+        argv = ["-hi123", "xx"]
+        d = @parser.parse(argv)
+        ok {d} == {help: true, indent: 123}
+        ok {argv} == ['xx']
+      end
+      spec "[!wape4] otpional arg can be omit." do
+        argv = ["-hi", "xx"]
+        d = @parser.parse(argv)
+        ok {d} == {help: true, indent: true}
+        ok {argv} == ['xx']
+      end
+      spec "[!yu0kc] validates short option argument." do
+        argv = ["-iaaa"]
+        pr = proc { @parser.parse(argv) }
+        ok {pr}.raise?(Benry::CmdOpt::OptionError, "-iaaa: Integer expected.")
+        #
+        argv = ["-I", "/foo/bar"]
+        pr = proc { @parser.parse(argv) }
+        ok {pr}.raise?(Benry::CmdOpt::OptionError, "-I /foo/bar: Directory not exist.")
+      end
     end
-    it "[!t4elj] raises error when faield to convert value into float." do
-      pr = proc { @parser.parse(['-r', 'abc']) }
-      ok {pr}.raise?(Benry::Cmdopt::OptionError, "-r abc: float expected.")
-      #
-      pr = proc { @parser.parse(['--ratio=abc']) }
-      ok {pr}.raise?(Benry::Cmdopt::OptionError, "--ratio=abc: float expected.")
+    topic '#new_options_dict()' do
+      spec "[!vm6h0] returns new hash object." do
+        parser = Benry::CmdOpt::Parser.new(new_sample_schema())
+        ret = parser.__send__(:new_options_dict)
+        ok {ret}.is_a?(Hash)
+        ok {ret} == {}
+      end
     end
-  end
+    topic '#handle_unknown_long_option()' do
+      spec "[!0q78a] raises OptionError." do
+        parser = Benry::CmdOpt::Parser.new(new_sample_schema())
+        pr = proc {
+          parser.__send__(:handle_unknown_long_option, "--xx=XX", "xx", "XX")
+        }
+        ok {pr}.raise?(Benry::CmdOpt::OptionError, "--xx=XX: Unknown long option.")
+      end
-  describe 'PARAM_TYPES[TrueClass]' do
-    before do
-      sc = Benry::Cmdopt::Schema.new
-      sc.add(:border  , "-b, --border[=<on|off>]", "enable border", type: TrueClass)
-      @parser = Benry::Cmdopt::Parser.new(sc)
-    end
-    it "[!47kx4] converts 'true'/'on'/'yes' into true." do
-      d = @parser.parse(["-btrue"])
-      ok {d} == {border: true}
-      d = @parser.parse(["-bon"])
-      ok {d} == {border: true}
-      d = @parser.parse(["-byes"])
-      ok {d} == {border: true}
-      #
-      d = @parser.parse(["--border=true"])
-      ok {d} == {border: true}
-      d = @parser.parse(["--border=on"])
-      ok {d} == {border: true}
-      d = @parser.parse(["--border=yes"])
-      ok {d} == {border: true}
-    end
-    it "[!3n810] converts 'false'/'off'/'no' into false." do
-      d = @parser.parse(["-bfalse"])
-      ok {d} == {border: false}
-      d = @parser.parse(["-boff"])
-      ok {d} == {border: false}
-      d = @parser.parse(["-bno"])
-      ok {d} == {border: false}
-      #
-      d = @parser.parse(["--border=false"])
-      ok {d} == {border: false}
-      d = @parser.parse(["--border=off"])
-      ok {d} == {border: false}
-      d = @parser.parse(["--border=no"])
-      ok {d} == {border: false}
-    end
-    it "[!h8ayh] raises error when failed to convert value into true nor false." do
-      pr = proc { @parser.parse(["-bt"]) }
-      ok {pr}.raise?(Benry::Cmdopt::OptionError,
-                     "-bt: boolean expected.")
-      #
-      pr = proc { @parser.parse(["--border=t"]) }
-      ok {pr}.raise?(Benry::Cmdopt::OptionError,
-                     "--border=t: boolean expected.")
     end
   end
-  describe 'PARAM_TYPES[Date]' do
-    before do
-      require 'date'
-      sc = Benry::Cmdopt::Schema.new
-      sc.add(:date, "-d, --date=<YYYY-MM-DD>]", "date", type: Date)
-      @parser = Benry::Cmdopt::Parser.new(sc)
-    end
+  topic Benry::CmdOpt do
-    it "[!sru5j] converts 'YYYY-MM-DD' into date object." do
-      d = @parser.parse(['-d', '2000-01-01'])
-      ok {d[:date]} == Date.new(2000, 1, 1)
-      #
-      d = @parser.parse(['--date=2000-1-2'])
-      ok {d[:date]} == Date.new(2000, 1, 2)
-    end
-    it "[!h9q9y] raises error when failed to convert into date object." do
-      pr = proc { @parser.parse(['-d', '2000/01/01']) }
-      ok {pr}.raise?(Benry::Cmdopt::OptionError,
-                     "-d 2000/01/01: invalid date format (ex: '2000-01-01')")
-      #
-      pr = proc { @parser.parse(['--date=01-01-2000']) }
-      ok {pr}.raise?(Benry::Cmdopt::OptionError,
-                     "--date=01-01-2000: invalid date format (ex: '2000-01-01')")
+    topic 'PARAM_TYPES[Integer]' do
+      before do
+        sc = Benry::CmdOpt::Schema.new
+        sc.add(:indent, "-i, --indent[=<N>]", "indent width", type: Integer)
+        @parser = Benry::CmdOpt::Parser.new(sc)
+      end
+      spec "[!6t8cs] converts value into integer." do
+        d = @parser.parse(['-i20'])
+        ok {d[:indent]} == 20
+        #
+        d = @parser.parse(['--indent=12'])
+        ok {d[:indent]} == 12
+      end
+      spec "[!nzwc9] raises error when failed to convert value into integer." do
+        pr = proc { @parser.parse(['-i2.1']) }
+        ok {pr}.raise?(Benry::CmdOpt::OptionError, "-i2.1: Integer expected.")
+        #
+        pr = proc { @parser.parse(['--indent=2.2']) }
+        ok {pr}.raise?(Benry::CmdOpt::OptionError, "--indent=2.2: Integer expected.")
+      end
     end
-    it "[!i4ui8] raises error when specified date not exist." do
-      pr = proc { @parser.parse(['-d', '2001-02-29']) }
-      ok {pr}.raise?(Benry::Cmdopt::OptionError,
-                     "-d 2001-02-29: date not exist.")
-      #
-      pr = proc { @parser.parse(['--date=2001-02-29']) }
-      ok {pr}.raise?(Benry::Cmdopt::OptionError,
-                     "--date=2001-02-29: date not exist.")
+    topic 'PARAM_TYPES[Float]' do
+      before do
+        sc = Benry::CmdOpt::Schema.new
+        sc.add(:ratio, "-r, --ratio=<RATIO>", "ratio", type: Float)
+        @parser = Benry::CmdOpt::Parser.new(sc)
+      end
+      spec "[!gggy6] converts value into float." do
+        d = @parser.parse(['-r', '1.25'])
+        ok {d[:ratio]} == 1.25
+        #
+        d = @parser.parse(['--ratio=1.25'])
+        ok {d[:ratio]} == 1.25
+      end
+      spec "[!t4elj] raises error when faield to convert value into float." do
+        pr = proc { @parser.parse(['-r', 'abc']) }
+        ok {pr}.raise?(Benry::CmdOpt::OptionError, "-r abc: Float expected.")
+        #
+        pr = proc { @parser.parse(['--ratio=abc']) }
+        ok {pr}.raise?(Benry::CmdOpt::OptionError, "--ratio=abc: Float expected.")
+      end
     end
-  end
+    topic 'PARAM_TYPES[TrueClass]' do
+      before do
+        sc = Benry::CmdOpt::Schema.new
+        sc.add(:border  , "-b, --border[=<on|off>]", "enable border", type: TrueClass)
+        @parser = Benry::CmdOpt::Parser.new(sc)
+      end
+      spec "[!47kx4] converts 'true'/'on'/'yes' into true." do
+        d = @parser.parse(["-btrue"])
+        ok {d} == {border: true}
+        d = @parser.parse(["-bon"])
+        ok {d} == {border: true}
+        d = @parser.parse(["-byes"])
+        ok {d} == {border: true}
+        #
+        d = @parser.parse(["--border=true"])
+        ok {d} == {border: true}
+        d = @parser.parse(["--border=on"])
+        ok {d} == {border: true}
+        d = @parser.parse(["--border=yes"])
+        ok {d} == {border: true}
+      end
+      spec "[!3n810] converts 'false'/'off'/'no' into false." do
+        d = @parser.parse(["-bfalse"])
+        ok {d} == {border: false}
+        d = @parser.parse(["-boff"])
+        ok {d} == {border: false}
+        d = @parser.parse(["-bno"])
+        ok {d} == {border: false}
+        #
+        d = @parser.parse(["--border=false"])
+        ok {d} == {border: false}
+        d = @parser.parse(["--border=off"])
+        ok {d} == {border: false}
+        d = @parser.parse(["--border=no"])
+        ok {d} == {border: false}
+      end
-  describe '.new()' do
+      spec "[!h8ayh] raises error when failed to convert value into true nor false." do
+        pr = proc { @parser.parse(["-bt"]) }
+        ok {pr}.raise?(Benry::CmdOpt::OptionError,
+                       "-bt: Boolean expected.")
+        #
+        pr = proc { @parser.parse(["--border=t"]) }
+        ok {pr}.raise?(Benry::CmdOpt::OptionError,
+                       "--border=t: Boolean expected.")
+      end
-    it "[!7kkqv] creates Facade object." do
-      obj = Benry::Cmdopt.new
-      ok {obj}.is_a?(Benry::Cmdopt::Facade)
     end
-  end
+    topic 'PARAM_TYPES[Date]' do
-end
+      before do
+        require 'date'
+        sc = Benry::CmdOpt::Schema.new
+        sc.add(:date, "-d, --date=<YYYY-MM-DD>]", "date", type: Date)
+        @parser = Benry::CmdOpt::Parser.new(sc)
+      end
+      spec "[!sru5j] converts 'YYYY-MM-DD' into date object." do
+        d = @parser.parse(['-d', '2000-01-01'])
+        ok {d[:date]} == Date.new(2000, 1, 1)
+        #
+        d = @parser.parse(['--date=2000-1-2'])
+        ok {d[:date]} == Date.new(2000, 1, 2)
+      end
+      spec "[!h9q9y] raises error when failed to convert into date object." do
+        pr = proc { @parser.parse(['-d', '2000/01/01']) }
+        ok {pr}.raise?(Benry::CmdOpt::OptionError,
+                       "-d 2000/01/01: Invalid date format (ex: '2000-01-01')")
+        #
+        pr = proc { @parser.parse(['--date=01-01-2000']) }
+        ok {pr}.raise?(Benry::CmdOpt::OptionError,
+                       "--date=01-01-2000: Invalid date format (ex: '2000-01-01')")
+      end
+      spec "[!i4ui8] raises error when specified date not exist." do
+        pr = proc { @parser.parse(['-d', '2001-02-29']) }
+        ok {pr}.raise?(Benry::CmdOpt::OptionError,
+                       "-d 2001-02-29: Date not exist.")
+        #
+        pr = proc { @parser.parse(['--date=2001-02-29']) }
+        ok {pr}.raise?(Benry::CmdOpt::OptionError,
+                       "--date=2001-02-29: Date not exist.")
+      end
+    end
-class Benry::Cmdopt::Facade::Test < MiniTest::Test
+    topic '.new()' do
-  describe '#add()' do
+      spec "[!7kkqv] creates Facade object." do
+        obj = Benry::CmdOpt.new
+        ok {obj}.is_a?(Benry::CmdOpt::Facade)
+      end
-    it "[!vmb3r] defines command option." do
-      cmdopt = Benry::Cmdopt.new()
-      cmdopt.add(:help, "-h, --help", "show help message")
-      items = cmdopt.instance_eval { @schema.instance_variable_get('@items') }
-      ok {items}.is_a?(Array)
-      ok {items.length} == 1
-      ok {items[0].key} == :help
-      ok {items[0].short} == 'h'
-      ok {items[0].long} == 'help'
-      ok {items[0].help} == 'show help message'
     end
   end
-  describe '#build_option_help()' do
-    before do
-      @cmdopt = Benry::Cmdopt.new
-      @cmdopt.add(:help   , "-h, --help"        , "show help message")
-      @cmdopt.add(:version, "    --version"     , "print version")
-      @cmdopt.add(:file   , "-f, --file=<FILE>" , "filename")
+  topic Benry::CmdOpt::Facade do
+    topic '#add()' do
+      spec "[!vmb3r] defines command option." do
+        cmdopt = Benry::CmdOpt.new()
+        cmdopt.add(:help, "-h, --help", "show help message", detail: "(text)", tag: :important)
+        items = cmdopt.instance_eval { @schema.instance_variable_get('@items') }
+        ok {items}.is_a?(Array)
+        ok {items.length} == 1
+        ok {items[0].key} == :help
+        ok {items[0].short} == 'h'
+        ok {items[0].long} == 'help'
+        ok {items[0].desc} == 'show help message'
+        ok {items[0].detail} == '(text)'
+        ok {items[0].tag} == :important
+      end
+      spec "[!71cvg] type, rexp, enum, and range are can be passed as positional args as well as keyword args." do
+        cmdopt = Benry::CmdOpt.new()
+        cmdopt.add(:key, "--optdef[=xx]", "desc", Integer, /\A\d+\z/, [2,4,8], (2..8), value: 4)
+        items = cmdopt.instance_eval { @schema.instance_variable_get('@items') }
+        item = items.first
+        ok {item.type} == Integer
+        ok {item.rexp} == /\A\d+\z/
+        ok {item.enum} == [2,4,8]
+        ok {item.range} == (2..8)
+        ok {item.value} == 4
+      end
     end
-    it "[!dm4p8] returns option help message." do
-      help = @cmdopt.build_option_help()
-      ok {help} == <<END
+    topic '#option_help()' do
+      before do
+        @cmdopt = Benry::CmdOpt.new
+        @cmdopt.add(:help   , "-h, --help"        , "show help message")
+        @cmdopt.add(:version, "    --version"     , "print version")
+        @cmdopt.add(:file   , "-f, --file=<FILE>" , "filename")
+      end
+      spec "[!dm4p8] returns option help message." do
+        helpmsg = @cmdopt.option_help()
+        ok {helpmsg} == <<END
   -h, --help           : show help message
       --version        : print version
   -f, --file=<FILE>    : filename
 END
+      end
     end
-  end
+    topic '#to_s()' do
-  describe '#each_option_help()' do
+      spec "[!s61vo] '#to_s' is an alias to '#option_help()'." do
+        cmdopt = Benry::CmdOpt.new
+        cmdopt.add(:help   , "-h, --help"        , "show help message")
+        cmdopt.add(:version, "    --version"     , "print version")
+        ok {cmdopt.to_s} == cmdopt.option_help()
+      end
-    before do
-      @cmdopt = Benry::Cmdopt.new
-      @cmdopt.add(:help   , "-h, --help"        , "show help message")
-      @cmdopt.add(:version, "    --version"     , "print version")
-      @cmdopt.add(:file   , "-f, --file=<FILE>" , "filename")
     end
-    it "[!bw9qx] yields each option definition string and help message." do
-      cmdopt = @cmdopt
-      pairs = []
-      cmdopt.each_option_help do |opt, help|
-        pairs << [opt, help]
+    topic '#each_option_and_desc()' do
+      before do
+        @cmdopt = Benry::CmdOpt.new
+        @cmdopt.add(:help   , "-h, --help"        , "show help message")
+        @cmdopt.add(:version, "    --version"     , "print version")
+        @cmdopt.add(:debug  , "-D"                , nil)       # hidden option
+        @cmdopt.add(:_trace , "-T"                , "trace")   # hidden option
+      end
+      spec "[!bw9qx] yields each option definition string and help message." do
+        pairs = []
+        @cmdopt.each_option_and_desc {|opt, desc| pairs << [opt, desc] }
+        ok {pairs} == [
+          ["-h, --help"   , "show help message"],
+          ["    --version", "print version"],
+        ]
+      end
+      spec "[!kunfw] yields all items (including hidden items) if `all: true` specified." do
+        ## when 'all: true'
+        pairs = []
+        @cmdopt.each_option_and_desc(all: true) {|opt, desc| pairs << [opt, desc] }
+        ok {pairs} == [
+          ["-h, --help"   , "show help message"],
+          ["    --version", "print version"],
+          ["-D"           , nil],
+          ["-T"           , "trace"],
+        ]
+        ## when 'all: false'
+        pairs = []
+        @cmdopt.each_option_and_desc(all: false) {|opt, desc| pairs << [opt, desc] }
+        ok {pairs} == [
+          ["-h, --help"   , "show help message"],
+          ["    --version", "print version"],
+        ]
+      end
+      spec "[!wght5] returns enumerator object if block not given." do
+        ## when 'all: true'
+        xs = @cmdopt.each_option_and_desc(all: true)
+        ok {xs}.is_a?(Enumerator)
+        ok {xs.collect {|x, _| x }} == ["-h, --help", "    --version", "-D", "-T"]
+        ## when 'all: false'
+        xs = @cmdopt.each_option_and_desc(all: false)
+        ok {xs}.is_a?(Enumerator)
+        ok {xs.collect {|x, _| x }} == ["-h, --help", "    --version"]
       end
-      ok {pairs} == [
-        ["-h, --help", "show help message"],
-        ["    --version", "print version"],
-        ["-f, --file=<FILE>", "filename"],
-      ]
     end
-  end
+    topic '#parse()' do
-  describe '#parse_options()' do
+      before do
+        @cmdopt = Benry::CmdOpt.new()
+        @cmdopt.add(:file, "-f, --file=<FILE>", "file") do |val|
+          File.open(val) {|f| f.read }
+        end
+        @cmdopt.add(:debug, "-d, --debug[=<LEVEL>]", "debug", type: Integer)
+      end
-    before do
-      @cmdopt = Benry::Cmdopt.new()
-      @cmdopt.add(:file, "-f, --file=<FILE>", "file") do |val|
-        File.open(val) {|f| f.read }
+      spec "[!areof] handles only OptionError when block given." do
+        errmsg = nil
+        errcls = nil
+        @cmdopt.parse(["-dx"]) {|err|
+          errmsg = err.message
+          errcls = err.class
+        }
+        ok {errmsg} == "-dx: Integer expected."
+        ok {errcls} == Benry::CmdOpt::OptionError
+        #
+        pr = proc do
+          @cmdopt.parse(["-f", "/foo/bar/baz.png"])
+        end
+        ok {pr}.raise?(Errno::ENOENT, /No such file or directory/)
       end
-      @cmdopt.add(:file, "-d, --debug[=<LEVEL>]", "debug", type: Integer)
-    end
-    it "[!areof] handles only OptionError when block given." do
-      errmsg = nil
-      errcls = nil
-      @cmdopt.parse(["-dx"]) {|err|
-        errmsg = err.message
-        errcls = err.class
-      }
-      ok {errmsg} == "-dx: integer expected."
-      ok {errcls} == Benry::Cmdopt::OptionError
-      #
-      pr = proc do
-        @cmdopt.parse(["-f", "/foo/bar/baz.png"])
+      spec "[!peuva] returns nil when OptionError handled." do
+        ret = @cmdopt.parse(["-dx"]) {|err| 1 }
+        ok {ret} == nil
+      end
+      spec "[!za9at] parses options only before args when `all: false`." do
+        argv = ["aaa", "-d3", "bbb"]
+        #
+        argv1 = argv.dup
+        opts1 = @cmdopt.parse(argv1)
+        ok {opts1} == {:debug=>3}
+        ok {argv1} == ["aaa", "bbb"]
+        #
+        argv2 = argv.dup
+        opts2 = @cmdopt.parse(argv2, all: false)
+        ok {opts2} == {}
+        ok {argv2} == ["aaa", "-d3", "bbb"]
       end
-      ok {pr}.raise?(Errno::ENOENT, /No such file or directory/)
-    end
-    it "[!peuva] returns nil when OptionError handled." do
-      ret = @cmdopt.parse(["-dx"]) {|err| 1 }
-      ok {ret} == nil
     end
   end