opal 1.0.5 → 1.1.0.rc1

data/spec/filters/unsupported/integer.rb

@@ -0,0 +1,101 @@
+# NOTE: run bin/format-filters after changing this file
+opal_unsupported_filter "Integer" do
+  fails "Integer#% bignum returns the modulus obtained from dividing self by the given argument" # Expected 0 to equal 9223372036854776000
+  fails "Integer#& bignum raises a TypeError when passed a Float" # Expected TypeError but no exception was raised (0 was returned)
+  fails "Integer#& bignum returns self bitwise AND other when both operands are negative" # Expected 0 to equal -13835058055282164000
+  fails "Integer#& bignum returns self bitwise AND other when one operand is negative" # Expected 0 to equal 18446744073709552000
+  fails "Integer#& bignum returns self bitwise AND other" # Expected 0 to equal 1
+  fails "Integer#& fixnum returns self bitwise AND a bignum" # Expected 0 to equal 18446744073709552000
+  fails "Integer#& fixnum returns self bitwise AND other" # Actually uses Bignums
+  fails "Integer#* bignum returns self multiplied by the given Integer" # Expected 8.507059173023462e+37 to equal 8.507059173023463e+37
+  fails "Integer#** fixnum can raise -1 to a bignum safely" # Expected 1 to have same value and type as -1
+  fails "Integer#- bignum returns self minus the given Integer" # Expected 0 to equal 272
+  fails "Integer#/ bignum raises a ZeroDivisionError if other is zero and not a Float" # Expected ZeroDivisionError but no exception was raised (Infinity was returned)
+  fails "Integer#/ bignum returns self divided by other" # Expected 10000000000 to equal 9999999999
+  fails "Integer#< bignum returns true if self is less than the given argument" # Expected false to equal true
+  fails "Integer#<< (with n << m) bignum calls #to_int to convert the argument to an Integer" # Expected 0 to equal 2.3611832414348226e+21
+  fails "Integer#<< (with n << m) bignum returns n shifted left m bits when n < 0, m > 0" # Expected 0 to equal -7.555786372591432e+22
+  fails "Integer#<< (with n << m) bignum returns n shifted left m bits when n > 0, m > 0" # Expected 0 to equal 2.3611832414348226e+21
+  fails "Integer#<< (with n << m) bignum returns n shifted right m bits when n < 0, m < 0" # Expected 0 to equal -36893488147419103000
+  fails "Integer#<< (with n << m) bignum returns n shifted right m bits when n > 0, m < 0" # Expected 0 to equal 73786976294838210000
+  fails "Integer#<< (with n << m) bignum returns n when n < 0, m == 0" # Expected 0 to equal -147573952589676410000
+  fails "Integer#<< (with n << m) bignum returns n when n > 0, m == 0" # Expected 0 to equal 147573952589676410000
+  fails "Integer#<< (with n << m) fixnum returns 0 when m < 0 and m is a Bignum" # Expected 3 to equal 0
+  fails "Integer#<< (with n << m) fixnum returns an Bignum == fixnum_max * 2 when fixnum_max << 1 and n > 0" # Expected 2147483646 (Number) to be an instance of Bignum
+  fails "Integer#<< (with n << m) fixnum returns an Bignum == fixnum_min * 2 when fixnum_min << 1 and n < 0" # Expected -2147483648 (Number) to be an instance of Bignum
+  fails "Integer#<= bignum returns false if compares with near float" # Expected true to equal false
+  fails "Integer#<=> bignum with a Bignum when other is negative returns -1 when self is negative and other is larger" # Expected 0 to equal -1
+  fails "Integer#<=> bignum with a Bignum when other is negative returns 1 when self is negative and other is smaller" # Expected 0 to equal 1
+  fails "Integer#<=> bignum with a Bignum when other is positive returns -1 when self is positive and other is larger" # Expected 0 to equal -1
+  fails "Integer#<=> bignum with a Bignum when other is positive returns 1 when other is smaller" # Expected 0 to equal 1
+  fails "Integer#<=> bignum with an Object returns -1 if the coerced value is larger" # Expected 0 to equal -1
+  fails "Integer#<=> bignum with an Object returns nil if #coerce does not return an Array" # Expected 0 to be nil
+  fails "Integer#== bignum returns the result of 'other == self' as a boolean" # Expected "woot" to equal true
+  fails "Integer#== bignum returns true if self has the same value as the given argument" # Expected true to equal false
+  fails "Integer#=== bignum returns the result of 'other == self' as a boolean" # Expected "woot" to equal true
+  fails "Integer#=== bignum returns true if self has the same value as the given argument" # Expected true to equal false
+  fails "Integer#> bignum returns true if self is greater than the given argument" # Expected false to equal true
+  fails "Integer#>= bignum returns true if self is greater than or equal to other" # Expected true to equal false
+  fails "Integer#>> (with n >> m) bignum calls #to_int to convert the argument to an Integer" # Expected 0 to equal 36893488147419103000
+  fails "Integer#>> (with n >> m) bignum respects twos complement signed shifting for very large values" # Expected 0 to equal 2.2204460502842888e+66
+  fails "Integer#>> (with n >> m) bignum respects twos complement signed shifting" # Expected 101376 to equal -2621440001220703000
+  fails "Integer#>> (with n >> m) bignum returns n shifted left m bits when  n < 0, m < 0" # Expected 0 to equal -1.1805916207174113e+21
+  fails "Integer#>> (with n >> m) bignum returns n shifted left m bits when  n > 0, m < 0" # Expected 0 to equal 590295810358705700000
+  fails "Integer#>> (with n >> m) bignum returns n shifted right m bits when n < 0, m > 0" # Expected 0 to equal -36893488147419103000
+  fails "Integer#>> (with n >> m) bignum returns n shifted right m bits when n > 0, m > 0" # Expected 0 to equal 73786976294838210000
+  fails "Integer#>> (with n >> m) bignum returns n when n < 0, m == 0" # Expected 0 to equal -147573952589676410000
+  fails "Integer#>> (with n >> m) bignum returns n when n > 0, m == 0" # Expected 0 to equal 147573952589676410000
+  fails "Integer#>> (with n >> m) fixnum returns 0 when m is a bignum" # Expected 3 to equal 0
+  fails "Integer#>> (with n >> m) fixnum returns an Bignum == fixnum_max * 2 when fixnum_max >> -1 and n > 0" # NameError: uninitialized constant Bignum
+  fails "Integer#>> (with n >> m) fixnum returns an Bignum == fixnum_min * 2 when fixnum_min >> -1 and n < 0" # NameError: uninitialized constant Bignum
+  fails "Integer#[] bignum returns the nth bit in the binary representation of self" # Expected 0 to equal 1
+  fails "Integer#[] bignum tries to convert the given argument to an Integer using #to_int" # Expected 0 to equal 1
+  fails "Integer#^ bignum raises a TypeError when passed a Float" # Expected TypeError but no exception was raised (14 was returned)
+  fails "Integer#^ bignum returns self bitwise EXCLUSIVE OR other when all bits are 1 and other value is negative" # Expected -1 to equal -9.903520314283042e+27
+  fails "Integer#^ bignum returns self bitwise EXCLUSIVE OR other when both operands are negative" # Expected 0 to equal 64563604257983430000
+  fails "Integer#^ bignum returns self bitwise EXCLUSIVE OR other when one operand is negative" # Expected 0 to equal -64563604257983430000
+  fails "Integer#^ bignum returns self bitwise EXCLUSIVE OR other" # Expected 2 to equal 9223372036854776000
+  fails "Integer#^ fixnum returns self bitwise EXCLUSIVE OR a bignum" # Expected -1 to equal -18446744073709552000
+  fails "Integer#bit_length bignum returns the position of the leftmost 0 bit of a negative number" # NoMethodError: undefined method `bit_length` for -Infinity:Float
+  fails "Integer#bit_length bignum returns the position of the leftmost bit of a positive number" # Expected 1 to equal 1000
+  fails "Integer#coerce bignum coerces other to a Bignum and returns [other, self] when passed a Fixnum" # NameError: uninitialized constant Bignum
+  fails "Integer#coerce bignum raises a TypeError when not passed a Fixnum or Bignum" # ArgumentError: invalid value for Float(): "test"
+  fails "Integer#coerce bignum returns [other, self] when passed a Bignum" # NameError: uninitialized constant Bignum
+  fails "Integer#div bignum calls #coerce and #div if argument responds to #coerce" # Mock 'x' expected to receive div(main) exactly 1 times but received it 0 times
+  fails "Integer#div bignum looses precision if passed Float argument" # Expected 9223372036854776000 not to equal 9223372036854776000
+  fails "Integer#div bignum returns self divided by other" # Expected 10000000000 to equal 9999999999
+  fails "Integer#divmod bignum raises a TypeError when the given argument is not an Integer" # NoMethodError: undefined method `nan?' for main
+  fails "Integer#divmod bignum returns an Array containing quotient and modulus obtained from dividing self by the given argument" # Expected [2305843009213694000, 0] to equal [2305843009213694000, 3]
+  fails "Integer#divmod bignum with q = floor(x/y), a = q*b + r, returns [q,r] when a < 0, b < 0 and |a| < |b|" # Expected [1, 0] to equal [0, -9223372036854776000]
+  fails "Integer#divmod bignum with q = floor(x/y), a = q*b + r, returns [q,r] when a < 0, b > 0 and |a| < b" # Expected [-1, 0] to equal [-1, 1]
+  fails "Integer#divmod bignum with q = floor(x/y), a = q*b + r, returns [q,r] when a > 0, b < 0 and a < |b|" # Expected [-1, 0] to equal [-1, -1]
+  fails "Integer#divmod bignum with q = floor(x/y), a = q*b + r, returns [q,r] when a > 0, b < 0 and a > |b|" # Expected [-1, 0] to equal [-2, -9223372036854776000]
+  fails "Integer#even? fixnum returns true for a Bignum when it is an even number" # Expected true to be false
+  fails "Integer#even? returns true for a Bignum when it is an even number"
+  fails "Integer#modulo bignum returns the modulus obtained from dividing self by the given argument" # Expected 0 to equal 9223372036854776000
+  fails "Integer#odd? bignum returns false if self is even and negative" # Expected true to be false
+  fails "Integer#odd? bignum returns true if self is odd and positive" # Expected false to be true
+  fails "Integer#pow one argument is passed bignum raises a TypeError when given a non-Integer" # NoMethodError: undefined method `pow' for 9223372036854776000
+  fails "Integer#pow one argument is passed bignum returns a complex number when negative and raised to a fractional power" # NoMethodError: undefined method `pow' for -9223372036854776000
+  fails "Integer#pow one argument is passed bignum returns self raised to other power" # NoMethodError: undefined method `pow' for 9223372036854776000
+  fails "Integer#pow one argument is passed bignum switch to a Float when the values is too big" # NoMethodError: undefined method `pow' for 9223372036854776000
+  fails "Integer#pow one argument is passed fixnum can raise -1 to a bignum safely" # NoMethodError: undefined method `pow' for -1
+  fails "Integer#pow one argument is passed fixnum can raise 1 to a bignum safely" # NoMethodError: undefined method `pow' for 1
+  fails "Integer#pow one argument is passed fixnum overflows the answer to a bignum transparently" # NoMethodError: undefined method `pow' for 2
+  fails "Integer#pow one argument is passed fixnum returns Float::INFINITY for 0 ** -1.0" # Depends on the difference between Integer and Float
+  fails "Integer#pow two arguments are passed ensures all arguments are integers" # Depends on the difference between Integer and Float
+  fails "Integer#pow two arguments are passed works well with bignums" # NoMethodError: undefined method `pow' for 2
+  fails "Integer#remainder bignum does raises ZeroDivisionError if other is zero and a Float" # NoMethodError: undefined method `remainder' for 9223372036854776000
+  fails "Integer#remainder bignum raises a ZeroDivisionError if other is zero and not a Float" # NoMethodError: undefined method `remainder' for 9223372036854776000
+  fails "Integer#remainder bignum returns the remainder of dividing self by other" # NoMethodError: undefined method `remainder' for 9223372036854776000
+  fails "Integer#size bignum returns the number of bytes required to hold the unsigned bignum data" # Expected 4 to equal 8
+  fails "Integer#| bignum raises a TypeError when passed a Float" # Expected TypeError but no exception was raised (9 was returned)
+  fails "Integer#| bignum returns self bitwise OR other when both operands are negative" # Expected 0 to equal -1
+  fails "Integer#| bignum returns self bitwise OR other when one operand is negative" # Expected 0 to equal -64563604257983430000
+  fails "Integer#| bignum returns self bitwise OR other" # Expected 2 to equal 9223372036854776000
+  fails "Integer#~ bignum returns self with each bit flipped" # Expected -1 to equal -9223372036854776000
+  fails "String#to_r does not treat a leading period without a numeric prefix as a decimal point" # Expected (8106479329266893/9007199254740992) not to equal (8106479329266893/9007199254740992)
+  fails "String#to_r ignores underscores between numbers" # Expected (-5228919960423629/274877906944) to equal (-190227/10)
+  fails "String#to_r understands a forward slash as separating the numerator from the denominator" # Expected (-896028675862255/140737488355328) to equal (-191/30)
+  fails "String#to_r understands decimal points" # Expected (1874623344892969/562949953421312) to equal (333/100)
+end

data/spec/filters/unsupported/kernel.rb

@@ -0,0 +1,35 @@
+# NOTE: run bin/format-filters after changing this file
+opal_unsupported_filter "Kernel" do
+  fails "Kernel has private instance method Array()"
+  fails "Kernel has private instance method Hash()"
+  fails "Kernel#Float is a private method"
+  fails "Kernel#Float raises a TypeError if #to_f returns an Integer"
+  fails "Kernel#Integer calls to_i on Rationals"
+  fails "Kernel#Integer is a private method"
+  fails "Kernel#Integer returns a Fixnum or Bignum object"
+  fails "Kernel#String is a private method"
+  fails "Kernel#class returns the first non-singleton class" # TypeError: can't define singleton
+  fails "Kernel#clone preserves tainted state from the original"
+  fails "Kernel#clone preserves untrusted state from the original"
+  fails "Kernel#clone raises a TypeError for Symbol"
+  fails "Kernel#dup does not copy frozen state from the original"
+  fails "Kernel#dup preserves tainted state from the original"
+  fails "Kernel#dup preserves untrusted state from the original"
+  fails "Kernel#dup raises a TypeError for Symbol"
+  fails "Kernel#eql? is a public instance method"
+  fails "Kernel#fail is a private method"
+  fails "Kernel#format is a private method"
+  fails "Kernel#inspect returns an untrusted string if self is untrusted"
+  fails "Kernel#raise is a private method"
+  fails "Kernel#sleep accepts a Rational"
+  fails "Kernel#sleep is a private method"
+  fails "Kernel#sleep pauses execution indefinitely if not given a duration"
+  fails "Kernel#sprintf is a private method"
+  fails "Kernel#to_s returns a tainted result if self is tainted"
+  fails "Kernel#to_s returns an untrusted result if self is untrusted"
+  fails "Kernel#warn is a private method"
+  fails "Kernel.Float raises a TypeError if #to_f returns an Integer"
+  fails "Kernel.Integer calls to_i on Rationals"
+  fails "Kernel.Integer returns a Fixnum or Bignum object"
+  fails "Kernel.fail is a private method"
+end

data/spec/filters/unsupported/language.rb

@@ -0,0 +1,25 @@
+# NOTE: run bin/format-filters after changing this file
+opal_unsupported_filter "language" do
+  fails "Magic comment can be after the shebang"
+  fails "Magic comment can take Emacs style"
+  fails "Magic comment can take vim style"
+  fails "Magic comment determines __ENCODING__"
+  fails "Magic comment is case-insensitive"
+  fails "Magic comment must be at the first line"
+  fails "Magic comment must be the first token of the line"
+  fails "Ruby String literals with a magic frozen comment produce different objects for literals with the same content in different files if the other file doesn't have the comment"
+  fails "Ruby String literals with a magic frozen comment produce different objects for literals with the same content in different files if they have different encodings"
+  fails "Ruby String literals with a magic frozen comment produce the same object each time"
+  fails "Ruby String literals with a magic frozen comment produce the same object for literals with the same content in different files"
+  fails "Ruby String literals with a magic frozen comment produce the same object for literals with the same content"
+  fails "The defined? keyword for pseudo-variables returns 'expression' for __ENCODING__"
+  fails "The defined? keyword when called with a method name having a module as receiver returns nil if the method is private"
+  fails "The defined? keyword when called with a method name having a module as receiver returns nil if the method is protected"
+  fails "The private keyword changes the visibility of the existing method in the subclass"
+  fails "The private keyword changes visibility of previously called method"
+  fails "The private keyword changes visibility of previously called methods with same send/call site" # Expected NoMethodError but no exception was raised (2 was returned)
+  fails "The private keyword is overridden when a new class is opened"
+  fails "The private keyword marks following methods as being private"
+  fails "rescuing Interrupt raises an Interrupt when sent a signal SIGINT" # NoMethodError: undefined method `kill' for Process
+  fails "rescuing SignalException raises a SignalException when sent a signal" # NoMethodError: undefined method `kill' for Process
+end

data/spec/filters/unsupported/marshal.rb

@@ -0,0 +1,44 @@
+# NOTE: run bin/format-filters after changing this file
+opal_unsupported_filter "Marshal" do
+  fails "Marshal.dump dumps subsequent appearances of a symbol as a link" # depends on Symbol-s
+  fails "Marshal.dump raises a TypeError if dumping a IO/File instance"
+  fails "Marshal.dump returns a tainted string if nested object is tainted"
+  fails "Marshal.dump returns a tainted string if object is tainted"
+  fails "Marshal.dump returns a trusted string if object is trusted"
+  fails "Marshal.dump returns an untainted string if object is untainted"
+  fails "Marshal.dump returns an untrusted string if nested object is untrusted"
+  fails "Marshal.dump returns an untrusted string if object is untrusted"
+  fails "Marshal.dump when passed an IO raises an Error when the IO-Object does not respond to #write"
+  fails "Marshal.dump when passed an IO returns the IO-Object"
+  fails "Marshal.dump when passed an IO writes the serialized data to the IO-Object"
+  fails "Marshal.dump with a Float dumps a Float" # depends on the string mutating, replaced with test in spec/opal
+  fails "Marshal.dump with a Regexp dumps a Regexp in another encoding"
+  fails "Marshal.dump with a Regexp dumps a Regexp with flags" # depends on string encoding, replaced with test in spec/opal
+  fails "Marshal.dump with a Regexp dumps a Regexp" # depends on utf-8 encoding which is not required, replaced with test in spec/opal
+  fails "Marshal.dump with a Regexp dumps a UTF-8 Regexp"
+  fails "Marshal.dump with a Regexp dumps a binary Regexp"
+  fails "Marshal.dump with a Regexp dumps an extended Regexp" # depends on string encoding, replaced with test in spec/opal
+  fails "Marshal.dump with a String dumps a String extended with a Module" # depends on string mutation
+  fails "Marshal.dump with a String dumps a String with instance variables"  # depends on string mutation
+  fails "Marshal.dump with an object responding to #marshal_dump dumps the object returned by #marshal_dump" # depends on Symbol-s, replaced with test in spec/opal
+  fails "Marshal.load for a Hash preserves hash ivars when hash contains a string having ivar" # depends on String#instance_variable_set
+  fails "Marshal.load for a String loads a string having ivar with ref to self" # depends on string mutation
+  fails "Marshal.load for a String loads a string through StringIO stream"
+  fails "Marshal.load for a String loads a string with an ivar" # depends on string mutation
+  fails "Marshal.load for a wrapped C pointer loads"
+  fails "Marshal.load for a wrapped C pointer raises ArgumentError when the local class is a regular object"
+  fails "Marshal.load for a wrapped C pointer raises TypeError when the local class is missing _load_data"
+  fails "Marshal.load for an Array loads an array having ivar" # for some reason depends on String#instance_variable_set which is not supported. replaced with test in spec/opal
+  fails "Marshal.load loads a Random" # depends on the reading from the filesystem
+  fails "Marshal.load preserves taintedness of nested structure"
+  fails "Marshal.load raises EOFError on loading an empty file"
+  fails "Marshal.load raises a TypeError with bad Marshal version" # depends on String#[]=
+  fails "Marshal.load returns a trusted object if source is trusted"
+  fails "Marshal.load returns an untainted object if source is untainted"
+  fails "Marshal.load returns an untrusted object if source is untrusted"
+  fails "Marshal.load when source is tainted does not taint Bignums"
+  fails "Marshal.load when source is tainted does not taint Fixnums"
+  fails "Marshal.load when source is tainted does not taint Floats"
+  fails "Marshal.load when source is tainted does not taint Symbols"
+  fails "Marshal.load when source is tainted returns a tainted object"
+end

data/spec/filters/unsupported/matchdata.rb

@@ -0,0 +1,63 @@
+# NOTE: run bin/format-filters after changing this file
+opal_unsupported_filter "MatchData" do
+  fails "MatchData#[Symbol] raises an IndexError if there is no named match corresponding to the String"
+  fails "MatchData#[Symbol] raises an IndexError if there is no named match corresponding to the Symbol"
+  fails "MatchData#[Symbol] returns matches in the String's encoding"
+  fails "MatchData#[Symbol] returns nil on non-matching named matches"
+  fails "MatchData#[Symbol] returns the corresponding named match when given a String"
+  fails "MatchData#[Symbol] returns the corresponding named match when given a Symbol"
+  fails "MatchData#[Symbol] returns the last match when multiple named matches exist with the same name"
+  fails "MatchData#[Symbol] returns the matching version of multiple corresponding named match"
+  fails "MatchData#begin returns nil when the nth match isn't found"
+  fails "MatchData#begin returns the offset for multi byte strings with unicode regexp"
+  fails "MatchData#begin returns the offset for multi byte strings"
+  fails "MatchData#begin returns the offset of the start of the nth element"
+  fails "MatchData#begin when passed a String argument return the character offset of the start of the named capture" # Exception: named captures are not supported in javascript: "(?<a>.)(.)(?<b>\d+)(\d)"
+  fails "MatchData#begin when passed a String argument returns the character offset for multi byte strings" # Exception: named captures are not supported in javascript: "(?<a>.)(.)(?<b>\d+)(\d)"
+  fails "MatchData#begin when passed a String argument returns the character offset for multi-byte names" # Exception: named captures are not supported in javascript: "(?<æ>.)(.)(?<b>\d+)(\d)"
+  fails "MatchData#begin when passed a String argument returns the character offset for the farthest match when multiple named captures use the same name" # Exception: named captures are not supported in javascript: "(?<a>.)(.)(?<a>\d+)(\d)"
+  fails "MatchData#begin when passed a Symbol argument return the character offset of the start of the named capture" # Exception: named captures are not supported in javascript: "(?<a>.)(.)(?<b>\d+)(\d)"
+  fails "MatchData#begin when passed a Symbol argument returns the character offset for multi byte strings" # Exception: named captures are not supported in javascript: "(?<a>.)(.)(?<b>\d+)(\d)"
+  fails "MatchData#begin when passed a Symbol argument returns the character offset for multi-byte names" # Exception: named captures are not supported in javascript: "(?<æ>.)(.)(?<b>\d+)(\d)"
+  fails "MatchData#begin when passed a Symbol argument returns the character offset for the farthest match when multiple named captures use the same name" # Exception: named captures are not supported in javascript: "(?<a>.)(.)(?<a>\d+)(\d)"
+  fails "MatchData#begin when passed an integer argument returns nil when the nth match isn't found" # ArgumentError: MatchData#begin only supports 0th element
+  fails "MatchData#begin when passed an integer argument returns the character offset for multi-byte strings" # ArgumentError: MatchData#begin only supports 0th element
+  fails "MatchData#begin when passed an integer argument returns the character offset of the start of the nth element" # ArgumentError: MatchData#begin only supports 0th element
+  fails "MatchData#begin when passed an integer argument tries to convert the passed argument to an Integer using #to_int" # ArgumentError: MatchData#begin only supports 0th element
+  fails "MatchData#end returns nil when the nth match isn't found"
+  fails "MatchData#end returns the offset for multi byte strings with unicode regexp"
+  fails "MatchData#end returns the offset for multi byte strings"
+  fails "MatchData#end returns the offset of the end of the nth element"
+  fails "MatchData#end when passed a String argument return the character offset of the start of the named capture" # Exception: named captures are not supported in javascript: "(?<a>.)(.)(?<b>\d+)(\d)"
+  fails "MatchData#end when passed a String argument returns the character offset for multi byte strings" # Exception: named captures are not supported in javascript: "(?<a>.)(.)(?<b>\d+)(\d)"
+  fails "MatchData#end when passed a String argument returns the character offset for multi-byte names" # Exception: named captures are not supported in javascript: "(?<æ>.)(.)(?<b>\d+)(\d)"
+  fails "MatchData#end when passed a String argument returns the character offset for the farthest match when multiple named captures use the same name" # Exception: named captures are not supported in javascript: "(?<a>.)(.)(?<a>\d+)(\d)"
+  fails "MatchData#end when passed a Symbol argument return the character offset of the start of the named capture" # Exception: named captures are not supported in javascript: "(?<a>.)(.)(?<b>\d+)(\d)"
+  fails "MatchData#end when passed a Symbol argument returns the character offset for multi byte strings" # Exception: named captures are not supported in javascript: "(?<a>.)(.)(?<b>\d+)(\d)"
+  fails "MatchData#end when passed a Symbol argument returns the character offset for multi-byte names" # Exception: named captures are not supported in javascript: "(?<æ>.)(.)(?<b>\d+)(\d)"
+  fails "MatchData#end when passed a Symbol argument returns the character offset for the farthest match when multiple named captures use the same name" # Exception: named captures are not supported in javascript: "(?<a>.)(.)(?<a>\d+)(\d)"
+  fails "MatchData#end when passed an integer argument returns nil when the nth match isn't found" # ArgumentError: MatchData#end only supports 0th element
+  fails "MatchData#end when passed an integer argument returns the character offset for multi-byte strings" # ArgumentError: MatchData#end only supports 0th element
+  fails "MatchData#end when passed an integer argument returns the character offset of the end of the nth element" # ArgumentError: MatchData#end only supports 0th element
+  fails "MatchData#end when passed an integer argument tries to convert the passed argument to an Integer using #to_int" # ArgumentError: MatchData#end only supports 0th element
+  fails "MatchData#named_captures prefers later captures" # Exception: named captures are not supported in javascript: "^(?<a>.)(?<b>.)(?<b>.)(?<a>.)$"
+  fails "MatchData#named_captures returns a Hash that has captured name and the matched string pairs" # Exception: named captures are not supported in javascript: "(?<a>.)(?<b>.)?"
+  fails "MatchData#named_captures returns the latest matched capture, even if a later one that does not match exists" # Exception: named captures are not supported in javascript: "^(?<a>.)(?<b>.)(?<b>.)(?<a>.)?$"
+  fails "MatchData#names equals Regexp#names"
+  fails "MatchData#names returns [] if there were no named captures"
+  fails "MatchData#names returns an Array"
+  fails "MatchData#names returns each name only once"
+  fails "MatchData#names returns the names of the named capture groups"
+  fails "MatchData#names sets each element to a String"
+  fails "MatchData#offset returns [nil, nil] when the nth match isn't found"
+  fails "MatchData#offset returns a two element array with the begin and end of the nth match"
+  fails "MatchData#offset returns the offset for multi byte strings with unicode regexp"
+  fails "MatchData#offset returns the offset for multi byte strings"
+  fails "MatchData#post_match keeps taint status from the source string"
+  fails "MatchData#post_match keeps untrusted status from the source string"
+  fails "MatchData#pre_match keeps taint status from the source string"
+  fails "MatchData#pre_match keeps untrusted status from the source string"
+  fails "MatchData#regexp returns the pattern used in the match"
+  fails "MatchData#values_at slices captures with the given names" # Exception: named captures are not supported in javascript: "(?<a>.)(?<b>.)(?<c>.)"
+  fails "MatchData#values_at takes names and indices" # Exception: named captures are not supported in javascript: "^(?<a>.)(?<b>.)$"
+end

data/spec/filters/unsupported/math.rb

@@ -0,0 +1,4 @@
+# NOTE: run bin/format-filters after changing this file
+opal_unsupported_filter "Math" do
+  fails "Math#atanh is a private instance method"
+end

data/spec/filters/unsupported/pathname.rb

@@ -0,0 +1,4 @@
+# NOTE: run bin/format-filters after changing this file
+opal_unsupported_filter "Pathname" do
+  fails "Pathname.new is tainted if path is tainted"
+end

data/spec/filters/unsupported/privacy.rb

@@ -0,0 +1,287 @@
+# NOTE: run bin/format-filters after changing this file
+opal_unsupported_filter "private" do
+  fails "A method definition always resets the visibility to public for nested definitions at the toplevel" # Expected NoMethodError (/private/) but no exception was raised ("nested_method_in_toplevel_method" was returned)
+  fails "A method definition always resets the visibility to public for nested definitions in Class.new" # Expected NoMethodError (/private/) but no exception was raised ("new_def" was returned)
+  fails "BasicObject#initialize is a private instance method"
+  fails "BasicObject#method_missing for a Class raises a NoMethodError when an undefined method is called"
+  fails "BasicObject#method_missing is a private method"
+  fails "BasicObject#singleton_method_added is a private method"
+  fails "BasicObject#singleton_method_removed is a private method"
+  fails "BasicObject#singleton_method_undefined is a private method"
+  fails "Defining a 'respond_to_missing?' method sets the method's visibility to private"
+  fails "Defining a method at the top-level defines it on Object with private visibility by default"
+  fails "Defining an 'initialize' method sets the method's visibility to private"
+  fails "Defining an 'initialize_clone' method sets the method's visibility to private"
+  fails "Defining an 'initialize_copy' method sets the method's visibility to private"
+  fails "Defining an 'initialize_dup' method sets the method's visibility to private"
+  fails "Enumerator#initialize is a private method"
+  fails "Invoking a private getter method does not permit self as a receiver"
+  fails "Kernel#block_given? is a private method"
+  fails "Kernel#eval is a private method"
+  fails "Kernel#iterator? is a private method"
+  fails "Kernel#local_variables is a private method"
+  fails "Kernel#methods returns private singleton methods defined by obj.meth"
+  fails "Kernel#methods returns singleton methods defined in 'class << self' when it follows 'private'"
+  fails "Kernel#p is a private method"
+  fails "Kernel#print is a private method"
+  fails "Kernel#printf is a private method"
+  fails "Kernel#private_methods returns a list of the names of privately accessible methods in the object and its ancestors and mixed-in modules"
+  fails "Kernel#private_methods returns a list of the names of privately accessible methods in the object"
+  fails "Kernel#private_methods returns private methods mixed in to the metaclass"
+  fails "Kernel#private_methods when not passed an argument returns a unique list for a class including a module"
+  fails "Kernel#private_methods when not passed an argument returns a unique list for a subclass of a class that includes a module"
+  fails "Kernel#private_methods when not passed an argument returns a unique list for an object extended by a module"
+  fails "Kernel#private_methods when passed false returns a list of private methods in without its ancestors"
+  fails "Kernel#private_methods when passed nil returns a list of private methods in without its ancestors"
+  fails "Kernel#private_methods when passed true returns a unique list for a class including a module"
+  fails "Kernel#private_methods when passed true returns a unique list for a subclass of a class that includes a module"
+  fails "Kernel#private_methods when passed true returns a unique list for an object extended by a module"
+  fails "Kernel#protected_methods returns a list of the names of protected methods accessible in the object and from its ancestors and mixed-in modules"
+  fails "Kernel#protected_methods returns a list of the names of protected methods accessible in the object"
+  fails "Kernel#protected_methods returns methods mixed in to the metaclass"
+  fails "Kernel#protected_methods when not passed an argument returns a unique list for a class including a module"
+  fails "Kernel#protected_methods when not passed an argument returns a unique list for a subclass of a class that includes a module"
+  fails "Kernel#protected_methods when not passed an argument returns a unique list for an object extended by a module"
+  fails "Kernel#protected_methods when passed false returns a list of protected methods in without its ancestors"
+  fails "Kernel#protected_methods when passed nil returns a list of protected methods in without its ancestors"
+  fails "Kernel#protected_methods when passed true returns a unique list for a class including a module"
+  fails "Kernel#protected_methods when passed true returns a unique list for a subclass of a class that includes a module"
+  fails "Kernel#protected_methods when passed true returns a unique list for an object extended by a module"
+  fails "Kernel#public_send called from own public method raises a NoMethodError if the method is private"
+  fails "Kernel#public_send called from own public method raises a NoMethodError if the method is protected"
+  fails "Kernel#public_send raises a NoMethodError if the method is protected"
+  fails "Kernel#public_send raises a NoMethodError if the named method is an alias of a private method"
+  fails "Kernel#public_send raises a NoMethodError if the named method is an alias of a protected method"
+  fails "Kernel#public_send raises a NoMethodError if the named method is private"
+  fails "Kernel#puts is a private method"
+  fails "Kernel#respond_to? does not change method visibility when finding private method"
+  fails "Kernel#respond_to? returns false even if obj responds to the given private method (include_private = false)"
+  fails "Kernel#respond_to? returns false if obj responds to the given private method"
+  fails "Kernel#respond_to? returns false if obj responds to the given protected method (include_private = false)"
+  fails "Kernel#respond_to? returns false if obj responds to the given protected method"
+  fails "Kernel#respond_to_missing? is a private method"
+  fails "Kernel#respond_to_missing? is called when obj responds to the given private method, include_private = false"
+  fails "Kernel#respond_to_missing? is called when obj responds to the given protected method, include_private = false"
+  fails "Kernel#respond_to_missing? isn't called when obj responds to the given private method, include_private = true"
+  fails "Kernel#respond_to_missing? isn't called when obj responds to the given protected method, include_private = true"
+  fails "Kernel#respond_to_missing? isn't called when obj responds to the given public method, include_private = true"
+  fails "Kernel#singleton_methods when not passed an argument does not return private class methods for a class"
+  fails "Kernel#singleton_methods when not passed an argument does not return private inherited singleton methods for a class including a module"
+  fails "Kernel#singleton_methods when not passed an argument does not return private inherited singleton methods for a module including a module"
+  fails "Kernel#singleton_methods when not passed an argument does not return private inherited singleton methods for a subclass including a module"
+  fails "Kernel#singleton_methods when not passed an argument does not return private inherited singleton methods for a subclass of a class including a module"
+  fails "Kernel#singleton_methods when not passed an argument does not return private inherited singleton methods for a subclass of a class that includes a module, where the subclass also includes a module"
+  fails "Kernel#singleton_methods when not passed an argument does not return private inherited singleton methods for a subclass"
+  fails "Kernel#singleton_methods when not passed an argument does not return private module methods for a module"
+  fails "Kernel#singleton_methods when not passed an argument does not return private singleton methods for a class extended with a module"
+  fails "Kernel#singleton_methods when not passed an argument does not return private singleton methods for an object extended with a module"
+  fails "Kernel#singleton_methods when not passed an argument does not return private singleton methods for an object extended with two modules"
+  fails "Kernel#singleton_methods when not passed an argument does not return private singleton methods for an object extented with a module including a module"
+  fails "Kernel#singleton_methods when passed false does not return private class methods for a class"
+  fails "Kernel#singleton_methods when passed false does not return private inherited singleton methods for a class including a module"
+  fails "Kernel#singleton_methods when passed false does not return private inherited singleton methods for a module including a module"
+  fails "Kernel#singleton_methods when passed false does not return private inherited singleton methods for a subclass including a module"
+  fails "Kernel#singleton_methods when passed false does not return private inherited singleton methods for a subclass of a class including a module"
+  fails "Kernel#singleton_methods when passed false does not return private inherited singleton methods for a subclass of a class that includes a module, where the subclass also includes a module"
+  fails "Kernel#singleton_methods when passed false does not return private inherited singleton methods for a subclass"
+  fails "Kernel#singleton_methods when passed false does not return private module methods for a module"
+  fails "Kernel#singleton_methods when passed false does not return private singleton methods for a class extended with a module"
+  fails "Kernel#singleton_methods when passed false does not return private singleton methods for an object extended with a module"
+  fails "Kernel#singleton_methods when passed false does not return private singleton methods for an object extended with two modules"
+  fails "Kernel#singleton_methods when passed false does not return private singleton methods for an object extented with a module including a module"
+  fails "Kernel#singleton_methods when passed true does not return private class methods for a class"
+  fails "Kernel#singleton_methods when passed true does not return private inherited singleton methods for a class including a module"
+  fails "Kernel#singleton_methods when passed true does not return private inherited singleton methods for a module including a module"
+  fails "Kernel#singleton_methods when passed true does not return private inherited singleton methods for a subclass including a module"
+  fails "Kernel#singleton_methods when passed true does not return private inherited singleton methods for a subclass of a class including a module"
+  fails "Kernel#singleton_methods when passed true does not return private inherited singleton methods for a subclass of a class that includes a module, where the subclass also includes a module"
+  fails "Kernel#singleton_methods when passed true does not return private inherited singleton methods for a subclass"
+  fails "Kernel#singleton_methods when passed true does not return private module methods for a module"
+  fails "Kernel#singleton_methods when passed true does not return private singleton methods for a class extended with a module"
+  fails "Kernel#singleton_methods when passed true does not return private singleton methods for an object extended with a module"
+  fails "Kernel#singleton_methods when passed true does not return private singleton methods for an object extended with two modules"
+  fails "Kernel#singleton_methods when passed true does not return private singleton methods for an object extented with a module including a module"
+  fails "Kernel.global_variables is a private method"
+  fails "Kernel.lambda is a private method"
+  fails "Kernel.loop is a private method"
+  fails "Kernel.proc is a private method"
+  fails "Kernel.rand is a private method"
+  fails "Kernel.srand is a private method"
+  fails "Method#== missing methods calls respond_to_missing? with true to include private methods"
+  fails "Method#eql? missing methods calls respond_to_missing? with true to include private methods"
+  fails "Module#alias_method aliasing special methods keeps initialize private when aliasing"
+  fails "Module#alias_method aliasing special methods keeps initialize_clone private when aliasing"
+  fails "Module#alias_method aliasing special methods keeps initialize_copy private when aliasing"
+  fails "Module#alias_method aliasing special methods keeps initialize_dup private when aliasing"
+  fails "Module#alias_method aliasing special methods keeps respond_to_missing? private when aliasing"
+  fails "Module#alias_method is a private method"
+  fails "Module#append_features is a private method"
+  fails "Module#attr is a private method"
+  fails "Module#attr_accessor is a private method"
+  fails "Module#attr_reader is a private method"
+  fails "Module#attr_writer is a private method"
+  fails "Module#define_method is private"
+  fails "Module#define_method when given an UnboundMethod sets the new method's visibility to the current frame's visibility" # Expected NoMethodError but no exception was raised ("piggy" was returned)
+  fails "Module#define_method when name is :initialize given an UnboundMethod sets the visibility to private when method is named :initialize"
+  fails "Module#define_method when name is :initialize passed a block sets visibility to private when method name is :initialize"
+  fails "Module#define_method when name is not a special private name given an UnboundMethod and called from the target module sets the visibility of the method to the current visibility"
+  fails "Module#define_method when name is not a special private name given an UnboundMethod sets the visibility of the method to the current visibility"
+  fails "Module#define_method when name is not a special private name passed a block and called from the target module sets the visibility of the method to the current visibility"
+  fails "Module#extend_object is a private method"
+  fails "Module#extend_object is called even when private"
+  fails "Module#extended is private in its default implementation"
+  fails "Module#included is private in its default implementation"
+  fails "Module#instance_methods makes a private Object instance method public in Kernel"
+  fails "Module#method_added is a private instance method"
+  fails "Module#method_removed is a private instance method"
+  fails "Module#method_undefined is a private instance method"
+  fails "Module#module_function is a private method"
+  fails "Module#module_function with specific method names can make accessible private methods"
+  fails "Module#module_function with specific method names makes the instance methods private"
+  fails "Module#prepend_features is a private method"
+  fails "Module#prepended is a private method"
+  fails "Module#private is a private method"
+  fails "Module#private makes a public Object instance method private in Kernel"
+  fails "Module#private makes a public Object instance method private in a new module"
+  fails "Module#private makes the target method uncallable from other types"
+  fails "Module#private only makes the method private in the class it is called on" # Expected NameError but no exception was raised (2 was returned)
+  fails "Module#private raises a NameError when given an undefined name"
+  fails "Module#private returns self"
+  fails "Module#private without arguments affects evaled method definitions when itself is outside the eval"
+  fails "Module#private without arguments affects normally if itself and following method definitions are inside a eval"
+  fails "Module#private without arguments affects normally if itself and method definitions are inside a module_eval"
+  fails "Module#private without arguments continues setting visibility if the body encounters other visibility setters with arguments"
+  fails "Module#private without arguments does not affect method definitions when itself is inside an eval and method definitions are outside"
+  fails "Module#private without arguments does not affect module_evaled method definitions when itself is outside the eval"
+  fails "Module#private without arguments sets visibility to following method definitions"
+  fails "Module#private without arguments stops setting visibility if the body encounters other visibility setters without arguments"
+  fails "Module#private without arguments within a closure sets the visibility outside the closure"
+  fails "Module#private_class_method accepts more than one method at a time"
+  fails "Module#private_class_method makes a class method private"
+  fails "Module#private_class_method makes an existing class method private up the inheritance tree"
+  fails "Module#private_class_method makes an existing class method private"
+  fails "Module#private_class_method raises a NameError if class method doesn't exist"
+  fails "Module#private_class_method raises a NameError when the given name is an instance method"
+  fails "Module#private_class_method raises a NameError when the given name is not a method"
+  fails "Module#private_constant accepts multiple names"
+  fails "Module#private_constant accepts strings as constant names"
+  fails "Module#private_constant can only be passed constant names defined in the target (self) module"
+  fails "Module#private_constant marked constants NameError by #private_constant has :receiver and :name attributes" # Expected NameError but no exception was raised (true was returned)
+  fails "Module#private_constant marked constants NameError by #private_constant has the defined class as the :name attribute" # Expected NameError but no exception was raised (true was returned)
+  fails "Module#private_constant marked constants in Object cannot be accessed using ::Const form"
+  fails "Module#private_constant marked constants in Object is not defined? using ::Const form"
+  fails "Module#private_constant marked constants in a class can be accessed from lexical scope"
+  fails "Module#private_constant marked constants in a class can be accessed from the class itself"
+  fails "Module#private_constant marked constants in a class cannot be accessed from outside the class"
+  fails "Module#private_constant marked constants in a class cannot be reopened as a class"
+  fails "Module#private_constant marked constants in a class cannot be reopened as a module"
+  fails "Module#private_constant marked constants in a class is defined? from lexical scope"
+  fails "Module#private_constant marked constants in a class is not defined? with A::B form"
+  fails "Module#private_constant marked constants in a module can be accessed from lexical scope"
+  fails "Module#private_constant marked constants in a module can be accessed from the module itself"
+  fails "Module#private_constant marked constants in a module cannot be accessed from outside the module"
+  fails "Module#private_constant marked constants in a module cannot be reopened as a class from scope where constant would be private" # Expected NameError but no exception was raised (nil was returned)
+  fails "Module#private_constant marked constants in a module cannot be reopened as a class"
+  fails "Module#private_constant marked constants in a module cannot be reopened as a module from scope where constant would be private" # Exception: Cannot read property '$pretty_inspect' of undefined
+  fails "Module#private_constant marked constants in a module cannot be reopened as a module"
+  fails "Module#private_constant marked constants in a module is defined? from lexical scope"
+  fails "Module#private_constant marked constants in a module is not defined? with A::B form"
+  fails "Module#private_constant marked constants remain private even when updated"
+  fails "Module#private_instance_methods returns a list of private methods in module and its ancestors"
+  fails "Module#private_instance_methods when not passed an argument returns a unique list for a class including a module"
+  fails "Module#private_instance_methods when not passed an argument returns a unique list for a subclass"
+  fails "Module#private_instance_methods when passed false as a parameter, should return only methods defined in that module"
+  fails "Module#private_instance_methods when passed true returns a unique list for a class including a module"
+  fails "Module#private_instance_methods when passed true returns a unique list for a subclass"
+  fails "Module#private_method_defined? accepts symbols for the method name"
+  fails "Module#private_method_defined? calls #to_str to convert an Object"
+  fails "Module#private_method_defined? raises a TypeError if passed a Fixnum"
+  fails "Module#private_method_defined? raises a TypeError if passed an object that defines #to_sym"
+  fails "Module#private_method_defined? raises a TypeError if passed an object that does not defined #to_str"
+  fails "Module#private_method_defined? raises a TypeError if passed false"
+  fails "Module#private_method_defined? raises a TypeError if passed nil"
+  fails "Module#private_method_defined? returns true if the named private method is defined by module or its ancestors"
+  fails "Module#protected is a private method"
+  fails "Module#protected makes a public Object instance method protected in Kernel"
+  fails "Module#protected makes a public Object instance method protected in a new module"
+  fails "Module#protected makes an existing class method protected"
+  fails "Module#protected raises a NameError when given an undefined name"
+  fails "Module#protected returns self"
+  fails "Module#protected without arguments affects evaled method definitions when itself is outside the eval"
+  fails "Module#protected without arguments affects normally if itself and following method definitions are inside a eval"
+  fails "Module#protected without arguments affects normally if itself and method definitions are inside a module_eval"
+  fails "Module#protected without arguments continues setting visibility if the body encounters other visibility setters with arguments"
+  fails "Module#protected without arguments does not affect method definitions when itself is inside an eval and method definitions are outside"
+  fails "Module#protected without arguments does not affect module_evaled method definitions when itself is outside the eval"
+  fails "Module#protected without arguments sets visibility to following method definitions"
+  fails "Module#protected without arguments stops setting visibility if the body encounters other visibility setters without arguments"
+  fails "Module#protected without arguments within a closure sets the visibility outside the closure"
+  fails "Module#protected_instance_methods default list should be the same as passing true as an argument"
+  fails "Module#protected_instance_methods returns a list of protected methods in module and its ancestors"
+  fails "Module#protected_instance_methods when not passed an argument returns a unique list for a class including a module"
+  fails "Module#protected_instance_methods when not passed an argument returns a unique list for a subclass"
+  fails "Module#protected_instance_methods when passed false as a parameter, should return only methods defined in that module"
+  fails "Module#protected_instance_methods when passed true returns a unique list for a class including a module"
+  fails "Module#protected_instance_methods when passed true returns a unique list for a subclass"
+  fails "Module#protected_method_defined? accepts symbols for the method name"
+  fails "Module#protected_method_defined? calls #to_str to convert an Object"
+  fails "Module#protected_method_defined? raises a TypeError if passed a Fixnum"
+  fails "Module#protected_method_defined? raises a TypeError if passed an object that defines #to_sym"
+  fails "Module#protected_method_defined? raises a TypeError if passed an object that does not defined #to_str"
+  fails "Module#protected_method_defined? raises a TypeError if passed false"
+  fails "Module#protected_method_defined? raises a TypeError if passed nil"
+  fails "Module#protected_method_defined? returns true if the named protected method is defined by module or its ancestors"
+  fails "Module#public is a private method"
+  fails "Module#public makes a private Object instance method public in Kernel"
+  fails "Module#public makes a private Object instance method public in a new module"
+  fails "Module#public raises a NameError when given an undefined name"
+  fails "Module#public returns self"
+  fails "Module#public without arguments affects evaled method definitions when itself is outside the eval"
+  fails "Module#public without arguments affects normally if itself and following method definitions are inside a eval"
+  fails "Module#public without arguments does not affect method definitions when itself is inside an eval and method definitions are outside"
+  fails "Module#public without arguments does not affect module_evaled method definitions when itself is outside the eval"
+  fails "Module#public without arguments stops setting visibility if the body encounters other visibility setters without arguments"
+  fails "Module#public_class_method accepts more than one method at a time"
+  fails "Module#public_class_method makes an existing class method public up the inheritance tree"
+  fails "Module#public_class_method makes an existing class method public"
+  fails "Module#public_class_method raises a NameError if class method doesn't exist"
+  fails "Module#public_class_method raises a NameError when the given name is an instance method"
+  fails "Module#public_class_method raises a NameError when the given name is not a method"
+  fails "Module#public_constant accepts multiple names"
+  fails "Module#public_constant accepts strings as constant names"
+  fails "Module#public_constant can only be passed constant names defined in the target (self) module"
+  fails "Module#public_constant marked constants in a class can be accessed from outside the class"
+  fails "Module#public_constant marked constants in a class is defined? with A::B form" # Exception: Opal.TypeError is not a constructor
+  fails "Module#public_constant marked constants in a module can be accessed from outside the module"
+  fails "Module#public_constant marked constants in a module is defined? with A::B form" # Exception: Opal.TypeError is not a constructor
+  fails "Module#public_instance_method is a public method"
+  fails "Module#public_instance_method raises a NameError if the method is private"
+  fails "Module#public_instance_method raises a NameError when given a protected method name"
+  fails "Module#public_instance_method raises a TypeError when given a name is not Symbol or String"
+  fails "Module#public_instance_method requires an argument"
+  fails "Module#public_instance_method sets the NameError#name attribute to the name of the missing method"
+  fails "Module#public_instance_method when given a public method name accepts if the name is a Symbol or String"
+  fails "Module#public_instance_method when given a public method name returns an UnboundMethod corresponding to the defined Module"
+  fails "Module#public_instance_methods when passed false as a parameter, should return only methods defined in that module"
+  fails "Module#public_method_defined? calls #to_str to convert an Object"
+  fails "Module#public_method_defined? raises a TypeError if passed a Fixnum"
+  fails "Module#public_method_defined? raises a TypeError if passed an object that defines #to_sym"
+  fails "Module#public_method_defined? raises a TypeError if passed an object that does not defined #to_str"
+  fails "Module#public_method_defined? raises a TypeError if passed false"
+  fails "Module#public_method_defined? raises a TypeError if passed nil"
+  fails "Module#public_method_defined? returns false if method is not a public method"
+  fails "Module#remove_const is a private method"
+  fails "Module#remove_method is a private method"
+  fails "Module#undef_method is a private method"
+  fails "NoMethodError#message for an protected method match /protected method/"
+  fails "NoMethodError#message for private method match /private method/"
+  fails "OpenStruct#initialize is private"
+  fails "OpenStruct#new_ostruct_member is protected"
+  fails "OpenStruct#table is protected"
+  fails "Rational#marshal_dump is a private method"
+  fails "Redefining a singleton method does not inherit a previously set visibility"
+  fails "Regexp#initialize is a private method"
+  fails "Set#flatten_merge is protected"
+  fails "String#+@ returns mutable copy despite freeze-magic-comment in file" # NoMethodError: undefined method `tmp' for #<Object:0x3bdc>
+  fails "StringScanner#initialize is a private method"
+end