opal 0.11.0.rc1 → 0.11.0

data/spec/filters/unsupported/basicobject.rb

@@ -1,14 +0,0 @@
-opal_unsupported_filter "BasicObject" do
-  fails "BasicObject#method_missing for a Class raises a NoMethodError when a private method is called"
-  fails "BasicObject#method_missing for a Class raises a NoMethodError when a protected method is called"
-  fails "BasicObject#method_missing for a Class with #method_missing defined is called when an private method is called"
-  fails "BasicObject#method_missing for a Class with #method_missing defined is called when an protected method is called"
-  fails "BasicObject#method_missing for a Module raises a NoMethodError when a private method is called"
-  fails "BasicObject#method_missing for a Module raises a NoMethodError when a protected method is called"
-  fails "BasicObject#method_missing for a Module with #method_missing defined is called when a private method is called"
-  fails "BasicObject#method_missing for a Module with #method_missing defined is called when a protected method is called"
-  fails "BasicObject#method_missing for an instance raises a NoMethodError when a private method is called"
-  fails "BasicObject#method_missing for an instance raises a NoMethodError when a protected method is called"
-  fails "BasicObject#method_missing for an instance with #method_missing defined is called when an private method is called"
-  fails "BasicObject#method_missing for an instance with #method_missing defined is called when an protected method is called"
-end

data/spec/filters/unsupported/bignum.rb

@@ -1,55 +0,0 @@
-opal_unsupported_filter "Bignum" do
-  fails "BasicObject#__id__ returns a different value for two Bignum literals"
-  fails "Complex#== with Numeric returns true when self's imaginary part is 0 and the real part and other have numerical equality"
-  fails "Complex#fdiv with an imaginary part sets the real part to self's real part fdiv'd with the argument"
-  fails "Complex#fdiv with no imaginary part sets the real part to self's real part fdiv'd with the argument"
-  fails "Complex#rect raises an ArgumentError if given any arguments"
-  fails "Complex#rect returns a two-element Array"
-  fails "Complex#rect returns an Array"
-  fails "Complex#rect returns the imaginary part of self as the last element"
-  fails "Complex#rect returns the real part of self as the first element"
-  fails "Enumerable#first raises a RangeError when passed a Bignum"
-  fails "Fixnum#& returns self bitwise AND a Bignum"
-  fails "Fixnum#& returns self bitwise AND other"
-  fails "Fixnum#* overflows to Bignum when the result does not fit in Fixnum"
-  fails "Fixnum#** can raise -1 to a Bignum safely"
-  fails "Fixnum#/ coerces fixnum and return self divided by other"
-  fails "Fixnum#^ returns self bitwise EXCLUSIVE OR a Bignum"
-  fails "Fixnum#^ returns self bitwise EXCLUSIVE OR other"
-  fails "Fixnum#| returns self bitwise OR other"
-  fails "Float#fdiv performs floating-point division between self and a Bignum"
-  fails "Float#numerator converts self to a Rational object then returns its numerator"
-  fails "Float#quo performs floating-point division between self and a Bignum"
-  fails "Float#round returns rounded values for big values"
-  fails "Integer#gcd accepts a Bignum argument"
-  fails "Integer#gcd works if self is a Bignum"
-  fails "Integer#gcdlcm accepts a Bignum argument"
-  fails "Integer#gcdlcm works if self is a Bignum"
-  fails "Integer#lcm accepts a Bignum argument"
-  fails "Integer#lcm works if self is a Bignum"
-  fails "Integer#odd? returns true when self is an odd number"
-  fails "Integer#rationalize returns a Rational object"
-  fails "Integer#rationalize uses 1 as the denominator"
-  fails "Integer#rationalize uses self as the numerator"
-  fails "Integer#round returns itself rounded if passed a negative value"
-  fails "Integer#to_r works even if self is a Bignum"
-  fails "Numeric#denominator returns 1"
-  fails "Numeric#numerator converts self to a Rational object then returns its numerator"
-  fails "Numeric#quo raises a ZeroDivisionError when the given Integer is 0"
-  fails "Rational#** when passed Bignum raises ZeroDivisionError when self is Rational(0) and the exponent is negative"
-  fails "Rational#** when passed Bignum returns 0.0 when self is < -1 and the exponent is negative"
-  fails "Rational#** when passed Bignum returns 0.0 when self is > 1 and the exponent is negative"
-  fails "Rational#** when passed Bignum returns positive Infinity when self < -1"
-  fails "Rational#** when passed Bignum returns positive Infinity when self is > 1"
-  fails "Rational#** when passed Bignum returns Rational(-1) when self is Rational(-1) and the exponent is positive and odd"
-  fails "Rational#** when passed Bignum returns Rational(1) when self is Rational(-1) and the exponent is positive and even"
-  fails "Rational#round with a precision > 0 doesn't fail when rounding to an absurdly large positive precision"
-  fails "Marshal.load loads a Bignum 2**90"
-  fails "Marshal.load for a Integer loads an Integer 2361183241434822606847"
-  fails "Marshal.load for a Integer loads an Integer -2361183241434822606847"
-  fails "Marshal.dump with a Bignum dumps a Bignum"
-  fails "Marshal.dump with a Bignum dumps a Bignum"
-  fails "Random.new_seed returns a Bignum"
-  fails "Random.new uses a random seed value if none is supplied"
-  fails "Random#rand with Bignum typically returns a Bignum"
-end

data/spec/filters/unsupported/class.rb

@@ -1,4 +0,0 @@
-opal_unsupported_filter "Class" do
-  fails "Class#initialize is private"
-  fails "Class.inherited is called when marked as a public class method"
-end

data/spec/filters/unsupported/delegator.rb

@@ -1,5 +0,0 @@
-opal_unsupported_filter "Delegator" do
-  fails "SimpleDelegator.new doesn't forward private method calls even via send or __send__"
-  fails "SimpleDelegator.new doesn't forward private method calls"
-  fails "SimpleDelegator.new forwards protected method calls"
-end

data/spec/filters/unsupported/enumerable.rb

@@ -1,11 +0,0 @@
-opal_unsupported_filter "Enumerable" do
-  fails "Enumerable#chunk does not return elements for which the block returns :_separator"
-  fails "Enumerable#chunk raises a RuntimeError if the block returns a Symbol starting with an underscore other than :_alone or :_separator"
-  fails "Enumerable#chunk with [initial_state] yields an element and an object value-equal but not identical to the object passed to #chunk"
-  fails "Enumerable#entries returns a tainted array if self is tainted"
-  fails "Enumerable#entries returns an untrusted array if self is untrusted"
-  fails "Enumerable#group_by returns a tainted hash if self is tainted"
-  fails "Enumerable#group_by returns an untrusted hash if self is untrusted"
-  fails "Enumerable#to_a returns a tainted array if self is tainted"
-  fails "Enumerable#to_a returns an untrusted array if self is untrusted"
-end

data/spec/filters/unsupported/enumerator.rb

@@ -1,13 +0,0 @@
-opal_unsupported_filter "Enumerator" do
-  fails "Enumerator#next cannot be called again until the enumerator is rewound"
-  fails "Enumerator#next raises a StopIteration exception at the end of the stream"
-  fails "Enumerator#next returns the next element of the enumeration"
-  fails "Enumerator#rewind calls the enclosed object's rewind method if one exists"
-  fails "Enumerator#rewind clears a pending #feed value"
-  fails "Enumerator#rewind does nothing if the object doesn't have a #rewind method"
-  fails "Enumerator#rewind has no effect if called multiple, consecutive times"
-  fails "Enumerator#rewind has no effect on a new enumerator"
-  fails "Enumerator#rewind resets the enumerator to its initial state"
-  fails "Enumerator#rewind returns self"
-  fails "Enumerator#rewind works with peek to reset the position"
-end

data/spec/filters/unsupported/file.rb

@@ -1,4 +0,0 @@
-opal_unsupported_filter "File" do
-  fails "File.join doesn't mutate the object when calling #to_str"
-end
-

data/spec/filters/unsupported/fixnum.rb

@@ -1,14 +0,0 @@
-opal_unsupported_filter "Fixnum" do
-  fails "Fixnum#+ overflows to Bignum when the result does not fit in Fixnum"
-  fails "Fixnum#- returns a Bignum only if the result is too large to be a Fixnum"
-  fails "Fixnum#<< with n << m returns -1 when n < 0, m < 0 and n > -(2**-m)"
-  fails "Fixnum#<< with n << m returns 0 when m < 0 and m is a Bignum"
-  fails "Fixnum#<< with n << m returns 0 when n > 0, m < 0 and n < 2**-m"
-  fails "Fixnum#<< with n << m returns a Bignum == fixnum_max * 2 when fixnum_max << 1 and n > 0"
-  fails "Fixnum#<< with n << m returns a Bignum == fixnum_min * 2 when fixnum_min << 1 and n < 0"
-  fails "Fixnum#>> with n >> m returns -1 when n < 0, m > 0 and n > -(2**m)"
-  fails "Fixnum#>> with n >> m returns 0 when m is a Bignum"
-  fails "Fixnum#>> with n >> m returns 0 when n > 0, m > 0 and n < 2**m"
-  fails "Fixnum#>> with n >> m returns a Bignum == fixnum_max * 2 when fixnum_max >> -1 and n > 0"
-  fails "Fixnum#>> with n >> m returns a Bignum == fixnum_min * 2 when fixnum_min >> -1 and n < 0"
-end

data/spec/filters/unsupported/float.rb

@@ -1,46 +0,0 @@
-opal_unsupported_filter "Float" do
-  fails "BasicObject#__id__ returns a different value for two Float literals"
-  fails "Complex#/ with Fixnum raises a ZeroDivisionError when given zero"
-  fails "Complex#eql? returns false when the imaginary parts are of different classes"
-  fails "Complex#eql? returns false when the real parts are of different classes"
-  fails "Complex#quo with Fixnum raises a ZeroDivisionError when given zero"
-  fails "Complex#rationalize raises RangeError if self has 0.0 imaginary part"
-  fails "Complex#to_f when the imaginary part is Float 0.0 raises RangeError"
-  fails "Complex#to_i when the imaginary part is Float 0.0 raises RangeError"
-  fails "Complex#to_r when the imaginary part is Float 0.0 raises RangeError"
-  fails "Complex#to_s returns 1+0.0i for Complex(1, 0.0)"
-  fails "Complex#to_s returns 1-0.0i for Complex(1, -0.0)"
-  fails "Fixnum#% raises a ZeroDivisionError when the given argument is 0 and a Float"
-  fails "Fixnum#% raises a ZeroDivisionError when the given argument is 0"
-  fails "Fixnum#& raises a TypeError when passed a Float"
-  fails "Fixnum#/ raises a ZeroDivisionError if the given argument is zero and not a Float"
-  fails "Fixnum#/ returns self divided by the given argument"
-  fails "Fixnum#/ supports dividing negative numbers"
-  fails "Fixnum#coerce when given a String returns  an array containing two Floats"
-  fails "Fixnum#div coerces self and the given argument to Floats and returns self divided by other as Fixnum"
-  fails "Fixnum#divmod raises a TypeError when given a non-Integer"
-  fails "Fixnum#^ raises a TypeError when passed a Float"
-  fails "Fixnum#| raises a TypeError when passed a Float"
-  fails "Float constant MAX_10_EXP is 308"
-  fails "Float constant MAX_EXP is 1024"
-  fails "Float constant MIN is 2.2250738585072e-308"
-  fails "Float constant MIN_10_EXP is -308"
-  fails "Float constant MIN_EXP is -1021"
-  fails "Float#coerce returns [other, self] both as Floats"
-  fails "Float#eql? returns false if other is not a Float"
-  fails "Float#to_s emits '-' for -0.0"
-  fails "Float#to_s emits a trailing '.0' for a whole number"
-  fails "Float#to_s emits a trailing '.0' for the mantissa in e format"
-  fails "Float#to_s returns '0.0' for 0.0"
-  fails "Math.gamma returns approximately (n-1)! given n for n between 24 and 30" # precision error
-  fails "Rational#% returns a Float value when the argument is Float"
-  fails "Rational#** raises ZeroDivisionError for Rational(0, 1) passed a negative Integer"
-  fails "Rational#** when passed Integer returns the Rational value of self raised to the passed argument"
-  fails "Rational#/ when passed an Integer raises a ZeroDivisionError when passed 0"
-  fails "Rational#coerce returns the passed argument, self as Float, when given a Float"
-  fails "Rational#divmod when passed an Integer returns the quotient as Integer and the remainder as Rational"
-  fails "Struct#eql? returns false if any corresponding elements are not #eql?" # Rubyspec uses 1.eql?(1.0) which always returns true in compiled JS
-  fails "Numeric#step with positional args when no block is given returned Enumerator size when self, stop or step is a Float and step is positive returns the difference between self and stop divided by the number of steps"
-  fails "Numeric#step with keyword arguments when no block is given returned Enumerator size when self, stop or step is a Float and step is positive returns the difference between self and stop divided by the number of steps"
-  fails "Numeric#step with mixed arguments when no block is given returned Enumerator size when self, stop or step is a Float and step is positive returns the difference between self and stop divided by the number of steps"
-end

data/spec/filters/unsupported/freeze.rb

@@ -1,75 +0,0 @@
-opal_unsupported_filter "freezing" do
-  fails "A method definition inside a metaclass scope raises RuntimeError if frozen"
-  fails "A singleton method definition raises RuntimeError if frozen"
-  fails "Array#delete returns nil on a frozen array if a modification does not take place"
-  fails "Array#dup does not copy frozen status from the original"
-  fails "Array#rotate does not mutate the receiver"
-  fails "Array#rotate! raises a RuntimeError on a frozen array"
-  fails "Array#select! on frozen objects returns an Enumerator if no block is given"
-  fails "Array#sort does not freezes self during being sorted"
-  fails "Array#sort_by! raises a RuntimeError on a frozen array"
-  fails "Array#sort_by! raises a RuntimeError on an empty frozen array"
-  fails "Date constants freezes MONTHNAMES, DAYNAMES, ABBR_MONTHNAMES, ABBR_DAYSNAMES"
-  fails "Enumerable#sort doesn't raise an error if #to_a returns a frozen Array"
-  fails "Enumerator#initialize on frozen instance raises a RuntimeError"
-  fails "Hash literal does not change encoding of literal string keys during creation"
-  fails "Hash literal freezes string keys on initialization"
-  fails "Hash#== compares keys with matching hash codes via eql?"
-  fails "Hash#[]= doesn't duplicate and freeze already frozen string keys"
-  fails "Hash#delete_if returns an Enumerator if called on a frozen instance"
-  fails "Hash#each returns an Enumerator if called on a frozen instance"
-  fails "Hash#each_key returns an Enumerator if called on a frozen instance"
-  fails "Hash#each_pair returns an Enumerator if called on a frozen instance"
-  fails "Hash#each_value returns an Enumerator if called on a frozen instance"
-  fails "Hash#eql? compares keys with matching hash codes via eql?"
-  fails "Hash#keep_if returns an Enumerator if called on a frozen instance"
-  fails "Hash#reject returns an Enumerator if called on a frozen instance"
-  fails "Hash#select returns an Enumerator if called on a frozen instance"
-  fails "Hash#select! returns an Enumerator if called on a frozen instance"
-  fails "Hash#store doesn't duplicate and freeze already frozen string keys"
-  fails "Kernel#clone copies frozen state from the original"
-  fails "Kernel#clone copies frozen? and tainted?" # Expected false to be true
-  fails "Kernel#extend on frozen instance raises a RuntimeError"
-  fails "Kernel#extend on frozen instance raises an ArgumentError when no arguments given"
-  fails "Kernel#freeze causes instance_variable_set to raise RuntimeError"
-  fails "Kernel#freeze causes mutative calls to raise RuntimeError"
-  fails "Kernel#freeze on a Float has no effect since it is already frozen"
-  fails "Kernel#freeze on a Symbol has no effect since it is already frozen"
-  fails "Kernel#freeze on integers has no effect since they are already frozen"
-  fails "Kernel#freeze on true, false and nil has no effect since they are already frozen"
-  fails "Kernel#freeze prevents self from being further modified"
-  fails "Kernel#freeze returns self"
-  fails "Kernel#frozen? on a Float returns true"
-  fails "Kernel#frozen? on a Symbol returns true"
-  fails "Kernel#frozen? on integers returns true"
-  fails "Kernel#frozen? on true, false and nil returns true"
-  fails "Kernel#frozen? returns true if self is frozen"
-  fails "Kernel#instance_variable_set on frozen objects keeps stored object after any exceptions"
-  fails "Kernel#instance_variable_set on frozen objects raises a RuntimeError when passed replacement is different from stored object"
-  fails "Kernel#instance_variable_set on frozen objects raises a RuntimeError when passed replacement is identical to stored object"
-  fails "MatchData#string returns a frozen copy of the match string"
-  fails "Module#alias_method raises RuntimeError if frozen"
-  fails "Module#append_features when other is frozen raises a RuntimeError before appending self"
-  fails "Module#autoload on a frozen module raises a RuntimeError before setting the name"
-  fails "Module#class_variable_set raises a RuntimeError when self is frozen"
-  fails "Module#const_set on a frozen module raises a RuntimeError before setting the name"
-  fails "Module#define_method raises a RuntimeError if frozen"
-  fails "Module#extend_object when given a frozen object raises a RuntimeError before extending the object"
-  fails "Module#remove_method on frozen instance does not raise exceptions when no arguments given"
-  fails "Module#remove_method on frozen instance raises a RuntimeError when passed a missing name"
-  fails "Module#remove_method on frozen instance raises a RuntimeError when passed a name"
-  fails "Module#remove_method on frozen instance raises a TypeError when passed a not name"
-  fails "Module#undef_method on frozen instance does not raise exceptions when no arguments given"
-  fails "Module#undef_method on frozen instance raises a RuntimeError when passed a missing name"
-  fails "Module#undef_method on frozen instance raises a RuntimeError when passed a name"
-  fails "Module#undef_method on frozen instance raises a TypeError when passed a not name"
-  fails "OpenStruct#method_missing when called with a method name ending in '=' raises a TypeError when self is frozen"
-  fails "String#+@ returns an unfrozen copy of a frozen String"
-  fails "String#+@ returns self if the String is not frozen"
-  fails "String#-@ returns a frozen copy if the String is not frozen"
-  fails "String#-@ returns self if the String is frozen"
-  fails "String#clone copies frozen state"
-  fails "String#freeze doesn't produce the same object for different instances of literals in the source"
-  fails "String#initialize with no arguments does not raise an exception when frozen"
-  fails "StringScanner#initialize returns an instance of StringScanner"
-end

data/spec/filters/unsupported/hash.rb

@@ -1,43 +0,0 @@
-opal_unsupported_filter "Hash" do
-  fails "Hash#assoc only returns the first matching key-value pair for identity hashes"
-  fails "Hash#clear raises a RuntimeError if called on a frozen instance"
-  fails "Hash#compare_by_identity raises a RuntimeError on frozen hashes"
-  fails "Hash#default= raises a RuntimeError if called on a frozen instance"
-  fails "Hash#default_proc= raises a RuntimeError if self is frozen"
-  fails "Hash#delete raises a RuntimeError if called on a frozen instance"
-  fails "Hash#delete_if raises a RuntimeError if called on a frozen instance"
-  fails "Hash#initialize is private"
-  fails "Hash#initialize raises a RuntimeError if called on a frozen instance"
-  fails "Hash#inspect returns a tainted string if self is tainted and not empty"
-  fails "Hash#inspect returns an untrusted string if self is untrusted and not empty"
-  fails "Hash#keep_if raises a RuntimeError if called on a frozen instance"
-  fails "Hash#merge! checks frozen status before coercing an object with #to_hash"
-  fails "Hash#merge! raises a RuntimeError on a frozen instance that is modified"
-  fails "Hash#merge! raises a RuntimeError on a frozen instance that would not be modified"
-  fails "Hash#rehash raises a RuntimeError if called on a frozen instance"
-  fails "Hash#reject! raises a RuntimeError if called on a frozen instance that is modified"
-  fails "Hash#reject! raises a RuntimeError if called on a frozen instance that would not be modified"
-  fails "Hash#reject! returns an Enumerator if called on a frozen instance"
-  fails "Hash#replace raises a RuntimeError if called on a frozen instance that is modified"
-  fails "Hash#replace raises a RuntimeError if called on a frozen instance that would not be modified"
-  fails "Hash#select! raises a RuntimeError if called on a frozen instance that would not be modified"
-  fails "Hash#select! raises a RuntimeError if called on an empty frozen instance"
-  fails "Hash#shift raises a RuntimeError if called on a frozen instance"
-  fails "Hash#store duplicates and freezes string keys"
-  fails "Hash#store raises a RuntimeError if called on a frozen instance"
-  fails "Hash#to_a returns a tainted array if self is tainted"
-  fails "Hash#to_a returns an untrusted array if self is untrusted"
-  fails "Hash#to_proc the returned proc raises ArgumentError if not passed exactly one argument"
-  fails "Hash#to_proc the returned proc passed as a block to instance_exec always retrieves the original hash's values"
-  fails "Hash#to_s returns a tainted string if self is tainted and not empty"
-  fails "Hash#to_s returns an untrusted string if self is untrusted and not empty"
-  fails "Hash#update checks frozen status before coercing an object with #to_hash"
-  fails "Hash#update raises a RuntimeError on a frozen instance that is modified"
-  fails "Hash#update raises a RuntimeError on a frozen instance that would not be modified"
-  fails "Hash#[]= duplicates and freezes string keys"
-  fails "Hash#[]= raises a RuntimeError if called on a frozen instance"
-  fails "Hash#inspect does not raise if inspected result is not default external encoding" # Mock 'utf_16be' expected to receive 'inspect' exactly 1 times but received it 0 times
-  fails "Hash#inspect does not raise if inspected result is not default external encoding" # NoMethodError: undefined method `encode!' for "\"utf_16be あ\"":String
-  fails "Hash#to_s does not raise if inspected result is not default external encoding" # Mock 'utf_16be' expected to receive 'inspect' exactly 1 times but received it 0 times
-  fails "Hash#to_s does not raise if inspected result is not default external encoding" # NoMethodError: undefined method `encode!' for "\"utf_16be あ\"":String
-end

data/spec/filters/unsupported/integer.rb

@@ -1,3 +0,0 @@
-opal_unsupported_filter "Integer" do
-  fails "Integer#even? returns true for a Bignum when it is an even number"
-end

data/spec/filters/unsupported/kernel.rb

@@ -1,32 +0,0 @@
-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#eql? is a public instance method"
-  fails "Kernel#format 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#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.fail is a private method"
-  fails "Kernel#raise is a private method"
-  fails "Kernel#inspect returns an untrusted string if self is untrusted"
-end

data/spec/filters/unsupported/language.rb

@@ -1,22 +0,0 @@
-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 "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 visiblity of previously called methods with same send/call site"
-  fails "The private keyword is overridden when a new class is opened"
-  fails "The private keyword marks following methods as being private"
-  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"
-  fails "Ruby String literals with a magic frozen comment produce the same object for literals with the same content in different files"
-end

data/spec/filters/unsupported/marshal.rb

@@ -1,46 +0,0 @@
-opal_unsupported_filter "Marshal" do
-  # Marshal.load
-  fails "Marshal.load loads a Random" # depends on the reading from the filesystem
-  fails "Marshal.load when source is tainted returns a tainted object"
-  fails "Marshal.load when source is tainted does not taint Symbols"
-  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 Bignums"
-  fails "Marshal.load returns an untainted object if source is untainted"
-  fails "Marshal.load preserves taintedness of nested structure"
-  fails "Marshal.load returns a trusted object if source is trusted"
-  fails "Marshal.load returns an untrusted object if source is untrusted"
-  fails "Marshal.load for a String loads a string through StringIO stream"
-  fails "Marshal.load raises EOFError on loading an empty file"
-  fails "Marshal.load for a String loads a string with an ivar" # depends on string mutation
-  fails "Marshal.load for a String loads a string having ivar with ref to self" # depends on string mutation
-  fails "Marshal.load for a wrapped C pointer loads"
-  fails "Marshal.load for a wrapped C pointer raises TypeError when the local class is missing _load_data"
-  fails "Marshal.load for a wrapped C pointer raises ArgumentError when the local class is a regular object"
-  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 raises a TypeError with bad Marshal version" # depends on String#[]=
-  fails "Marshal.load for a Hash preserves hash ivars when hash contains a string having ivar" # depends on String#instance_variable_set
-
-  # Marshal.dump
-  fails "Marshal.dump returns a tainted string if object is tainted"
-  fails "Marshal.dump returns a tainted string if nested object is tainted"
-  fails "Marshal.dump returns a trusted string if object is trusted"
-  fails "Marshal.dump returns an untrusted string if object is untrusted"
-  fails "Marshal.dump returns an untrusted string if nested object is untrusted"
-  fails "Marshal.dump returns an untainted string if object is untainted"
-  fails "Marshal.dump when passed an IO writes the serialized data to the IO-Object"
-  fails "Marshal.dump when passed an IO returns the IO-Object"
-  fails "Marshal.dump when passed an IO raises an Error when the IO-Object does not respond to #write"
-  fails "Marshal.dump raises a TypeError if dumping a IO/File instance"
-  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 String dumps a String with instance variables"  # depends on string mutation
-  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 with flags" # depends on string encoding, replaced with test in spec/opal
-  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 dumps subsequent appearances of a symbol as a link" # depends on Symbol-s
-  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.dump with a Regexp dumps a binary Regexp"
-  fails "Marshal.dump with a Regexp dumps a UTF-8 Regexp"
-  fails "Marshal.dump with a Regexp dumps a Regexp in another encoding"
-end

data/spec/filters/unsupported/matchdata.rb

@@ -1,33 +0,0 @@
-opal_unsupported_filter "MatchData" do
-  fails "MatchData#begin returns nil when the nth match isn't found"
-  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#end returns nil when the nth match isn't found"
-  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#names equals Regexp#names"
-  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 returns [] if there were no named captures"
-  fails "MatchData#names sets each element to a String"
-  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"
-  fails "MatchData#offset returns [nil, nil] when the nth match isn't found"
-  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#[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 the offset for multi byte strings with unicode regexp"
-  fails "MatchData#end returns the offset for multi byte strings with unicode regexp"
-  fails "MatchData#offset returns the offset for multi byte strings with unicode regexp"
-end

data/spec/filters/unsupported/math.rb

@@ -1,3 +0,0 @@
-opal_unsupported_filter "Math" do
-  fails "Math#atanh is a private instance method"
-end