opal 1.0.5 → 1.1.0.rc1

data/opal/corelib/string/unpack.rb

@@ -1,3 +1,4 @@
+require 'base64'
 require 'corelib/pack_unpack/format_string_parser'
 
 class String
@@ -234,23 +235,7 @@ class String
 
     function base64Decode(callback) {
       return function(data) {
-        var string = callback(data);
-        if (typeof(atob) === 'function') {
-          // Browser
-          return atob(string);
-        } else if (typeof(Buffer) === 'function') {
-          // Node
-          if (typeof(Buffer.from) === 'function') {
-            // Node 5.10+
-            return Buffer.from(string, 'base64').toString();
-          } else {
-            return new Buffer(string, 'base64').toString();
-          }
-        } else if (#{defined?(Base64)}) {
-          return #{Base64.decode64(`string`)};
-        } else {
-          #{raise "To use String#unpack('m'), you must first require 'base64'."}
-        }
+        return #{Base64.decode64(`callback(data)`)};
       }
     }
 

data/opal/corelib/struct.rb

@@ -101,6 +101,17 @@ class Struct
     end
   end
 
+  def initialize_copy(from)
+    %x{
+      self.$$data = {}
+      var keys = Object.keys(from.$$data), i, max, name;
+      for (i = 0, max = keys.length; i < max; i++) {
+        name = keys[i];
+        self.$$data[name] = from.$$data[name];
+      }
+    }
+  end
+
   def members
     self.class.members
   end
@@ -261,7 +272,9 @@ class Struct
 
   alias to_s inspect
 
-  def to_h
+  def to_h(&block)
+    return map(&block).to_h(*args) if block_given?
+
     self.class.members.each_with_object({}) { |name, h| h[name] = self[name] }
   end
 

data/opal/corelib/time.rb

@@ -1,3 +1,5 @@
+# helpers: slice
+
 require 'corelib/comparable'
 
 class Time < `Date`
@@ -493,6 +495,8 @@ class Time < `Date`
             break;
 
           case 'j':
+            zero    = !blank;
+            width   = isNaN(width) ? 3 : width;
             result += #{yday};
             break;
 

data/opal/opal.rb

@@ -14,6 +14,6 @@ require 'corelib/dir'
 require 'corelib/file'
 require 'corelib/process'
 require 'corelib/random'
-require 'corelib/random/mersenne_twister.js'
+require 'corelib/random/mersenne_twister'
 
 require 'corelib/unsupported'

data/opal/opal/mini.rb

@@ -13,6 +13,6 @@ require 'corelib/range'
 require 'corelib/proc'
 require 'corelib/method'
 require 'corelib/regexp'
-
 require 'corelib/variables'
+require 'corelib/io'
 require 'opal/regexp_anchors'

data/package.json

@@ -3,6 +3,7 @@
   "private": true,
   "dependencies": {
     "benchmark": "^2.1.4",
+    "browserify": "^17.0.0",
     "jshint": "^2.11.0-rc1",
     "source-map-support": "^0.5.16",
     "uglify-js": "^3.7.2"

data/spec/README.md

@@ -0,0 +1,10 @@
+# Opal specs overview
+
+* **ruby** the Ruby Spec Suite examples (submodule)
+* **ruby_specs** (file) a whitelist of the Ruby Spec Suite files to be ran
+* **filters** The list of the Ruby Spec Suite examples that are either bugs or unsupported
+* **opal** opal additions/special behaviour in the runtime/corelib
+* **lib** specs for opal lib (parser, lexer, grammar, compiler etc)
+* **mspec** the MSpec library that runs the ruby spec
+* **mspec-opal** Opal specific patches to the MSpec library
+* **support** misc. utilities

data/spec/filters/bugs/array.rb

@@ -0,0 +1,76 @@
+# NOTE: run bin/format-filters after changing this file
+opal_filter "Array" do
+  fails "Array#* with an integer with a subclass of Array returns an Array instance" # Expected [] (ArraySpecs::MyArray) to be an instance of Array
+  fails "Array#== compares with an equivalent Array-like object using #to_ary" # Expected false to be true
+  fails "Array#== returns true for [NaN] == [NaN] because Array#== first checks with #equal? and NaN.equal?(NaN) is true" # Expected [NaN] to equal [NaN]
+  fails "Array#[] can accept beginless ranges" # Opal::SyntaxError: undefined method `type' for nil
+  fails "Array#[] can accept endless ranges" # Opal::SyntaxError: undefined method `type' for nil
+  fails "Array#[] can accept nil...nil ranges" # TypeError: no implicit conversion of NilClass into Integer
+  fails "Array#[] raises TypeError if to_int returns non-integer" # Expected TypeError but no exception was raised ([1, 2, 3, 4] was returned)
+  fails "Array#[] raises a RangeError if passed a range with a bound that is too large" # Expected RangeError but no exception was raised (nil was returned)
+  fails "Array#[] raises a type error if a range is passed with a length" # Expected TypeError but no exception was raised ([2, 3] was returned)
+  fails "Array#[] with a subclass of Array returns a Array instance with [-n, m]" # Expected [3, 4] (ArraySpecs::MyArray) to be an instance of Array
+  fails "Array#[] with a subclass of Array returns a Array instance with [-n..-m]" # Expected [3, 4, 5] (ArraySpecs::MyArray) to be an instance of Array
+  fails "Array#[] with a subclass of Array returns a Array instance with [-n...-m]" # Expected [3, 4] (ArraySpecs::MyArray) to be an instance of Array
+  fails "Array#[] with a subclass of Array returns a Array instance with [n, m]" # Expected [1, 2] (ArraySpecs::MyArray) to be an instance of Array
+  fails "Array#[] with a subclass of Array returns a Array instance with [n...m]" # Expected [2, 3] (ArraySpecs::MyArray) to be an instance of Array
+  fails "Array#[] with a subclass of Array returns a Array instance with [n..m]" # Expected [2, 3, 4] (ArraySpecs::MyArray) to be an instance of Array
+  fails "Array#[]= with [..n] and [...n] inserts at the beginning if n < negative the array size" # Opal::SyntaxError: undefined method `type' for nil
+  fails "Array#[]= with [..n] and [...n] just sets the section defined by range to nil even if the rhs is nil" # Opal::SyntaxError: undefined method `type' for nil
+  fails "Array#[]= with [..n] and [...n] just sets the section defined by range to nil if n < 0 and the rhs is nil" # Opal::SyntaxError: undefined method `type' for nil
+  fails "Array#[]= with [..n] and [...n] replaces everything if n > the array size" # Opal::SyntaxError: undefined method `type' for nil
+  fails "Array#[]= with [..n] and [...n] replaces the section defined by range" # Opal::SyntaxError: undefined method `type' for nil
+  fails "Array#[]= with [..n] and [...n] replaces the section if n < 0" # Opal::SyntaxError: undefined method `type' for nil
+  fails "Array#[]= with [m..] inserts at the end if m > the array size" # Opal::SyntaxError: undefined method `type' for nil
+  fails "Array#[]= with [m..] just sets the section defined by range to nil even if the rhs is nil" # Opal::SyntaxError: undefined method `type' for nil
+  fails "Array#[]= with [m..] just sets the section defined by range to nil if m and n < 0 and the rhs is nil" # Opal::SyntaxError: undefined method `type' for nil
+  fails "Array#[]= with [m..] replaces the section defined by range" # Opal::SyntaxError: undefined method `type' for nil
+  fails "Array#[]= with [m..] replaces the section if m and n < 0" # Opal::SyntaxError: undefined method `type' for nil
+  fails "Array#deconstruct returns self" # NoMethodError: undefined method `deconstruct' for [1]
+  fails "Array#difference accepts multiple arguments" # NoMethodError: undefined method `difference' for [1, 2, 3, 1]
+  fails "Array#difference does not return subclass instances for Array subclasses" # NoMethodError: undefined method `difference' for [1, 2, 3]
+  fails "Array#difference returns a copy when called without any parameter" # NoMethodError: undefined method `difference' for [1, 2, 3, 2]
+  fails "Array#drop raises a TypeError when the passed argument can't be coerced to Integer" # Expected TypeError but no exception was raised ([1, 2] was returned)
+  fails "Array#drop raises a TypeError when the passed argument isn't an integer and #to_int returns non-Integer" # Expected TypeError but no exception was raised ([1, 2] was returned)
+  fails "Array#drop tries to convert the passed argument to an Integer using #to_int" # Expected [1, 2, 3] == [3] to be truthy but was false
+  fails "Array#each does not yield elements deleted from the end of the array" # Expected [2, 3, nil] to equal [2, 3]
+  fails "Array#each yields elements added to the end of the array by the block" # Expected [2] to equal [2, 0, 0]
+  fails "Array#fill with (filler, range) works with beginless ranges" # Opal::SyntaxError: undefined method `type' for nil
+  fails "Array#fill with (filler, range) works with endless ranges" # Opal::SyntaxError: undefined method `type' for nil
+  fails "Array#filter returns a new array of elements for which block is true" # NoMethodError: undefined method `filter' for [1, 3, 4, 5, 6, 9]
+  fails "Array#flatten does not call #to_ary on elements beyond the given level"
+  fails "Array#flatten performs respond_to? and method_missing-aware checks when coercing elements to array"
+  fails "Array#flatten returns Array instance for Array subclasses" # Expected [] (ArraySpecs::MyArray) to be an instance of Array
+  fails "Array#flatten with a non-Array object in the Array calls #method_missing if defined"
+  fails "Array#inspect does not call #to_str on the object returned from #to_s when it is not a String" # Exception: Cannot convert object to primitive value
+  fails "Array#intersection accepts multiple arguments" # NoMethodError: undefined method `intersection' for [1, 2, 3, 4]
+  fails "Array#join raises a NoMethodError if an element does not respond to #to_str, #to_ary, or #to_s"
+  fails "Array#partition returns in the left array values for which the block evaluates to true"
+  fails "Array#rassoc calls elem == obj on the second element of each contained array"
+  fails "Array#rassoc does not check the last element in each contained but specifically the second" # Expected [1, "foobar", #<MockObject:0x4ef6e>] to equal [2, #<MockObject:0x4ef6e>, 1]
+  fails "Array#select returns a new array of elements for which block is true"
+  fails "Array#slice can accept beginless ranges" # Opal::SyntaxError: undefined method `type' for nil
+  fails "Array#slice can accept endless ranges" # Opal::SyntaxError: undefined method `type' for nil
+  fails "Array#slice can accept nil...nil ranges" # TypeError: no implicit conversion of NilClass into Integer
+  fails "Array#slice raises TypeError if to_int returns non-integer" # Expected TypeError but no exception was raised ([1, 2, 3, 4] was returned)
+  fails "Array#slice raises a RangeError if passed a range with a bound that is too large" # Expected RangeError but no exception was raised (nil was returned)
+  fails "Array#slice raises a type error if a range is passed with a length" # Expected TypeError but no exception was raised ([2, 3] was returned)
+  fails "Array#slice with a subclass of Array returns a Array instance with [-n, m]" # Expected [3, 4] (ArraySpecs::MyArray) to be an instance of Array
+  fails "Array#slice with a subclass of Array returns a Array instance with [-n..-m]" # Expected [3, 4, 5] (ArraySpecs::MyArray) to be an instance of Array
+  fails "Array#slice with a subclass of Array returns a Array instance with [-n...-m]" # Expected [3, 4] (ArraySpecs::MyArray) to be an instance of Array
+  fails "Array#slice with a subclass of Array returns a Array instance with [n, m]" # Expected [1, 2] (ArraySpecs::MyArray) to be an instance of Array
+  fails "Array#slice with a subclass of Array returns a Array instance with [n...m]" # Expected [2, 3] (ArraySpecs::MyArray) to be an instance of Array
+  fails "Array#slice with a subclass of Array returns a Array instance with [n..m]" # Expected [2, 3, 4] (ArraySpecs::MyArray) to be an instance of Array
+  fails "Array#slice! works with beginless ranges" # Opal::SyntaxError: undefined method `type' for nil
+  fails "Array#slice! works with endless ranges" # Opal::SyntaxError: undefined method `type' for nil
+  fails "Array#to_h with block does not coerce returned pair to Array with #to_a" # Expected TypeError (/wrong element type MockObject at 0/) but got: TypeError (wrong element type NilClass at 0 (expected array))
+  fails "Array#to_h with block raises TypeError if block returns something other than Array" # Expected TypeError (/wrong element type String at 0/) but got: TypeError (wrong element type NilClass at 0 (expected array))
+  fails "Array#to_s does not call #to_str on the object returned from #to_s when it is not a String" # Exception: Cannot convert object to primitive value
+  fails "Array#union accepts multiple arguments" # NoMethodError: undefined method `union' for [1, 2, 3]
+  fails "Array#union does not return subclass instances for Array subclasses"
+  fails "Array#union returns unique elements when given no argument" # NoMethodError: undefined method `union' for [1, 2, 3, 2]
+  fails "Array#uniq returns Array instance on Array subclasses" # Expected [1, 2, 3] (ArraySpecs::MyArray) to be an instance of Array
+  fails "Array#uniq! properly handles recursive arrays"
+  fails "Array#values_at works when given beginless ranges" # Opal::SyntaxError: undefined method `type' for nil
+  fails "Array#values_at works when given endless ranges" # Opal::SyntaxError: undefined method `type' for nil
+end

data/spec/filters/bugs/base64.rb

@@ -0,0 +1,10 @@
+# NOTE: run bin/format-filters after changing this file
+opal_filter "Base64" do
+  fails "Base64#decode64 returns a binary encoded string" # Expected #<Encoding:UTF-8> == #<Encoding:ASCII-8BIT (dummy)> to be truthy but was false
+  fails "Base64#decode64 returns the Base64-decoded version of the given string with wrong padding" # Expected "]M\u0095¹\u0090\u0081É\u0095¥¹\u0099½É\u008D\u0095µ\u0095¹ÑÌ" == "]M\u0095¹\u0090\u0081ɕ¥¹\u0099½ɍ\u0095µ\u0095¹ÑÌ" to be truthy but was false
+  fails "Base64#encode64 returns a US_ASCII encoded string" # Expected #<Encoding:UTF-8> == #<Encoding:ASCII-8BIT (dummy)> to be truthy but was false
+  fails "Base64#strict_decode64 raises ArgumentError when the given string contains an invalid character" # Expected ArgumentError but no exception was raised ("Ü" was returned)
+  fails "Base64#strict_decode64 raises ArgumentError when the given string has wrong padding" # Expected ArgumentError but no exception was raised ("\u0001M\u0095¹\u0090\u0081É\u0095¥¹\u0099½É\u008D\u0095µ\u0095¹ÑÌ" was returned)
+  fails "Base64#strict_decode64 returns a binary encoded string" # Expected #<Encoding:UTF-8> == #<Encoding:ASCII-8BIT (dummy)> to be truthy but was false
+  fails "Base64#strict_encode64 returns a US_ASCII encoded string" # Expected #<Encoding:UTF-8> == #<Encoding:ASCII-8BIT (dummy)> to be truthy but was false
+end

data/spec/filters/bugs/basicobject.rb

@@ -0,0 +1,12 @@
+# NOTE: run bin/format-filters after changing this file
+opal_filter "BasicObject" do
+  fails "BasicObject raises NoMethodError for nonexistent methods after #method_missing is removed"
+  fails "BasicObject#__send__ raises a TypeError if the method name is not a string or symbol" # NoMethodError: undefined method `' for SendSpecs
+  fails "BasicObject#initialize does not accept arguments"
+  fails "BasicObject#instance_eval evaluates string with given filename and linenumber"
+  fails "BasicObject#instance_eval evaluates string with given filename and negative linenumber" # Expected ["RuntimeError"] to equal ["b_file", "-98"]
+  fails "BasicObject#instance_eval has access to the caller's local variables" # Expected nil to equal "value"
+  fails "BasicObject#instance_exec binds the block's binding self to the receiver"
+  fails "BasicObject#instance_exec raises a LocalJumpError unless given a block"
+  fails "BasicObject#method_missing for an instance sets the receiver of the raised NoMethodError"
+end

data/spec/filters/bugs/bigdecimal.rb

@@ -0,0 +1,248 @@
+# NOTE: run bin/format-filters after changing this file
+opal_filter "BigDecimal" do
+  fails "BidDecimal#hash two BigDecimal objects with numerically equal values should have the same hash value" # Exception: self.$BigDecimal(...).$hash is not a function
+  fails "BidDecimal#hash two BigDecimal objects with the same value should have the same hash for NaNs" # Exception: self.$BigDecimal(...).$hash is not a function
+  fails "BidDecimal#hash two BigDecimal objects with the same value should have the same hash for infinite values" # Exception: self.$BigDecimal(...).$hash is not a function
+  fails "BidDecimal#hash two BigDecimal objects with the same value should have the same hash for ordinary values" # Exception: self.$BigDecimal(...).$hash is not a function
+  fails "BidDecimal#hash two BigDecimal objects with the same value should have the same hash for zero values" # Exception: self.$BigDecimal(...).$hash is not a function
+  fails "BigDecimal constants defines a VERSION value" # Expected false to be true
+  fails "BigDecimal constants exception-related constants has a EXCEPTION_ALL value" # NameError: uninitialized constant BigDecimal::EXCEPTION_ALL
+  fails "BigDecimal constants exception-related constants has a EXCEPTION_INFINITY value" # NameError: uninitialized constant BigDecimal::EXCEPTION_INFINITY
+  fails "BigDecimal constants exception-related constants has a EXCEPTION_NaN value" # NameError: uninitialized constant BigDecimal::EXCEPTION_NaN
+  fails "BigDecimal constants exception-related constants has a EXCEPTION_OVERFLOW value" # NameError: uninitialized constant BigDecimal::EXCEPTION_OVERFLOW
+  fails "BigDecimal constants exception-related constants has a EXCEPTION_UNDERFLOW value" # NameError: uninitialized constant BigDecimal::EXCEPTION_UNDERFLOW
+  fails "BigDecimal constants exception-related constants has a EXCEPTION_ZERODIVIDE value" # NameError: uninitialized constant BigDecimal::EXCEPTION_ZERODIVIDE
+  fails "BigDecimal constants has a BASE value" # NameError: uninitialized constant BigDecimal::BASE
+  fails "BigDecimal constants has a NaN value" # NameError: uninitialized constant BigDecimal::NAN
+  fails "BigDecimal constants has an INFINITY value" # NameError: uninitialized constant BigDecimal::INFINITY
+  fails "BigDecimal constants rounding-related constants has a ROUND_CEILING value" # Expected 2 to equal 5
+  fails "BigDecimal constants rounding-related constants has a ROUND_DOWN value" # Expected 1 to equal 2
+  fails "BigDecimal constants rounding-related constants has a ROUND_FLOOR value" # Expected 3 to equal 6
+  fails "BigDecimal constants rounding-related constants has a ROUND_HALF_DOWN value" # Expected 5 to equal 4
+  fails "BigDecimal constants rounding-related constants has a ROUND_HALF_EVEN value" # Expected 6 to equal 7
+  fails "BigDecimal constants rounding-related constants has a ROUND_HALF_UP value" # Expected 4 to equal 3
+  fails "BigDecimal constants rounding-related constants has a ROUND_UP value" # Expected 0 to equal 1
+  fails "BigDecimal is not defined unless it is required" # NoMethodError: undefined method `tmp' for #<MSpecEnv:0xbe6e>
+  fails "BigDecimal#% returns NaN if NaN is involved"
+  fails "BigDecimal#% returns NaN if the dividend is Infinity"
+  fails "BigDecimal#% returns self modulo other"
+  fails "BigDecimal#% returns the dividend if the divisor is Infinity"
+  fails "BigDecimal#% with Object tries to coerce the other operand to self" # Mock 'Object' expected to receive coerce(6543.21) exactly 1 times but received it 0 times
+  fails "BigDecimal#* with Object tries to coerce the other operand to self" # Mock 'Object' expected to receive coerce(3e-20001) exactly 1 times but received it 0 times
+  fails "BigDecimal#* with Rational produces a BigDecimal" # Exception: lhs.$* is not a function
+  fails "BigDecimal#** 0 to power of 0 is 1"
+  fails "BigDecimal#** 0 to powers < 0 is Infinity"
+  fails "BigDecimal#** other powers of 0 are 0"
+  fails "BigDecimal#** powers of 1 equal 1"
+  fails "BigDecimal#** powers of self"
+  fails "BigDecimal#** returns 0.0 if self is infinite and argument is negative"
+  fails "BigDecimal#** returns NaN if self is NaN"
+  fails "BigDecimal#** returns infinite if self is infinite and argument is positive"
+  fails "BigDecimal#+ with Object tries to coerce the other operand to self" # Mock 'Object' expected to receive coerce(1) exactly 1 times but received it 0 times
+  fails "BigDecimal#- with Object tries to coerce the other operand to self" # Mock 'Object' expected to receive coerce(1) exactly 1 times but received it 0 times
+  fails "BigDecimal#-@ properly handles special values"
+  fails "BigDecimal#/ returns a / b" #fails a single assertion: @one.send(@method, BigDecimal('-2E5555'), *@object).should == BigDecimal('-0.5E-5555')
+  fails "BigDecimal#/ with Object tries to coerce the other operand to self" # Mock 'Object' expected to receive coerce(1) exactly 1 times but received it 0 times
+  fails "BigDecimal#/ with Rational produces a BigDecimal" # Exception: lhs.$/ is not a function
+  fails "BigDecimal#< properly handles infinity values" #fails only with mock object
+  fails "BigDecimal#<= properly handles infinity values" #fails only with mock object
+  fails "BigDecimal#<=> returns -1 if a < b" #fails only with mock object
+  fails "BigDecimal#<=> returns 1 if a > b" #fails only with mock object
+  fails "BigDecimal#> properly handles infinity values" #fails only with mock object
+  fails "BigDecimal#>= properly handles infinity values" #fails only with mock object
+  fails "BigDecimal#add with Object tries to coerce the other operand to self" # Mock 'Object' expected to receive coerce(123450000000000) exactly 1 times but received it 0 times
+  fails "BigDecimal#add with Rational produces a BigDecimal" # Exception: lhs.$+ is not a function
+  fails "BigDecimal#ceil returns the smallest integer greater or equal to self, if n is unspecified"
+  fails "BigDecimal#ceil sets n digits left of the decimal point to 0, if given n < 0"
+  fails "BigDecimal#coerce returns [other, self] both as BigDecimal"
+  fails "BigDecimal#div returns a / b with optional precision" #fails the case of > 20 decimal places for to_s('F')
+  fails "BigDecimal#div with Object tries to coerce the other operand to self" # Mock 'Object' expected to receive coerce(1) exactly 1 times but received it 0 times
+  fails "BigDecimal#div with precision set to 0 returns a / b" #fails a single assertion: @one.send(@method, BigDecimal('-2E5555'), *@object).should == BigDecimal('-0.5E-5555')
+  fails "BigDecimal#div with precision set to 0 with Object tries to coerce the other operand to self" # Mock 'Object' expected to receive coerce(1) exactly 1 times but received it 0 times
+  fails "BigDecimal#divmod array contains quotient and modulus as BigDecimal"
+  fails "BigDecimal#divmod can be reversed with * and +" # Expected 0 to equal -1
+  fails "BigDecimal#divmod returns an array of Infinity and NaN if the dividend is Infinity"
+  fails "BigDecimal#divmod returns an array of two NaNs if NaN is involved"
+  fails "BigDecimal#divmod returns an array of zero and the dividend if the divisor is Infinity"
+  fails "BigDecimal#exponent is n if number can be represented as 0.xxx*10**n"
+  fails "BigDecimal#exponent returns 0 if self is 0"
+  fails "BigDecimal#exponent returns an Integer"
+  fails "BigDecimal#fix correctly handles special values"
+  fails "BigDecimal#fix does not allow any arguments"
+  fails "BigDecimal#fix returns 0 if the absolute value is < 1"
+  fails "BigDecimal#fix returns a BigDecimal"
+  fails "BigDecimal#fix returns the integer part of the absolute value"
+  fails "BigDecimal#floor raise exception, if self is special value"
+  fails "BigDecimal#floor returns the greatest integer smaller or equal to self"
+  fails "BigDecimal#floor sets n digits left of the decimal point to 0, if given n < 0"
+  fails "BigDecimal#frac correctly handles special values"
+  fails "BigDecimal#frac returns 0 if the value is 0"
+  fails "BigDecimal#frac returns 0 if the value is an integer"
+  fails "BigDecimal#frac returns a BigDecimal"
+  fails "BigDecimal#frac returns the fractional part of the absolute value"
+  fails "BigDecimal#inspect does not add an exponent for zero values" # Exception: self.$BigDecimal(...).$inspect is not a function
+  fails "BigDecimal#inspect encloses information in angle brackets"
+  fails "BigDecimal#inspect is comma separated list of three items"
+  fails "BigDecimal#inspect last part is number of significant digits"
+  fails "BigDecimal#inspect looks like this"
+  fails "BigDecimal#inspect returns String starting with #"
+  fails "BigDecimal#inspect value after first comma is value as string"
+  fails "BigDecimal#mod_part_of_divmod returns NaN if NaN is involved"
+  fails "BigDecimal#mod_part_of_divmod returns NaN if the dividend is Infinity"
+  fails "BigDecimal#mod_part_of_divmod returns self modulo other"
+  fails "BigDecimal#mod_part_of_divmod returns the dividend if the divisor is Infinity"
+  fails "BigDecimal#mod_part_of_divmod with Object tries to coerce the other operand to self" # Mock 'Object' expected to receive coerce(6543.21) exactly 1 times but received it 0 times
+  fails "BigDecimal#modulo returns NaN if NaN is involved" # FloatDomainError: Computation results to 'NaN'(Not a Number)
+  fails "BigDecimal#modulo returns NaN if the dividend is Infinity" # FloatDomainError: Computation results to 'Infinity'
+  fails "BigDecimal#modulo returns self modulo other" # Exception: new BigNumber() number type has more than 15 significant digits: 9223372036854776000
+  fails "BigDecimal#modulo returns the dividend if the divisor is Infinity" # Expected NaN to equal 1
+  fails "BigDecimal#modulo with Object tries to coerce the other operand to self" # Mock 'Object' expected to receive coerce(6543.21) exactly 1 times but received it 0 times
+  fails "BigDecimal#mult with Object tries to coerce the other operand to self" # Mock 'Object' expected to receive coerce(3e-20001) exactly 1 times but received it 0 times
+  fails "BigDecimal#power 0 to power of 0 is 1"
+  fails "BigDecimal#power 0 to powers < 0 is Infinity"
+  fails "BigDecimal#power other powers of 0 are 0"
+  fails "BigDecimal#power powers of 1 equal 1"
+  fails "BigDecimal#power powers of self"
+  fails "BigDecimal#power returns 0.0 if self is infinite and argument is negative"
+  fails "BigDecimal#power returns NaN if self is NaN"
+  fails "BigDecimal#power returns infinite if self is infinite and argument is positive"
+  fails "BigDecimal#precs returns Integers as array values"
+  fails "BigDecimal#precs returns array of two values"
+  fails "BigDecimal#precs returns the current value of significant digits as the first value"
+  fails "BigDecimal#precs returns the maximum number of significant digits as the second value"
+  fails "BigDecimal#quo returns a / b" #fails a single assertion: @one.send(@method, BigDecimal('-2E5555'), *@object).should == BigDecimal('-0.5E-5555')
+  fails "BigDecimal#quo with Object tries to coerce the other operand to self" # Mock 'Object' expected to receive coerce(1) exactly 1 times but received it 0 times
+  fails "BigDecimal#remainder coerces arguments to BigDecimal if possible"
+  fails "BigDecimal#remainder it equals modulo, if both values are of same sign"
+  fails "BigDecimal#remainder means self-arg*(self/arg).truncate"
+  fails "BigDecimal#remainder raises TypeError if the argument cannot be coerced to BigDecimal"
+  fails "BigDecimal#remainder returns NaN if Infinity is involved"
+  fails "BigDecimal#remainder returns NaN if NaN is involved"
+  fails "BigDecimal#remainder returns NaN used with zero"
+  fails "BigDecimal#remainder returns zero if used on zero"
+  fails "BigDecimal#remainder with Object tries to coerce the other operand to self" # Mock 'Object' expected to receive coerce(3) exactly 1 times but received it 0 times
+  fails "BigDecimal#round :banker rounds values > 5 up, < 5 down and == 5 towards even neighbor" # ArgumentError: [BigDecimal#round] wrong number of arguments(2 for -1)
+  fails "BigDecimal#round :ceil rounds values towards +infinity" # ArgumentError: [BigDecimal#round] wrong number of arguments(2 for -1)
+  fails "BigDecimal#round :ceiling rounds values towards +infinity" # ArgumentError: [BigDecimal#round] wrong number of arguments(2 for -1)
+  fails "BigDecimal#round :default rounds values >= 5 up, otherwise down" # ArgumentError: [BigDecimal#round] wrong number of arguments(2 for -1)
+  fails "BigDecimal#round :down rounds values towards zero" # ArgumentError: [BigDecimal#round] wrong number of arguments(2 for -1)
+  fails "BigDecimal#round :floor rounds values towards -infinity" # ArgumentError: [BigDecimal#round] wrong number of arguments(2 for -1)
+  fails "BigDecimal#round :half_down rounds values > 5 up, otherwise down" # ArgumentError: [BigDecimal#round] wrong number of arguments(2 for -1)
+  fails "BigDecimal#round :half_even rounds values > 5 up, < 5 down and == 5 towards even neighbor" # ArgumentError: [BigDecimal#round] wrong number of arguments(2 for -1)
+  fails "BigDecimal#round :half_up rounds values >= 5 up, otherwise down" # ArgumentError: [BigDecimal#round] wrong number of arguments(2 for -1)
+  fails "BigDecimal#round :truncate rounds values towards zero" # ArgumentError: [BigDecimal#round] wrong number of arguments(2 for -1)
+  fails "BigDecimal#round :up rounds values away from zero" # ArgumentError: [BigDecimal#round] wrong number of arguments(2 for -1)
+  fails "BigDecimal#round BigDecimal::ROUND_CEILING rounds values towards +infinity" # ArgumentError: [BigDecimal#round] wrong number of arguments(2 for -1)
+  fails "BigDecimal#round BigDecimal::ROUND_DOWN rounds values towards zero" # ArgumentError: [BigDecimal#round] wrong number of arguments(2 for -1)
+  fails "BigDecimal#round BigDecimal::ROUND_FLOOR rounds values towards -infinity" # ArgumentError: [BigDecimal#round] wrong number of arguments(2 for -1)
+  fails "BigDecimal#round BigDecimal::ROUND_HALF_DOWN rounds values > 5 up, otherwise down" # ArgumentError: [BigDecimal#round] wrong number of arguments(2 for -1)
+  fails "BigDecimal#round BigDecimal::ROUND_HALF_EVEN rounds values > 5 up, < 5 down and == 5 towards even neighbor" # ArgumentError: [BigDecimal#round] wrong number of arguments(2 for -1)
+  fails "BigDecimal#round BigDecimal::ROUND_HALF_UP rounds values >= 5 up, otherwise down" # ArgumentError: [BigDecimal#round] wrong number of arguments(2 for -1)
+  fails "BigDecimal#round BigDecimal::ROUND_UP rounds values away from zero" # ArgumentError: [BigDecimal#round] wrong number of arguments(2 for -1)
+  fails "BigDecimal#round raise for a non-existent round mode" # ArgumentError: [BigDecimal#round] wrong number of arguments(2 for -1)
+  fails "BigDecimal#round uses default rounding method unless given"
+  fails "BigDecimal#sign returns negative value if BigDecimal less than 0"
+  fails "BigDecimal#sign returns positive value if BigDecimal greater than 0"
+  fails "BigDecimal#split first value: -1 for numbers < 0" # NoMethodError: undefined method `split' for 3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196442881097566593014782083152134043
+  fails "BigDecimal#split first value: 0 if BigDecimal is NaN" # NoMethodError: undefined method `split' for 3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196442881097566593014782083152134043
+  fails "BigDecimal#split first value: 1 for numbers > 0" # NoMethodError: undefined method `split' for 3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196442881097566593014782083152134043
+  fails "BigDecimal#split fourth value: the exponent" # NoMethodError: undefined method `split' for 3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196442881097566593014782083152134043
+  fails "BigDecimal#split second value: a string with the significant digits" # NoMethodError: undefined method `split' for 3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196442881097566593014782083152134043
+  fails "BigDecimal#split splits BigDecimal in an array with four values"
+  fails "BigDecimal#split third value: the base (currently always ten)" # NoMethodError: undefined method `split' for 3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196442881097566593014782083152134043
+  fails "BigDecimal#sqrt raises ArgumentError if 2 arguments are given"
+  fails "BigDecimal#sqrt raises ArgumentError if a negative number is given"
+  fails "BigDecimal#sqrt raises ArgumentError when no argument is given"
+  fails "BigDecimal#sqrt raises FloatDomainError for NaN"
+  fails "BigDecimal#sqrt raises FloatDomainError for negative infinity"
+  fails "BigDecimal#sqrt raises FloatDomainError on negative values"
+  fails "BigDecimal#sqrt raises TypeError if a plain Object is given"
+  fails "BigDecimal#sqrt raises TypeError if a string is given"
+  fails "BigDecimal#sqrt raises TypeError if nil is given"
+  fails "BigDecimal#sqrt returns 0 for 0, +0.0 and -0.0"
+  fails "BigDecimal#sqrt returns 1 if precision is 0 or 1"
+  fails "BigDecimal#sqrt returns positive infinity for infinity" # NoMethodError: undefined method `sqrt' for Infinity
+  fails "BigDecimal#sqrt returns positive infitinity for infinity"
+  fails "BigDecimal#sqrt returns square root of 0.9E-99999 with desired precision"
+  fails "BigDecimal#sqrt returns square root of 121 with desired precision"
+  fails "BigDecimal#sqrt returns square root of 2 with desired precision"
+  fails "BigDecimal#sqrt returns square root of 3 with desired precision"
+  fails "BigDecimal#sub with Object tries to coerce the other operand to self" # Mock 'Object' expected to receive coerce(123450000000000) exactly 1 times but received it 0 times
+  fails "BigDecimal#sub with Rational produces a BigDecimal" # Exception: lhs.$- is not a function
+  fails "BigDecimal#to_f properly handles special values"
+  fails "BigDecimal#to_f remembers negative zero when converted to float"
+  fails "BigDecimal#to_i raises FloatDomainError if BigDecimal is infinity or NaN"
+  fails "BigDecimal#to_i returns Integer or Bignum otherwise"
+  fails "BigDecimal#to_i returns Integer otherwise" # NoMethodError: undefined method `to_i' for 3e-20001
+  fails "BigDecimal#to_int raises FloatDomainError if BigDecimal is infinity or NaN"
+  fails "BigDecimal#to_int returns Integer or Bignum otherwise"
+  fails "BigDecimal#to_int returns Integer otherwise" # NoMethodError: undefined method `to_i' for 3e-20001
+  fails "BigDecimal#to_r returns a Rational with bignum values" # NoMethodError: undefined method `to_r' for 3.141592653589793238462643
+  fails "BigDecimal#to_r returns a Rational" # NoMethodError: undefined method `to_r' for 3.14159
+  fails "BigDecimal#to_s can return a leading space for values > 0"
+  fails "BigDecimal#to_s can use conventional floating point notation"
+  fails "BigDecimal#to_s can use engineering notation"
+  fails "BigDecimal#to_s does not add an exponent for zero values" # Exception: self.$BigDecimal(...).$to_s is not a function
+  fails "BigDecimal#to_s inserts a space every n chars, if integer n is supplied"
+  fails "BigDecimal#to_s removes trailing spaces in floating point notation"
+  fails "BigDecimal#to_s return type is of class String" # Exception: self.bigdec.$to_s is not a function
+  fails "BigDecimal#to_s returns a String in US-ASCII encoding when Encoding.default_internal is nil" # NoMethodError: undefined method `default_internal' for Encoding
+  fails "BigDecimal#to_s returns a String in US-ASCII encoding when Encoding.default_internal is not nil" # NoMethodError: undefined method `default_internal' for Encoding
+  fails "BigDecimal#to_s starts with + if + is supplied and value is positive"
+  fails "BigDecimal#to_s takes an optional argument" # Expected to not get Exception
+  fails "BigDecimal#to_s the default format looks like 0.xxxxEnn"
+  fails "BigDecimal#to_s the default format looks like 0.xxxxenn" # Expected "3.14159265358979323846264338327950288419716939937" to match /^0\.[0-9]*e[0-9]*$/
+  fails "BigDecimal#truncate returns Infinity if self is infinite"
+  fails "BigDecimal#truncate returns the same value if self is special value"
+  fails "BigDecimal#truncate returns value of given precision otherwise"
+  fails "BigDecimal.double_fig returns the number of digits a Float number is allowed to have"
+  fails "BigDecimal.limit picks the global precision when limit 0 specified" # Expected 0.8888 to equal 0.889
+  fails "BigDecimal.limit picks the specified precision over global limit" # Expected 0.888 to equal 0.89
+  fails "BigDecimal.limit returns the value before set if the passed argument is nil or is not specified"
+  fails "BigDecimal.limit use the global limit if no precision is specified"
+  fails "BigDecimal.limit uses the global limit if no precision is specified" # Expected 0.888 to equal 0.9
+  fails "BigDecimal.mode raise an exception if the flag is true"
+  fails "BigDecimal.mode returns Infinity when too big"
+  fails "BigDecimal.mode returns the appropriate value and continue the computation if the flag is false"
+  fails "BigDecimal.new accepts significant digits >= given precision" # NoMethodError: undefined method `precs' for 3.1415923
+  fails "BigDecimal.new allows for [eEdD] as exponent separator"
+  fails "BigDecimal.new allows for underscores in all parts"
+  fails "BigDecimal.new creates a new object of class BigDecimal"
+  fails "BigDecimal.new determines precision from initial value"
+  fails "BigDecimal.new ignores trailing garbage"
+  fails "BigDecimal.new raises ArgumentError for invalid strings" # Exception: new BigNumber() not a number: ruby
+  fails "BigDecimal.new raises ArgumentError when Float is used without precision"
+  fails "BigDecimal.new treats invalid strings as 0.0"
+  fails "BigDecimal.ver returns the Version number"
+  fails "Float#to_d returns appropriate BigDecimal zero for signed zero" # NoMethodError: undefined method `to_d' for 0
+  fails "Kernel#BigDecimal BigDecimal(Rational) with bigger-than-double numerator" # Expected 1000000000000000000 > 18446744073709552000 to be truthy but was false
+  fails "Kernel#BigDecimal accepts significant digits >= given precision" # NoMethodError: undefined method `precs' for 3.1415923
+  fails "Kernel#BigDecimal allows for [eEdD] as exponent separator" # Exception: new BigNumber() not a number: 12345.67d89
+  fails "Kernel#BigDecimal allows for underscores in all parts" # Exception: new BigNumber() not a number: 12_345.67E89
+  fails "Kernel#BigDecimal coerces the value argument with #to_str" # Exception: new BigNumber() not a number: #<MockObject:0x666>
+  fails "Kernel#BigDecimal creates a new object of class BigDecimal" # Expected 1 to equal (1/1)
+  fails "Kernel#BigDecimal determines precision from initial value" # NoMethodError: undefined method `precs' for 3.14159265358979323846264338327950288419716939937510582097494459230781640628620899862803482534211706798214808651328230664709384460955058223172535940812848111745028410270193852110555964462294895493038196442881097566593014782083152134043
+  fails "Kernel#BigDecimal does not call to_s when calling inspect" # Expected "44.44" == "0.4444e2" to be truthy but was false
+  fails "Kernel#BigDecimal does not ignores trailing garbage" # Expected ArgumentError but got: Exception (new BigNumber() not a number: 123E45ruby)
+  fails "Kernel#BigDecimal ignores leading whitespace" # Exception: self.$BigDecimal(...).$should is not a function
+  fails "Kernel#BigDecimal ignores trailing garbage" # Exception: new BigNumber() not a number: 123E45ruby
+  fails "Kernel#BigDecimal pre-coerces long integers" # Expected 262000 == 1130000000000000 to be truthy but was false
+  fails "Kernel#BigDecimal process underscores as Float()" # Exception: new BigNumber() not a number: 12_345.67E89
+  fails "Kernel#BigDecimal raises ArgumentError for invalid strings" # Exception: new BigNumber() not a number: ruby
+  fails "Kernel#BigDecimal raises ArgumentError when Float is used without precision" # Expected ArgumentError but no exception was raised (1 was returned)
+  fails "Kernel#BigDecimal when interacting with Rational BigDecimal maximum precision is nine more than precision except for abnormals" # TypeError: Rational can't be coerced into BigDecimal
+  fails "Kernel#BigDecimal when interacting with Rational BigDecimal precision is the number of digits rounded up to a multiple of nine" # TypeError: Rational can't be coerced into BigDecimal
+  fails "Kernel#BigDecimal when interacting with Rational BigDecimal(Rational, 18) produces the result we expect" # TypeError: Rational can't be coerced into BigDecimal
+  fails "Kernel#BigDecimal when interacting with Rational BigDecimal(Rational, BigDecimal.precs[0]) produces the result we expect" # TypeError: Rational can't be coerced into BigDecimal
+  fails "Kernel#BigDecimal when interacting with Rational has the LHS print as expected" # TypeError: Rational can't be coerced into BigDecimal
+  fails "Kernel#BigDecimal when interacting with Rational has the RHS print as expected" # TypeError: Rational can't be coerced into BigDecimal
+  fails "Kernel#BigDecimal when interacting with Rational has the expected maximum precision on the LHS" # TypeError: Rational can't be coerced into BigDecimal
+  fails "Kernel#BigDecimal when interacting with Rational has the expected precision on the LHS" # TypeError: Rational can't be coerced into BigDecimal
+  fails "Kernel#BigDecimal when interacting with Rational produces a BigDecimal" # TypeError: Rational can't be coerced into BigDecimal
+  fails "Kernel#BigDecimal when interacting with Rational produces the correct class for other arithmetic operators" # TypeError: Rational can't be coerced into BigDecimal
+  fails "Kernel#BigDecimal when interacting with Rational produces the expected result when done via Float" # TypeError: Rational can't be coerced into BigDecimal
+  fails "Kernel#BigDecimal when interacting with Rational produces the expected result when done via to_f" # TypeError: Rational can't be coerced into BigDecimal
+  fails "Kernel#BigDecimal when interacting with Rational produces the expected result" # TypeError: Rational can't be coerced into BigDecimal
+  fails "Kernel#BigDecimal with exception: false returns nil for invalid strings" # Exception: new BigNumber() not a number: invalid
+  fails "Kernel#Pathname is a private instance method" # Expected Kernel to have private instance method 'Pathname' but it does not
+end