win32-api 1.5.3-universal-mingw32 → 1.6.0-universal-mingw32

data/vendor/bundle/ruby/2.2.0/gems/power_assert-0.3.0/lib/power_assert/enable_tracepoint_events.rb

@@ -0,0 +1,82 @@
+if defined? RubyVM
+  verbose = $VERBOSE
+  begin
+    $VERBOSE = nil
+    module PowerAssert
+      # set redefined flag
+      basic_classes = [
+        Fixnum, Float, String, Array, Hash, Bignum, Symbol, Time, Regexp
+      ]
+
+      basic_operators = [
+        :+, :-, :*, :/, :%, :==, :===, :<, :<=, :<<, :[], :[]=,
+        :length, :size, :empty?, :succ, :>, :>=, :!, :!=, :=~, :freeze
+      ]
+
+      class Bug11182
+        def fixed?
+          true
+        end
+      end
+      private_constant :Bug11182
+
+      refine Bug11182 do
+        def fixed?
+        end
+      end
+
+      class Bug11182Sub < Bug11182
+        alias _fixed? fixed?
+        protected :_fixed?
+      end
+      private_constant :Bug11182Sub
+
+      if (Bug11182.new.fixed? rescue false)
+        basic_classes.each do |klass|
+          basic_operators.each do |bop|
+            refine(klass) do
+              define_method(bop) {}
+            end
+          end
+        end
+      else
+        # workaround for https://bugs.ruby-lang.org/issues/11182
+        basic_classes.each do |klass|
+          basic_operators.each do |bop|
+            if klass.public_method_defined?(bop)
+              klass.ancestors.find {|i| i.instance_methods(false).index(bop) }.module_eval do
+                public bop
+              end
+            end
+          end
+        end
+
+        refine Symbol do
+          def ==
+          end
+        end
+      end
+
+      # bypass check_cfunc
+      refine BasicObject do
+        def !
+        end
+
+        def ==
+        end
+      end
+
+      refine Module do
+        def ==
+        end
+      end
+    end
+  ensure
+    $VERBOSE = verbose
+  end
+
+  # disable optimization
+  RubyVM::InstructionSequence.compile_option = {
+    specialized_instruction: false
+  }
+end

data/vendor/bundle/ruby/2.2.0/gems/power_assert-0.3.0/lib/power_assert/version.rb

@@ -0,0 +1,3 @@
+module PowerAssert
+  VERSION = "0.3.0"
+end

data/vendor/bundle/ruby/2.2.0/gems/power_assert-0.3.0/power_assert.gemspec

@@ -0,0 +1,23 @@
+$:.push File.expand_path('../lib', __FILE__)
+require 'power_assert/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'power_assert'
+  s.version     = PowerAssert::VERSION
+  s.authors     = ['Kazuki Tsujimoto']
+  s.email       = ['kazuki@callcc.net']
+  s.homepage    = 'https://github.com/k-tsj/power_assert'
+  s.summary     = %q{Power Assert for Ruby}
+  s.description = %q{Power Assert for Ruby. Power Assert shows each value of variables and method calls in the expression. It is useful for testing, providing which value wasn't correct when the condition is not satisfied.}
+
+  s.files            = `git ls-files`.split("\n")
+  s.test_files       = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables      = `git ls-files -- bin/*`.split("\n").map{|f| File.basename(f) }
+  s.require_paths    = ['lib']
+  s.add_development_dependency 'test-unit'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'simplecov'
+  s.extra_rdoc_files = ['README.rdoc']
+  s.rdoc_options     = ['--main', 'README.rdoc']
+  s.licenses         = ['2-clause BSDL', "Ruby's"]
+end

data/vendor/bundle/ruby/2.2.0/gems/power_assert-0.3.0/test/helper.rb

@@ -0,0 +1,10 @@
+begin
+  if ENV['COVERAGE']
+    require 'simplecov'
+    SimpleCov.start do
+      add_filter '/test/'
+      add_filter '/vendor/'
+    end
+  end
+rescue LoadError
+end

data/vendor/bundle/ruby/2.2.0/gems/power_assert-0.3.0/test/test_power_assert.rb

@@ -0,0 +1,512 @@
+require 'test/unit'
+require 'power_assert'
+require 'ripper'
+require 'set'
+
+class TestPowerAssert < Test::Unit::TestCase
+  class << self
+    def t(msg='', &blk)
+      loc = caller_locations(1, 1)[0]
+      test("#{loc.path} --location #{loc.lineno} #{msg}", &blk)
+    end
+  end
+
+  EXTRACT_METHODS_TEST = [
+    [[[:method, "c", 4], [:method, "b", 2], [:method, "d", 8], [:method, "a", 0]],
+      'a(b(c), d)'],
+
+    [[[:method, "a", 0], [:method, "b", 2], [:method, "d", 6], [:method, "c", 4]],
+      'a.b.c(d)'],
+
+    [[[:method, "b", 2], [:method, "a", 0], [:method, "c", 5], [:method, "e", 9], [:method, "d", 7]],
+      'a(b).c.d(e)'],
+
+    [[[:method, "b", 4], [:method, "a", 2], [:method, "c", 7], [:method, "e", 13], [:method, "g", 11], [:method, "d", 9], [:method, "f", 0]],
+      'f(a(b).c.d(g(e)))'],
+
+    [[[:method, "c", 5], [:method, "e", 11], [:method, "a", 0]],
+      'a(b: c, d: e)'],
+
+    [[[:method, "b", 2], [:method, "c", 7], [:method, "d", 10], [:method, "e", 15], [:method, "a", 0]],
+      'a(b => c, d => e)'],
+
+    [[[:method, "b", 4], [:method, "d", 10]],
+      '{a: b, c: d}'],
+
+    [[[:method, "a", 1], [:method, "b", 6], [:method, "c", 9], [:method, "d", 14]],
+      '{a => b, c => d}'],
+
+    [[[:method, "a", 2], [:method, "b", 5], [:method, "c", 10], [:method, "d", 13]],
+      '[[a, b], [c, d]]'],
+
+    [[[:method, "a", 0], [:method, "b", 2], [:method, "c", 5]],
+      'a b, c { d }'],
+
+    [[[:method, "a", 20]],
+      'assertion_message { a }'],
+
+    [[[:method, "a", 0]],
+      'a { b }'],
+
+    [[[:method, "c", 4], [:method, "B", 2], [:method, "d", 8], [:method, "A", 0]],
+      'A(B(c), d)'],
+
+    [[[:method, "c", 6], [:method, "f", 17], [:method, "h", 25], [:method, "a", 0]],
+      'a(b = c, (d, e = f), G = h)'],
+
+    [[[:method, "b", 2], [:method, "c", 6], [:method, "d", 9], [:method, "e", 12], [:method, "g", 18], [:method, "i", 24], [:method, "j", 29], [:method, "a", 0]],
+      'a(b, *c, d, e, f: g, h: i, **j)'],
+
+    [[[:method, "a", 0], [:method, "b", 5], [:method, "c", 9], [:method, "+", 7], [:method, "==", 2]],
+      'a == b + c'],
+
+    [[[:ref, "var", 0], [:ref, "var", 8], [:method, "var", 4]],
+      'var.var(var)'],
+
+    [[[:ref, "B", 2], [:ref, "@c", 5], [:ref, "@@d", 9], [:ref, "$e", 14], [:method, "f", 18], [:method, "self", 20], [:ref, "self", 26], [:method, "a", 0]],
+      'a(B, @c, @@d, $e, f.self, self)'],
+
+    [[[:method, "a", 0], [:method, "c", 4], [:method, "b", 2]],
+      'a.b c'],
+
+    [[[:method, "b", 4]],
+      '"a#{b}c"'],
+
+    [[[:method, "b", 4]],
+      '/a#{b}c/'],
+
+    [[],
+      '[]'],
+
+    [[[:method, "a", 0], [:method, "[]", 1]],
+      'a[0]'],
+
+    # not supported
+    [[],
+      '[][]'],
+
+    # not supported
+    [[],
+      '{}[]'],
+
+    [[[:method, "a", 1], [:method, "!", 0]],
+      '!a'],
+
+    [[[:method, "a", 1], [:method, "+@", 0]],
+      '+a'],
+
+    [[[:method, "a", 1], [:method, "-@", 0]],
+      '-a'],
+
+    [[[:method, "a", 2], [:method, "!", 0], [:method, "b", 9], [:method, "+@", 8], [:method, "c", 15], [:method, "-@", 14],
+        [:method, "==", 11], [:method, "==", 4]],
+      '! a == (+b == -c)'],
+
+    [[[:method, "b", 6]],
+      '%x{a#{b}c}'],
+
+    [[[:method, "a", 0], [:method, "b", 3]],
+      "a..b"],
+
+    [[[:method, "a", 0], [:method, "b", 4]],
+      "a...b"],
+
+    [[[:method, "b", 5]],
+      ':"a#{b}c"'],
+
+    # not supported
+    [[],
+      '->{}.()'],
+
+    [[[:method, "a", 0], [:method, "b", 3], [:method, "call", 2]],
+      'a.(b)'],
+  ]
+
+  EXTRACT_METHODS_TEST.each_with_index do |(expect, source), idx|
+    define_method("test_extract_methods_#{'%03d' % idx}") do
+      pa = PowerAssert.const_get(:Context).new(-> { var = nil; -> { var } }.(), nil, TOPLEVEL_BINDING)
+      pa.instance_variable_set(:@line, source)
+      pa.instance_variable_set(:@assertion_method_name, 'assertion_message')
+      assert_equal expect, pa.send(:extract_idents, Ripper.sexp(source)).map(&:to_a), source
+    end
+  end
+
+  class BasicObjectSubclass < BasicObject
+    def foo
+      "foo"
+    end
+  end
+
+  def assertion_message(source = nil, source_binding = TOPLEVEL_BINDING, &blk)
+    ::PowerAssert.start(source || blk, assertion_method: __callee__, source_binding: source_binding) do |pa|
+      pa.yield
+      pa.message
+    end
+  end
+
+  def Assertion(&blk)
+    ::PowerAssert.start(blk, assertion_method: __callee__) do |pa|
+      pa.yield
+      pa.message
+    end
+  end
+
+  define_method(:bmethod) do
+    false
+  end
+
+  sub_test_case 'lazy_inspection' do
+    t do
+      PowerAssert.configure do |c|
+        assert !c.lazy_inspection
+      end
+      assert_equal <<END.chomp, assertion_message {
+        'a'.sub(/./, 'b').sub!(/./, 'c')
+            |             |
+            |             "c"
+            "b"
+END
+        'a'.sub(/./, 'b').sub!(/./, 'c')
+      }
+    end
+
+    t do
+      PowerAssert.configure do |c|
+        c.lazy_inspection = true
+      end
+      begin
+        assert_equal <<END.chomp, assertion_message {
+          'a'.sub(/./, 'b').sub!(/./, 'c')
+              |             |
+              |             "c"
+              "c"
+END
+          'a'.sub(/./, 'b').sub!(/./, 'c')
+        }
+      ensure
+        PowerAssert.configure do |c|
+          c.lazy_inspection = false
+        end
+      end
+    end
+  end
+
+  sub_test_case 'assertion_message' do
+    t do
+      a = 0
+      @b = 1
+      @@c = 2
+      $d = 3
+      assert_equal <<END.chomp, assertion_message {
+        String(a) + String(@b) + String(@@c) + String($d)
+        |      |  | |      |   | |      |    | |      |
+        |      |  | |      |   | |      |    | |      3
+        |      |  | |      |   | |      |    | "3"
+        |      |  | |      |   | |      |    "0123"
+        |      |  | |      |   | |      2
+        |      |  | |      |   | "2"
+        |      |  | |      |   "012"
+        |      |  | |      1
+        |      |  | "1"
+        |      |  "01"
+        |      0
+        "0"
+END
+        String(a) + String(@b) + String(@@c) + String($d)
+      }
+    end
+
+    t do
+      assert_equal <<END.chomp, assertion_message {
+        "0".class == "3".to_i.times.map {|i| i + 1 }.class
+            |     |      |    |     |                |
+            |     |      |    |     |                Array
+            |     |      |    |     [1, 2, 3]
+            |     |      |    #<Enumerator: 3:times>
+            |     |      3
+            |     false
+            String
+END
+        "0".class == "3".to_i.times.map {|i| i + 1 }.class
+      }
+    end
+
+    t do
+      assert_equal '', assertion_message {
+        false
+      }
+    end
+
+    t do
+      assert_equal <<END.chomp,
+      assertion_message { "0".class }
+                              |
+                              String
+END
+      assertion_message { "0".class }
+    end
+
+    t do
+      assert_equal <<END.chomp,
+        "0".class
+            |
+            String
+END
+      Assertion {
+        "0".class
+      }
+    end
+
+    t do
+      assert_equal <<END.chomp,
+      Assertion { "0".class }
+                      |
+                      String
+END
+      Assertion { "0".class }
+    end
+
+    t do
+      assert_equal <<END.chomp, assertion_message {
+        Set.new == Set.new([0])
+        |   |   |  |   |
+        |   |   |  |   #<Set: {0}>
+        |   |   |  Set
+        |   |   false
+        |   #<Set: {}>
+        Set
+END
+        Set.new == Set.new([0])
+      }
+    end
+
+    t do
+      var = [10,20]
+      assert_equal <<END.chomp, assertion_message {
+        var[0] == 0
+        |  |   |
+        |  |   false
+        |  10
+        [10, 20]
+END
+        var[0] == 0
+      }
+    end
+
+    t do
+      a = 1
+      assert_equal <<END.chomp, assertion_message {
+        ! a != (+a == -a)
+        | | |   || |  ||
+        | | |   || |  |1
+        | | |   || |  -1
+        | | |   || false
+        | | |   |1
+        | | |   1
+        | | false
+        | 1
+        false
+END
+        ! a != (+a == -a)
+      }
+    end
+
+    t do
+      assert_equal <<END.chomp, assertion_message {
+        bmethod
+        |
+        false
+END
+        bmethod
+      }
+    end
+
+    t do
+      a = :a
+      assert_equal <<END.chomp, assertion_message {
+        a == :b
+        | |
+        | false
+        :a
+END
+        a == :b
+      }
+    end
+
+    t do
+      assert_equal <<END.chomp, assertion_message {
+        ! Object
+        | |
+        | Object
+        false
+END
+        ! Object
+      }
+    end
+
+    if PowerAssert.respond_to?(:clear_global_method_cache, true)
+      t do
+        3.times do
+          assert_equal <<END.chomp, assertion_message {
+            String == Array
+            |      |  |
+            |      |  Array
+            |      false
+            String
+END
+            String == Array
+          }
+        end
+      end
+    end
+  end
+
+  sub_test_case 'inspection_failure' do
+    t do
+      assert_match Regexp.new(<<END.chomp.gsub('|', "\\|")),
+      assertion_message { BasicObjectSubclass.new.foo }
+                          |                   |   |
+                          |                   |   "foo"
+                          |                   InspectionFailure: NoMethodError: .*
+                          TestPowerAssert::BasicObjectSubclass
+END
+      assertion_message { BasicObjectSubclass.new.foo }
+    end
+
+    t do
+      o = Object.new
+      def o.inspect
+        raise
+      end
+      assert_equal <<END.chomp.b, assertion_message {
+        o.class
+        | |
+        | Object
+        InspectionFailure: RuntimeError:
+END
+        o.class
+      }
+    end
+  end
+
+  sub_test_case 'alias_method' do
+    def setup
+      begin
+        PowerAssert.configure do |c|
+          c._trace_alias_method = true
+        end
+        @o = Class.new do
+          def foo
+            :foo
+          end
+          alias alias_of_iseq foo
+          alias alias_of_cfunc to_s
+        end
+        yield
+      ensure
+        PowerAssert.configure do |c|
+          c._trace_alias_method = false
+        end
+      end
+    end
+
+    t do
+      assert_match Regexp.new(<<END.chomp.gsub('|', "\\|")),
+        assertion_message { @o.new.alias_of_iseq }
+                            |  |   |
+                            |  |   :foo
+                            |  #<#<Class:.*>:.*>
+                            #<Class:.*>
+END
+        assertion_message { @o.new.alias_of_iseq }
+    end
+
+    t do
+      omit 'alias of cfunc is not supported yet'
+      assert_match Regexp.new(<<END.chomp.gsub('|', "\\|")),
+        assertion_message { @o.new.alias_of_cfunc }
+                            |  |   |
+                            |  |   #<#<Class:.*>:.*>
+                            |  #<#<Class:.*>:.*>
+                            #<Class:.*>
+END
+        assertion_message { @o.new.alias_of_cfunc }
+    end
+  end
+
+  sub_test_case 'assertion_message_with_incompatible_encodings' do
+    if Encoding.default_external == Encoding::UTF_8
+      t do
+        a = "\u3042"
+        def a.inspect
+          super.encode('utf-16le')
+        end
+        assert_equal <<END.chomp, assertion_message {
+          a + a
+          | | |
+          | | "\u3042"(UTF-16LE)
+          | "\u3042\u3042"
+          "\u3042"(UTF-16LE)
+END
+          a + a
+        }
+      end
+    end
+
+    t do
+      a = "\xFF"
+      def a.inspect
+        "\xFF".force_encoding('ascii-8bit')
+      end
+      assert_equal <<END.chomp.b, assertion_message {
+        a.length
+        | |
+        | 1
+        \xFF
+END
+        a.length
+      }.b
+    end
+  end
+
+  def test_assertion_message_with_string
+    a, = 0, a # suppress "assigned but unused variable" warning
+    @b = 1
+    @@c = 2
+    $d = 3
+    assert_equal <<END.chomp, assertion_message(<<END, binding)
+      String(a) + String(@b) + String(@@c) + String($d)
+      |      |  | |      |   | |      |    | |      |
+      |      |  | |      |   | |      |    | |      3
+      |      |  | |      |   | |      |    | "3"
+      |      |  | |      |   | |      |    "0123"
+      |      |  | |      |   | |      2
+      |      |  | |      |   | "2"
+      |      |  | |      |   "012"
+      |      |  | |      1
+      |      |  | "1"
+      |      |  "01"
+      |      0
+      "0"
+END
+      String(a) + String(@b) + String(@@c) + String($d)
+END
+  end
+
+  def test_workaround_for_ruby_2_2
+    assert_nothing_raised do
+      assertion_message { Thread.new {}.join }
+    end
+  end
+
+  class H < Hash
+    alias aref []
+    protected :aref
+  end
+
+  def test_workaround_for_bug11182
+    assert_nothing_raised do
+      {}[:a]
+    end
+  end
+end