gli_aziz_light 2.8.1

data/test/tc_compound_command.rb

@@ -0,0 +1,22 @@
+require 'test_helper'
+require 'tempfile'
+
+class TC_testCompounCommand < Clean::Test::TestCase
+  include TestHelper
+
+  test_that "when we create a CompoundCommand where some commands are missing, we get an exception" do
+    Given {
+      @name = any_string
+      @unknown_name = any_string
+      @existing_command = OpenStruct.new(:name => @name)
+      @base = OpenStruct.new( :commands => { @name => @existing_command })
+    }
+    When {
+      @code = lambda { GLI::Commands::CompoundCommand.new(@base,{:foo => [@name,@unknown_name]}) }
+    }
+    Then {
+      ex = assert_raises(RuntimeError,&@code)
+      assert_match /#{@unknown_name}/,ex.message
+    }
+  end
+end

data/test/tc_doc.rb

@@ -0,0 +1,325 @@
+require 'test_helper'
+require 'pp'
+
+class String
+  def blank?
+    self.strip.length == 0
+  end
+end
+
+class NilClass
+  def blank?
+    true
+  end
+end
+
+class Object
+  def blank?
+    false
+  end
+end
+
+class TC_testDoc < Clean::Test::TestCase
+  include TestHelper
+
+  class TestApp
+    include GLI::App
+  end
+
+  class TestListener
+    @@last = nil
+    def self.last
+      @@last
+    end
+    def initialize(*ignored)
+      @stringio = StringIO.new
+      @indent = ''
+      @@last = self
+    end
+    def options
+    end
+    def end_options
+    end
+    def commands
+    end
+    def end_commands
+    end
+    def beginning
+      @stringio << 'BEGIN' << "\n"
+    end
+
+    def ending
+      @stringio << 'END' << "\n"
+    end
+
+    def program_desc(desc)
+      @stringio << desc << "\n"
+    end
+
+    def program_long_desc(desc)
+      @stringio << desc << "\n"
+    end
+
+    def version(version)
+      @stringio << version << "\n"
+    end
+
+    def default_command(name)
+      @stringio << @indent << "default_command: " << name << "\n"
+    end
+
+    def flag(name,aliases,desc,long_desc,default_value,arg_name,must_match,type)
+      @stringio << @indent << "flag: " << name << "\n"
+      @indent += '  '
+      @stringio << @indent << "aliases: " << aliases.join(',') << "\n"   unless aliases.empty?
+      @stringio << @indent << "desc: " << desc << "\n"                   unless desc.blank?
+      @stringio << @indent << "long_desc: " << long_desc << "\n"         unless long_desc.blank?
+      @stringio << @indent << "default_value: " << default_value << "\n" unless default_value.blank?
+      @stringio << @indent << "arg_name: " << arg_name << "\n"           unless arg_name.blank?
+      @indent.gsub!(/  $/,'')
+    end
+
+    def switch(name,aliases,desc,long_desc,negatable)
+      @stringio << @indent << "switch: " << name << "\n"
+      @indent += '  '
+      @stringio << @indent << "aliases: " << aliases.join(',') << "\n"   unless aliases.empty?
+      @stringio << @indent << "desc: " << desc << "\n"                   unless desc.blank?
+      @stringio << @indent << "long_desc: " << long_desc << "\n"         unless long_desc.blank?
+      @stringio << @indent << "negatable: " << negatable << "\n"         unless negatable.blank?
+      @indent.gsub!(/  $/,'')
+    end
+
+    def command(name,aliases,desc,long_desc,arg_name)
+      @stringio << @indent << "command: " << name << "\n"
+      @indent += '  '
+      @stringio << @indent << "aliases: " << aliases.join(',') << "\n"   unless aliases.empty?
+      @stringio << @indent << "desc: " << desc << "\n"                   unless desc.blank?
+      @stringio << @indent << "long_desc: " << long_desc << "\n"         unless long_desc.blank?
+      @stringio << @indent << "arg_name: " << arg_name << "\n"           unless arg_name.blank?
+    end
+
+    def end_command(name)
+      @indent.gsub!(/  $/,'')
+      @stringio << @indent << "end #{name}" << "\n"
+    end
+
+    def to_s
+      @stringio.string
+    end
+  end
+
+  def setup
+    @@counter = -1 # we pre-increment so this makes 0 first
+  end
+
+  test_that "a GLI app with documentation gets the callbacks for each element" do
+    Given :the_test_app
+    And :the_expected_output
+    And {
+      @documenter = GLI::Commands::Doc.new(@app)
+      @listener = TestListener.new
+    }
+    When {
+      @documenter.document(@listener)
+    }
+    Then {
+      lines_expected = @string.split(/\n/)
+      lines_got = @listener.to_s.split(/\n/)
+      lines_expected.zip(lines_got).each_with_index do |(expected,got),index|
+        assert_equal expected,got,"At index #{index}"
+      end
+    }
+  end
+
+  test_that "the doc command works as a GLI command" do
+    Given :the_test_app
+    And :the_expected_output
+    And {
+      @documenter = GLI::Commands::Doc.new(@app)
+      @listener = TestListener.new
+    }
+    When {
+      @documenter.execute({},{:format => "TC_testDoc::TestListener"},[])
+    }
+    Then {
+      lines_expected = @string.split(/\n/)
+      lines_got = TestListener.last.to_s.split(/\n/)
+      lines_expected.zip(lines_got).each_with_index do |(expected,got),index|
+        assert_equal expected,got,"At index #{index}"
+      end
+    }
+  end
+
+private
+
+  @@counter = 1
+  def self.counter
+    @@counter += 1
+    @@counter
+  end
+
+  def the_test_app
+    @app = TestApp.new
+    @app.instance_eval do
+      program_desc "program desc"
+      program_long_desc "program long desc"
+      version "1.3.4"
+
+      TC_testDoc.flag_with_everything_specified(self)
+      TC_testDoc.flag_with_everything_omitted(self)
+      TC_testDoc.switch_with_everything_specified(self)
+      TC_testDoc.switch_with_everything_omitted(self)
+
+      desc      "command desc"
+      long_desc "command long desc"
+      arg_name  "cmd_arg_name"
+      command [:command1,:com1] do |c|
+        TC_testDoc.flag_with_everything_specified(c)
+        TC_testDoc.flag_with_everything_omitted(c)
+        TC_testDoc.switch_with_everything_specified(c)
+        TC_testDoc.switch_with_everything_omitted(c)
+
+        c.desc      "subcommand desc"
+        c.long_desc "subcommand long desc"
+        c.arg_name  "subcmd_arg_name"
+        c.action { |g,o,a| }
+        c.command [:sub,:subcommand] do |sub|
+          TC_testDoc.flag_with_everything_specified(sub,:subflag)
+          TC_testDoc.flag_with_everything_omitted(sub,:subflag2)
+          TC_testDoc.switch_with_everything_specified(sub,:subswitch)
+          TC_testDoc.switch_with_everything_omitted(sub,:subswitch2)
+          sub.action { |g,o,a| }
+        end
+        c.command [:default] do |sub|
+          sub.action { |g,o,a| }
+        end
+        c.default_command :default
+      end
+
+      command [:command2,:com2] do |c|
+        c.action { |g,o,a| }
+        c.command [:sub2,:subcommand2] do |sub|
+          sub.action { |g,o,a| }
+        end
+      end
+    end
+  end
+
+  def self.flag_with_everything_specified(on,name=[:f,:flag])
+    on.flag name,:desc          => "flag desc #{counter}",
+                 :long_desc     => "flag long_desc #{counter}",
+                 :default_value => "flag default_value #{counter}",
+                 :arg_name      => "flag_arg_name_#{counter}",
+                 :must_match    => /foo.*bar/,
+                 :type          => Array
+  end
+
+  def self.flag_with_everything_omitted(on,name=[:F,:flag2])
+    on.flag name
+  end
+
+  def self.switch_with_everything_specified(on,name=[:s,:switch])
+    on.switch name, :desc      => "switch desc #{counter}",
+                    :long_desc => "switch long_desc #{counter}",
+                    :negatable => false
+  end
+
+  def self.switch_with_everything_omitted(on,name=[:S,:switch2])
+    on.switch name
+  end
+  def the_expected_output
+    # Oh yeah.  Creating a string representing the structure of the calls.
+    @string =<<EOS
+BEGIN
+program desc
+program long desc
+1.3.4
+flag: F
+  aliases: flag2
+  arg_name: arg
+flag: f
+  aliases: flag
+  desc: flag desc 0
+  long_desc: flag long_desc 1
+  default_value: flag default_value 2
+  arg_name: flag_arg_name_3
+switch: S
+  aliases: switch2
+  negatable: true
+switch: s
+  aliases: switch
+  desc: switch desc 4
+  long_desc: switch long_desc 5
+  negatable: false
+switch: version
+  desc: Display the program version
+  negatable: false
+command: command1
+  aliases: com1
+  desc: command desc
+  long_desc: command long desc
+  arg_name: cmd_arg_name
+  flag: F
+    aliases: flag2
+    arg_name: arg
+  flag: f
+    aliases: flag
+    desc: flag desc 6
+    long_desc: flag long_desc 7
+    default_value: flag default_value 8
+    arg_name: flag_arg_name_9
+  switch: S
+    aliases: switch2
+    negatable: true
+  switch: s
+    aliases: switch
+    desc: switch desc 10
+    long_desc: switch long_desc 11
+    negatable: false
+  command: default
+    default_command: 
+  end default
+  command: sub
+    aliases: subcommand
+    desc: subcommand desc
+    long_desc: subcommand long desc
+    arg_name: subcmd_arg_name
+    flag: subflag
+      desc: flag desc 12
+      long_desc: flag long_desc 13
+      default_value: flag default_value 14
+      arg_name: flag_arg_name_15
+    flag: subflag2
+      arg_name: arg
+    switch: subswitch
+      desc: switch desc 16
+      long_desc: switch long_desc 17
+      negatable: false
+    switch: subswitch2
+      negatable: true
+    default_command: 
+  end sub
+  default_command: default
+end command1
+command: command2
+  aliases: com2
+  command: sub2
+    aliases: subcommand2
+    default_command: 
+  end sub2
+  default_command: 
+end command2
+command: help
+  desc: Shows a list of commands or help for one command
+  long_desc: Gets help for the application or its commands. Can also list the commands in a way helpful to creating a bash-style completion function
+  arg_name: command
+  switch: c
+    desc: List commands one per line, to assist with shell completion
+    negatable: true
+  default_command: 
+end help
+default_command: 
+END
+EOS
+  end
+end

data/test/tc_flag.rb

@@ -0,0 +1,62 @@
+require 'test_helper'
+
+class TC_testFlag < Clean::Test::TestCase
+  include TestHelper
+
+  def test_basics_simple
+    Given flag_with_names(:f)
+    Then attributes_should_be_set
+    And name_should_be(:f)
+    And aliases_should_be(nil)
+  end
+
+  def test_basics_kinda_complex
+    Given flag_with_names([:f])
+    Then attributes_should_be_set
+    And name_should_be(:f)
+    And aliases_should_be(nil)
+  end
+
+  def test_basics_complex
+    Given flag_with_names([:f,:file,:filename])
+    Then attributes_should_be_set
+    And name_should_be(:f)
+    And aliases_should_be([:file,:filename])
+    And {
+      assert_equal ["-f VAL","--file VAL","--filename VAL",/foobar/,Float],@flag.arguments_for_option_parser
+    }
+  end
+
+  def test_flag_can_mask_its_value
+    Given flag_with_names(:password, :mask => true)
+    Then attributes_should_be_set(:safe_default_value => "********")
+  end
+
+  def flag_with_names(names,options = {})
+    lambda do
+      @options = {
+        :desc => 'Filename',
+        :long_desc => 'The Filename',
+        :arg_name => 'file',
+        :default_value => '~/.blah.rc',
+        :safe_default_value => '~/.blah.rc',
+        :must_match => /foobar/,
+        :type => Float,
+      }.merge(options)
+      @flag = GLI::Flag.new(names,@options)
+      @cli_option = @flag
+    end
+  end
+
+  def attributes_should_be_set(override={})
+    lambda {
+      expected = @options.merge(override)
+      assert_equal(expected[:desc],@flag.description)
+      assert_equal(expected[:long_desc],@flag.long_description)
+      assert_equal(expected[:default_value],@flag.default_value)
+      assert_equal(expected[:safe_default_value],@flag.safe_default_value)
+      assert_equal(expected[:must_match],@flag.must_match)
+      assert_equal(expected[:type],@flag.type)
+    }
+  end
+end

data/test/tc_gli.rb

@@ -0,0 +1,773 @@
+# 1.9 adds realpath to resolve symlinks; 1.8 doesn't
+# have this method, so we add it so we get resolved symlinks
+# and compatibility
+unless File.respond_to? :realpath
+  class File
+    def self.realpath path
+      return realpath(File.readlink(path)) if symlink?(path)
+      path
+    end
+  end
+end
+
+require 'test_helper'
+
+class TC_testGLI < Clean::Test::TestCase
+  include TestHelper
+
+  def setup
+    @fake_stdout = FakeStdOut.new
+    @fake_stderr = FakeStdOut.new
+    @original_stdout = $stdout
+    $stdout = @fake_stdout
+    @original_stderr = $stderr
+    $stderr = @fake_stderr
+    @app = CLIApp.new
+
+    @config_file = File.expand_path(File.dirname(File.realpath(__FILE__)) + '/new_config.yaml')
+    @gli_debug = ENV['GLI_DEBUG']
+    @app.error_device=@fake_stderr
+    ENV.delete('GLI_DEBUG')
+  end
+
+  def teardown
+    File.delete(@config_file) if File.exist?(@config_file)
+    ENV['GLI_DEBUG'] = @gli_debug
+    @app.error_device=$stderr
+    $stdout = @original_stdout
+    $stderr = @original_stderr
+  end
+
+  def test_flag_create
+    @app.reset
+    do_test_flag_create(@app)
+    do_test_flag_create(GLI::Command.new(:names => :f))
+  end
+
+  def test_create_commands_using_strings
+    @app.reset
+    @app.flag ['f','flag']
+    @app.switch ['s','some-switch']
+    @app.command 'command','command-with-dash' do |c|
+    end
+    assert @app.commands.include? :command
+    assert @app.flags.include? :f
+    assert @app.switches.include? :s
+    assert @app.commands[:command].aliases.include? :'command-with-dash'
+    assert @app.flags[:f].aliases.include? :flag
+    assert @app.switches[:s].aliases.include? :'some-switch'
+  end
+
+  def test_default_command
+    @app.reset
+    @called = false
+    @app.command :foo do |c|
+      c.action do |global, options, arguments|
+        @called = true
+      end
+    end
+    @app.default_command(:foo)
+    assert_equal 0, @app.run([]), "Expected exit status to be 0"
+    assert @called, "Expected default command to be executed"
+  end
+
+  def test_flag_with_space_barfs
+    @app.reset
+    assert_raises(ArgumentError) { @app.flag ['some flag'] }
+    assert_raises(ArgumentError) { @app.flag ['f','some flag'] }
+    assert_raises(ArgumentError) { @app.switch ['some switch'] }
+    assert_raises(ArgumentError) { @app.switch ['f','some switch'] }
+    assert_raises(ArgumentError) { @app.command ['some command'] }
+    assert_raises(ArgumentError) { @app.command ['f','some command'] }
+  end
+
+  def test_command_line_stored_separately
+    failure = nil
+    @app.reset
+    @app.flag :f
+    @app.switch :s
+    @app.flag :g
+    @app.switch :bleorgh
+    called = false
+    @app.command :command do |c|
+      c.flag :f
+      c.switch :s
+      c.flag :g
+      c.action do |g,o,a|
+        begin
+          called = true
+          assert_equal "bar",g[:cli][:f]
+          assert !g[:cli][:bleorgh]
+          assert_equal "baaz",o[:cli][:g]
+        rescue Exception => ex
+          failure = ex
+        end
+      end
+    end
+    assert_equal 0,@app.run(%w(-f bar --no-bleorgh command -g baaz)),@fake_stderr.to_s
+    assert_equal "bar",@app.options[:global][:f]
+    assert !@app.options[:global][:bleorgh]
+    assert called
+    raise failure if !failure.nil?
+  end
+
+  def test_init_from_config
+    failure = nil
+    @app.reset
+    @app.config_file(File.expand_path(File.dirname(File.realpath(__FILE__)) + '/config.yaml'))
+    @app.flag :f
+    @app.switch :s
+    @app.flag :g
+    called = false
+    @app.command :command do |c|
+      c.flag :f
+      c.switch :s
+      c.flag :g
+      c.action do |g,o,a|
+        begin
+          called = true
+          assert_equal "foo",g[:f]
+          assert_equal "bar",o[:g]
+          assert !g[:g]
+          assert !o[:f]
+          assert !g[:s]
+          assert o[:s]
+        rescue Exception => ex
+          failure = ex
+        end
+      end
+    end
+    @app.run(['command'])
+    assert called
+    raise failure if !failure.nil?
+  end
+
+  def test_command_line_overrides_config
+    failure = nil
+    @app.reset
+    @app.config_file(File.expand_path(File.dirname(File.realpath(__FILE__)) + '/config.yaml'))
+    @app.flag :f
+    @app.switch :s
+    @app.flag :g
+    @app.switch :bleorgh
+    called = false
+    @app.command :command do |c|
+      c.flag :f
+      c.switch :s
+      c.flag :g
+      c.action do |g,o,a|
+        begin
+          called = true
+          assert_equal "baaz",o[:g]
+          assert_equal "bar",g[:f]
+          assert !g[:g],o.inspect
+          assert !o[:f],o.inspect
+          assert !g[:s],o.inspect
+          assert o[:s],o.inspect
+          assert g[:bleorgh] != nil,"Expected :bleorgh to have a value"
+          assert g[:bleorgh] == false,"Expected :bleorgh to be false"
+        rescue Exception => ex
+          failure = ex
+        end
+      end
+    end
+    assert_equal 0,@app.run(%w(-f bar --no-bleorgh command -g baaz)),@fake_stderr.to_s
+    assert called
+    raise failure if !failure.nil?
+  end
+
+  def test_no_overwrite_config
+    config_file = File.expand_path(File.dirname(File.realpath(__FILE__)) + '/config.yaml')
+    config_file_contents = File.read(config_file)
+    @app.reset
+    @app.config_file(config_file)
+    assert_equal 1,@app.run(['initconfig'])
+    assert @fake_stderr.strings.grep(/--force/),@fake_stderr.strings.inspect
+    assert !@fake_stdout.contained?(/written/), @fake_stdout.strings.inspect
+    config_file_contents_after = File.read(config_file)
+    assert_equal(config_file_contents,config_file_contents_after)
+  end
+
+  def test_config_file_name
+    @app.reset
+    file = @app.config_file("foo")
+    assert_equal(Etc.getpwuid.dir + "/foo",file)
+    file = @app.config_file("/foo")
+    assert_equal "/foo",file
+    init_command = @app.commands[:initconfig]
+    assert init_command
+  end
+
+  def test_initconfig_command
+    @app.reset
+    @app.config_file(@config_file)
+    @app.flag :f
+    @app.switch :s
+    @app.switch :w
+    @app.flag :bigflag
+    @app.flag :biggestflag
+    @app.command :foo do |c|
+    end
+    @app.command :bar do |c|
+    end
+    @app.command :blah do |c|
+    end
+    @app.on_error do |ex|
+      raise ex
+    end
+    @app.run(['-f','foo','-s','--bigflag=bleorgh','initconfig'])
+    assert @fake_stdout.contained?(/written/), @fake_stdout.strings.inspect
+
+    written_config = File.open(@config_file) { |f| YAML::load(f) }
+
+    assert_equal 'foo',written_config[:f]
+    assert_equal 'bleorgh',written_config[:bigflag]
+    assert written_config[:s]
+    assert !written_config[:w]
+    assert_nil written_config[:biggestflag]
+    assert written_config[GLI::InitConfig::COMMANDS_KEY]
+    assert written_config[GLI::InitConfig::COMMANDS_KEY][:foo]
+    assert written_config[GLI::InitConfig::COMMANDS_KEY][:bar]
+    assert written_config[GLI::InitConfig::COMMANDS_KEY][:blah]
+
+  end
+
+  def test_initconfig_permissions
+    @app.reset
+    @app.config_file(@config_file)
+    @app.run(['initconfig'])
+    oct_mode = "%o" % File.stat(@config_file).mode
+    assert_match /0600$/, oct_mode
+  end
+
+  def do_test_flag_create(object)
+    description = 'this is a description'
+    long_desc = 'this is a very long description'
+    object.desc description
+    object.long_desc long_desc
+    object.arg_name 'filename'
+    object.default_value '~/.blah.rc'
+    object.flag :f
+    assert (object.flags[:f] )
+    assert_equal(description,object.flags[:f].description)
+    assert_equal(long_desc,object.flags[:f].long_description)
+    assert(nil != object.flags[:f].usage)
+    assert(object.usage != nil) if object.respond_to? :usage;
+  end
+
+  def test_switch_create
+    @app.reset
+    do_test_switch_create(@app)
+    do_test_switch_create(GLI::Command.new(:names => :f))
+  end
+
+  def test_switch_create_twice
+    @app.reset
+    do_test_switch_create_twice(@app)
+    do_test_switch_create_twice(GLI::Command.new(:names => :f))
+  end
+
+  def test_all_aliases_in_options
+    @app.reset
+    @app.on_error { |ex| raise ex }
+    @app.flag [:f,:flag,:'big-flag-name']
+    @app.switch [:s,:switch,:'big-switch-name']
+    @app.command [:com,:command] do |c|
+      c.flag [:g,:gflag]
+      c.switch [:h,:hswitch]
+      c.action do |global,options,args|
+        assert_equal 'foo',global[:f]
+        assert_equal global[:f],global[:flag]
+        assert_equal global[:f],global['f']
+        assert_equal global[:f],global['flag']
+        assert_equal global[:f],global['big-flag-name']
+        assert_equal global[:f],global[:'big-flag-name']
+
+        assert global[:s]
+        assert global[:switch]
+        assert global[:'big-switch-name']
+        assert global['s']
+        assert global['switch']
+        assert global['big-switch-name']
+
+        assert_equal 'bar',options[:g]
+        assert_equal options[:g],options['g']
+        assert_equal options[:g],options['gflag']
+        assert_equal options[:g],options[:gflag]
+
+        assert options[:h]
+        assert options['h']
+        assert options[:hswitch]
+        assert options['hswitch']
+      end
+    end
+    @app.run(%w(-f foo -s command -g bar -h some_arg))
+  end
+
+  def test_use_hash_by_default
+    @app.reset
+    @app.switch :g
+    @app.command :command do |c|
+      c.switch :f
+      c.action do |global,options,args|
+        assert_equal Hash,global.class
+        assert_equal Hash,options.class
+      end
+    end
+    @app.run(%w(-g command -f))
+  end
+
+  def test_flag_array_of_options_global
+    @app.reset
+    @app.flag :foo, :must_match => ['bar','blah','baz']
+    @app.command :command do |c|
+      c.action do
+      end
+    end
+    assert_equal 64,@app.run(%w(--foo=cruddo command)),@fake_stderr.to_s
+    assert @fake_stderr.contained?(/error: invalid argument: --foo=cruddo/),"STDERR was:\n" + @fake_stderr.to_s
+    assert_equal 0,@app.run(%w(--foo=blah command)),@fake_stderr.to_s
+  end
+
+  def test_flag_hash_of_options_global
+    @app.reset
+    @app.flag :foo, :must_match => { 'bar' => "BAR", 'blah' => "BLAH" }
+    @foo_arg_value = nil
+    @app.command :command do |c|
+      c.action do |g,o,a|
+        @foo_arg_value = g[:foo]
+      end
+    end
+    assert_equal 64,@app.run(%w(--foo=cruddo command)),@fake_stderr.to_s
+    assert @fake_stderr.contained?(/error: invalid argument: --foo=cruddo/),"STDERR was:\n" + @fake_stderr.to_s
+    assert_equal 0,@app.run(%w(--foo=blah command)),@fake_stderr.to_s
+    assert_equal 'BLAH',@foo_arg_value
+  end
+
+  def test_flag_regexp_global
+    @app.reset
+    @app.flag :foo, :must_match => /bar/
+    @app.command :command do |c|
+      c.action do
+      end
+    end
+    assert_equal 64,@app.run(%w(--foo=cruddo command)),@fake_stderr.to_s
+    assert @fake_stderr.contained?(/error: invalid argument: --foo=cruddo/),"STDERR was:\n" + @fake_stderr.to_s
+  end
+
+  def test_flag_regexp_global_short_form
+    @app.reset
+    @app.flag :f, :must_match => /bar/
+    @app.command :command do |c|
+      c.action do
+      end
+    end
+    assert_equal 64,@app.run(%w(-f cruddo command)),@fake_stderr.to_s
+    assert @fake_stderr.contained?(/error: invalid argument: -f cruddo/),"STDERR was:\n" + @fake_stderr.to_s
+  end
+
+  def test_flag_regexp_command
+    @app.reset
+    @app.command :command do |c|
+      c.flag :foo, :must_match => /bar/
+      c.action do
+      end
+    end
+    assert_equal 64,@app.run(%w(command --foo=cruddo)),@fake_stderr.to_s
+    assert @fake_stderr.contained?(/error: invalid argument: --foo=cruddo/),"STDERR was:\n" + @fake_stderr.to_s
+  end
+
+  def test_use_openstruct
+    @app.reset
+    @app.switch :g
+    @app.use_openstruct true
+    @app.command :command do |c|
+      c.switch :f
+      c.action do |global,options,args|
+        assert_equal GLI::Options,global.class
+        assert_equal GLI::Options,options.class
+      end
+    end
+    @app.run(%w(-g command -f))
+  end
+
+  def test_repeated_option_names
+    @app.reset
+    @app.on_error { |ex| raise ex }
+    @app.flag [:f,:flag]
+    assert_raises(ArgumentError) { @app.switch [:foo,:flag] }
+    assert_raises(ArgumentError) { @app.switch [:f] }
+
+    @app.switch [:x,:y]
+    assert_raises(ArgumentError) { @app.flag [:x] }
+    assert_raises(ArgumentError) { @app.flag [:y] }
+
+    # This shouldn't raise; :help is special
+    @app.switch :help
+  end
+
+  def test_repeated_option_names_on_command
+    @app.reset
+    @app.on_error { |ex| raise ex }
+    @app.command :command do |c|
+      c.flag [:f,:flag]
+      assert_raises(ArgumentError) { c.switch [:foo,:flag] }
+      assert_raises(ArgumentError) { c.switch [:f] }
+      assert_raises(ArgumentError) { c.flag [:foo,:flag] }
+      assert_raises(ArgumentError) { c.flag [:f] }
+    end
+    @app.command :command3 do |c|
+      c.switch [:s,:switch]
+      assert_raises(ArgumentError) { c.switch [:switch] }
+      assert_raises(ArgumentError) { c.switch [:s] }
+      assert_raises(ArgumentError) { c.flag [:switch] }
+      assert_raises(ArgumentError) { c.flag [:s] }
+    end
+  end
+
+  def test_two_flags
+    @app.reset
+    @app.on_error do |ex|
+      raise ex
+    end
+    @app.command [:foo] do |c|
+      c.flag :i
+      c.flag :s
+      c.action do |g,o,a|
+        assert_equal "5", o[:i]
+        assert_equal "a", o[:s]
+      end
+    end
+    @app.run(['foo', '-i','5','-s','a'])
+  end
+
+  def test_two_flags_with_a_default
+    @app.reset
+    @app.on_error do |ex|
+      raise ex
+    end
+    @app.command [:foo] do |c|
+      c.default_value "1"
+      c.flag :i
+      c.flag :s
+      c.action do |g,o,a|
+        assert_equal "1", o[:i]
+        assert_equal nil, o[:s]
+      end
+    end
+    @app.run(['foo','a'])
+  end
+
+  def test_switch_with_default_of_true
+    @app.reset
+    @app.on_error do |ex|
+      raise ex
+    end
+    @switch_value = nil
+
+    @app.command [:foo] do |c|
+      c.default_value true
+      c.switch :switch
+      c.action do |g,o,a|
+        @switch_value = o[:switch]
+      end
+    end
+    @app.run(['foo'])
+
+    assert @switch_value == true,"Got: '#{@switch_value}', but expected true"
+
+    @app.run(['foo','--no-switch'])
+
+    assert @switch_value == false,"Got: '#{@switch_value}', but expected false"
+  end
+
+  def test_switch_with_default_true_and_not_negatable_causes_exception
+    @app.reset
+    @app.on_error do |ex|
+      raise ex
+    end
+    @switch_value = nil
+
+    assert_raises(RuntimeError) do 
+      @app.command [:foo] do |c|
+        c.switch :switch, :default_value => true, :negatable => false
+      end
+    end
+  end
+
+  def test_two_flags_using_equals_with_a_default
+    @app.reset
+    @app.on_error do |ex|
+      raise ex
+    end
+    @app.command [:foo] do |c|
+      c.default_value "1"
+      c.flag :i
+      c.flag :s
+      c.action do |g,o,a|
+        assert_equal "5", o[:i],o.inspect
+        assert_equal "a", o[:s],o.inspect
+      end
+    end
+    @app.run(['foo', '-i5','-sa'])
+  end
+
+  def test_default_values_are_available_on_all_aliases
+    @app.reset
+    @app.on_error { |e| raise e }
+
+    @app.default_value "global_default"
+    @app.flag [ :f, :flag ]
+
+    @global_options = {}
+    @command_options = {}
+
+    @app.command [:foo] do |c|
+      c.default_value "command_default"
+      c.flag [ :c,:commandflag]
+
+      c.action do |g,o,a|
+        @global_options = g
+        @command_options = o
+      end
+    end
+
+    @app.run(["foo"])
+
+    assert_equal "global_default", @global_options[:f]
+    assert_equal "global_default", @global_options[:flag]
+    assert_equal "global_default", @global_options["f"]
+    assert_equal "global_default", @global_options["flag"]
+
+    assert_equal "command_default", @command_options[:c]
+    assert_equal "command_default", @command_options[:commandflag]
+    assert_equal "command_default", @command_options["c"]
+    assert_equal "command_default", @command_options["commandflag"]
+  end
+
+  def test_exits_zero_on_success
+    @app.reset
+    assert_equal 0,@app.run([]),@fake_stderr.to_s
+  end
+
+  def test_exits_nonzero_on_bad_command_line
+    @app.reset
+    @app.on_error { true }
+    assert_equal 64,@app.run(['asdfasdfasdf'])
+  end
+
+  def test_exists_nonzero_on_raise_from_command
+    @app.reset
+    @app.on_error { true }
+    @app.command(:foo) do |c|
+      c.action do |g,o,a|
+        raise "Problem"
+      end
+    end
+    assert_equal 1,@app.run(['foo'])
+  end
+
+  def test_exits_nonzero_with_custom_exception
+    @app.reset
+    @app.on_error { true }
+    @app.command(:foo) do |c|
+      c.action do |g,o,a|
+        raise GLI::CustomExit.new("Problem",45)
+      end
+    end
+    assert_equal 45,@app.run(['foo'])
+  end
+
+  def test_exits_nonzero_with_exit_method
+    @app.reset
+    @app.on_error { true }
+    @app.command(:foo) do |c|
+      c.action do |g,o,a|
+        @app.exit_now!("Problem",45)
+      end
+    end
+    assert_equal 45,@app.run(['foo'])
+  end
+
+  def test_exits_nonzero_with_exit_method_by_default
+    @app.reset
+    @app.on_error { true }
+    @app.command(:foo) do |c|
+      c.action do |g,o,a|
+        @app.exit_now!("Problem")
+      end
+    end
+    assert_equal 1,@app.run(['foo'])
+  end
+
+  def test_help_now_exits_and_shows_help
+    @app.reset
+    @app.on_error { true }
+    @app.command(:foo) do |c|
+      c.action do |g,o,a|
+        @app.help_now!("Problem")
+      end
+    end
+    assert_equal 64,@app.run(['foo']),@fake_stderr.strings.join("\n")
+  end
+
+  def test_custom_exception_causes_error_to_be_printed_to_stderr
+    @app.reset
+    @app.on_error { true }
+    error_message = "Something went wrong"
+    @app.command(:foo) do |c|
+      c.action do |g,o,a|
+        raise error_message
+      end
+    end
+    @app.run(['foo'])
+    assert @fake_stderr.strings.include?("error: #{error_message}"),"STDERR was:\n" + @fake_stderr.to_s
+  end
+
+  def test_gli_debug_overrides_error_hiding
+    ENV['GLI_DEBUG'] = 'true'
+
+    @app.reset
+    @app.on_error { true }
+    @app.command(:foo) do |c|
+      c.action do |g,o,a|
+        @app.exit_now!("Problem",45)
+      end
+    end
+
+    assert_raises(GLI::CustomExit) { @app.run(['foo']) }
+  end
+
+  class ConvertMe
+    attr_reader :value
+    def initialize(value)
+      @value = value
+    end
+  end
+
+  def test_that_we_can_add_new_casts_for_flags
+    @app.reset
+    @app.accept(ConvertMe) do |value|
+      ConvertMe.new(value)
+    end
+    @app.flag :foo, :type => ConvertMe
+
+    @foo = nil
+    @baz = nil
+
+    @app.command(:bar) do |c|
+      c.flag :baz, :type => ConvertMe
+      c.action do |g,o,a|
+        @foo = g[:foo]
+        @baz = o[:baz]
+      end
+    end
+
+    assert_equal 0,@app.run(['--foo','blah','bar','--baz=crud']),@fake_stderr.to_s
+
+    assert @foo.kind_of?(ConvertMe),"Expected a ConvertMe, but get a #{@foo.class}"
+    assert_equal 'blah',@foo.value
+
+    assert @baz.kind_of?(ConvertMe),"Expected a ConvertMe, but get a #{@foo.class}"
+    assert_equal 'crud',@baz.value
+  end
+
+  def test_that_we_mutate_ARGV_by_default
+    @app.reset
+    @app.flag :f
+    @app.command :foo do |c|
+      c.action do |*args|
+      end
+    end
+
+    argv = %w(-f some_flag foo bar blah)
+
+    @app.run(argv)
+
+    assert_equal %w(bar blah),argv
+  end
+
+  def test_that_we_can_avoid_mutating_ARGV
+    @app.reset
+    @app.flag :f
+    @app.command :foo do |c|
+      c.action do |*args|
+      end
+    end
+    @app.preserve_argv
+
+    argv = %w(-f some_flag foo bar blah)
+
+    @app.run(argv)
+
+    assert_equal %w(-f some_flag foo bar blah),argv
+  end
+
+  private
+
+  def do_test_flag_create(object)
+    description = 'this is a description'
+    long_desc = 'this is a very long description'
+    object.desc description
+    object.long_desc long_desc
+    object.arg_name 'filename'
+    object.default_value '~/.blah.rc'
+    object.flag :f
+    assert (object.flags[:f] )
+    assert_equal(description,object.flags[:f].description)
+    assert_equal(long_desc,object.flags[:f].long_description)
+  end
+
+  def do_test_switch_create(object)
+    do_test_switch_create_classic(object)
+    do_test_switch_create_compact(object)
+  end
+
+  def some_descriptions
+    lambda {
+      @description = 'this is a description'
+      @long_description = 'this is a very long description'
+    }
+  end
+
+  def assert_switch_was_made(object,switch) 
+    lambda {
+      assert object.switches[switch]
+      assert_equal @description,object.switches[switch].description,"For switch #{switch}"
+      assert_equal @long_description,object.switches[switch].long_description,"For switch #{switch}"
+      assert(object.usage != nil) if object.respond_to? :usage
+    }
+  end
+
+  def do_test_switch_create_classic(object)
+    Given some_descriptions
+    When {
+      object.desc @description
+      object.long_desc @long_description
+      object.switch :f
+    }
+    Then assert_switch_was_made(object,:f)
+  end
+
+  def do_test_switch_create_compact(object)
+    Given some_descriptions
+    When {
+      object.switch :g, :desc => @description, :long_desc => @long_description
+    }
+    Then assert_switch_was_made(object,:g)
+  end
+
+  def do_test_switch_create_twice(object)
+    description = 'this is a description'
+    object.desc description
+    object.switch :f
+    assert (object.switches[:f] )
+    assert_equal(description,object.switches[:f].description)
+    object.switch :g
+    assert (object.switches[:g])
+    assert_equal(nil,object.switches[:g].description)
+    assert(object.usage != nil) if object.respond_to? :usage
+  end
+
+
+end