opal 0.10.0 → 0.11.0

data/spec/filters/unsupported/array.rb

@@ -1,163 +0,0 @@
-opal_filter "Array" do
-  fails "Array#* with a string with a tainted separator does not taint the result if the array has only one element"
-  fails "Array#* with a string with a tainted separator does not taint the result if the array is empty"
-  fails "Array#* with a string with a tainted separator taints the result if the array has two or more elements"
-  fails "Array#* with a string with an untrusted separator does not untrust the result if the array has only one element"
-  fails "Array#* with a string with an untrusted separator does not untrust the result if the array is empty"
-  fails "Array#* with a string with an untrusted separator untrusts the result if the array has two or more elements"
-  fails "Array#* with an integer copies the taint status of the original array even if the array is empty"
-  fails "Array#* with an integer copies the taint status of the original array even if the passed count is 0"
-  fails "Array#* with an integer copies the taint status of the original array if the passed count is not 0"
-  fails "Array#* with an integer copies the untrusted status of the original array even if the array is empty"
-  fails "Array#* with an integer copies the untrusted status of the original array even if the passed count is 0"
-  fails "Array#* with an integer copies the untrusted status of the original array if the passed count is not 0"
-  fails "Array#+ does not get infected even if an original array is tainted"
-  fails "Array#+ does not infected even if an original array is untrusted"
-  fails "Array#<< raises a RuntimeError on a frozen array"
-  fails "Array#clear keeps tainted status"
-  fails "Array#clear keeps untrusted status"
-  fails "Array#clear raises a RuntimeError on a frozen array"
-  fails "Array#clone copies frozen status from the original"
-  fails "Array#clone copies taint status from the original"
-  fails "Array#clone copies untrusted status from the original"
-  fails "Array#collect does not copy tainted status"
-  fails "Array#collect does not copy untrusted status"
-  fails "Array#collect! keeps tainted status"
-  fails "Array#collect! keeps untrusted status"
-  fails "Array#collect! when frozen raises a RuntimeError when calling #each on the returned Enumerator when empty"
-  fails "Array#collect! when frozen raises a RuntimeError when calling #each on the returned Enumerator"
-  fails "Array#collect! when frozen raises a RuntimeError when empty"
-  fails "Array#collect! when frozen raises a RuntimeError"
-  fails "Array#compact does not keep tainted status even if all elements are removed"
-  fails "Array#compact does not keep untrusted status even if all elements are removed"
-  fails "Array#compact! keeps tainted status even if all elements are removed"
-  fails "Array#compact! keeps untrusted status even if all elements are removed"
-  fails "Array#compact! raises a RuntimeError on a frozen array"
-  fails "Array#concat is not infected by the other"
-  fails "Array#concat is not infected untrustedness by the other"
-  fails "Array#concat keeps tainted status"
-  fails "Array#concat keeps the tainted status of elements"
-  fails "Array#concat keeps the untrusted status of elements"
-  fails "Array#concat keeps untrusted status"
-  fails "Array#concat raises a RuntimeError when Array is frozen and modification occurs"
-  fails "Array#concat raises a RuntimeError when Array is frozen and no modification occurs"
-  fails "Array#delete keeps tainted status"
-  fails "Array#delete keeps untrusted status"
-  fails "Array#delete raises a RuntimeError on a frozen array"
-  fails "Array#delete_at keeps tainted status"
-  fails "Array#delete_at keeps untrusted status"
-  fails "Array#delete_at raises a RuntimeError on a frozen array"
-  fails "Array#delete_if keeps tainted status"
-  fails "Array#delete_if keeps untrusted status"
-  fails "Array#delete_if raises a RuntimeError on a frozen array"
-  fails "Array#delete_if raises a RuntimeError on an empty frozen array"
-  fails "Array#delete_if returns an Enumerator if no block given, and the array is frozen"
-  fails "Array#dup copies taint status from the original"
-  fails "Array#dup copies untrusted status from the original"
-  fails "Array#eql? returns false if any corresponding elements are not #eql?"
-  fails "Array#fill does not replicate the filler"
-  fails "Array#fill raises a RuntimeError on a frozen array"
-  fails "Array#fill raises a RuntimeError on an empty frozen array"
-  fails "Array#first raises a RangeError when count is a Bignum"
-  fails "Array#flatten returns a tainted array if self is tainted"
-  fails "Array#flatten returns an untrusted array if self is untrusted"
-  fails "Array#flatten! raises a RuntimeError on frozen arrays when the array is modified"
-  fails "Array#flatten! raises a RuntimeError on frozen arrays when the array would not be modified"
-  fails "Array#frozen? returns false for an array being sorted by #sort"
-  fails "Array#frozen? returns true if array is frozen"
-  fails "Array#hash returns the same fixnum for arrays with the same content"
-  fails "Array#initialize is private"
-  fails "Array#initialize raises a RuntimeError on frozen arrays"
-  fails "Array#insert raises a RuntimeError on frozen arrays when the array is modified"
-  fails "Array#insert raises a RuntimeError on frozen arrays when the array would not be modified"
-  fails "Array#inspect does not taint the result if the Array is tainted but empty"
-  fails "Array#inspect does not untrust the result if the Array is untrusted but empty"
-  fails "Array#inspect represents a recursive element with '[...]'"
-  fails "Array#inspect taints the result if an element is tainted"
-  fails "Array#inspect taints the result if the Array is non-empty and tainted"
-  fails "Array#inspect untrusts the result if an element is untrusted"
-  fails "Array#inspect untrusts the result if the Array is untrusted"
-  fails "Array#inspect with encoding raises if inspected result is not default external encoding"
-  fails "Array#inspect with encoding returns a US-ASCII string for an empty Array"
-  fails "Array#inspect with encoding use the default external encoding if it is ascii compatible"
-  fails "Array#inspect with encoding use US-ASCII encoding if the default external encoding is not ascii compatible"
-  fails "Array#join does not taint the result if the Array is tainted but empty"
-  fails "Array#join does not untrust the result if the Array is untrusted but empty"
-  fails "Array#join fails for arrays with incompatibly-encoded strings"
-  fails "Array#join returns a US-ASCII string for an empty Array"
-  fails "Array#join taints the result if the Array is tainted and non-empty"
-  fails "Array#join taints the result if the result of coercing an element is tainted"
-  fails "Array#join untrusts the result if the Array is untrusted and non-empty"
-  fails "Array#join untrusts the result if the result of coercing an element is untrusted"
-  fails "Array#join uses the first encoding when other strings are compatible"
-  fails "Array#join uses the widest common encoding when other strings are incompatible"
-  fails "Array#join with a tainted separator does not taint the result if the array has only one element"
-  fails "Array#join with a tainted separator does not taint the result if the array is empty"
-  fails "Array#join with a tainted separator taints the result if the array has two or more elements"
-  fails "Array#join with an untrusted separator does not untrust the result if the array has only one element"
-  fails "Array#join with an untrusted separator does not untrust the result if the array is empty"
-  fails "Array#join with an untrusted separator untrusts the result if the array has two or more elements"
-  fails "Array#keep_if on frozen objects returns an Enumerator if no block is given"
-  fails "Array#keep_if on frozen objects with falsy block keeps elements after any exception"
-  fails "Array#keep_if on frozen objects with falsy block raises a RuntimeError"
-  fails "Array#keep_if on frozen objects with truthy block keeps elements after any exception"
-  fails "Array#keep_if on frozen objects with truthy block raises a RuntimeError"
-  fails "Array#map does not copy tainted status"
-  fails "Array#map does not copy untrusted status"
-  fails "Array#map! keeps tainted status"
-  fails "Array#map! keeps untrusted status"
-  fails "Array#map! when frozen raises a RuntimeError when calling #each on the returned Enumerator when empty"
-  fails "Array#map! when frozen raises a RuntimeError when calling #each on the returned Enumerator"
-  fails "Array#map! when frozen raises a RuntimeError when empty"
-  fails "Array#map! when frozen raises a RuntimeError"
-  fails "Array#pop keeps taint status"
-  fails "Array#pop keeps untrusted status"
-  fails "Array#pop passed a number n as an argument keeps taint status"
-  fails "Array#pop passed a number n as an argument keeps untrusted status"
-  fails "Array#pop passed a number n as an argument raises a RuntimeError on a frozen array"
-  fails "Array#pop passed a number n as an argument returns a trusted array even if the array is untrusted"
-  fails "Array#pop passed a number n as an argument returns an untainted array even if the array is tainted"
-  fails "Array#pop raises a RuntimeError on a frozen array"
-  fails "Array#pop raises a RuntimeError on an empty frozen array"
-  fails "Array#push raises a RuntimeError on a frozen array"
-  fails "Array#reject! raises a RuntimeError on a frozen array"
-  fails "Array#reject! raises a RuntimeError on an empty frozen array"
-  fails "Array#reject! returns an Enumerator if no block given, and the array is frozen"
-  fails "Array#replace raises a RuntimeError on a frozen array"
-  fails "Array#reverse! raises a RuntimeError on a frozen array"
-  fails "Array#select! on frozen objects with falsy block keeps elements after any exception"
-  fails "Array#select! on frozen objects with falsy block raises a RuntimeError"
-  fails "Array#select! on frozen objects with truthy block keeps elements after any exception"
-  fails "Array#select! on frozen objects with truthy block raises a RuntimeError"
-  fails "Array#shift passed a number n as an argument keeps taint status"
-  fails "Array#shift passed a number n as an argument returns an untainted array even if the array is tainted"
-  fails "Array#shift raises a RuntimeError on a frozen array"
-  fails "Array#shift raises a RuntimeError on an empty frozen array"
-  fails "Array#shuffle! raises a RuntimeError on a frozen array"
-  fails "Array#slice raises a RangeError when the length is out of range of Fixnum"
-  fails "Array#slice raises a RangeError when the start index is out of range of Fixnum"
-  fails "Array#slice! raises a RuntimeError on a frozen array"
-  fails "Array#sort! raises a RuntimeError on a frozen array"
-  fails "Array#to_s does not taint the result if the Array is tainted but empty"
-  fails "Array#to_s does not untrust the result if the Array is untrusted but empty"
-  fails "Array#to_s represents a recursive element with '[...]'"
-  fails "Array#to_s taints the result if an element is tainted"
-  fails "Array#to_s taints the result if the Array is non-empty and tainted"
-  fails "Array#to_s untrusts the result if an element is untrusted"
-  fails "Array#to_s untrusts the result if the Array is untrusted"
-  fails "Array#to_s with encoding raises if inspected result is not default external encoding"
-  fails "Array#to_s with encoding returns a US-ASCII string for an empty Array"
-  fails "Array#to_s with encoding use the default external encoding if it is ascii compatible"
-  fails "Array#to_s with encoding use US-ASCII encoding if the default external encoding is not ascii compatible"
-  fails "Array#uniq compares elements with matching hash codes with #eql?" #RubySpec uses taint, which is not supported on Opal.
-  fails "Array#uniq uses eql? semantics" #RubySpec expects 1.0 and 1 to be seen as different, which is not supported on Opal.
-  fails "Array#uniq! doesn't yield to the block on a frozen array"
-  fails "Array#uniq! raises a RuntimeError on a frozen array when the array is modified"
-  fails "Array#uniq! raises a RuntimeError on a frozen array when the array would not be modified"
-  fails "Array#unshift raises a RuntimeError on a frozen array when the array is modified"
-  fails "Array#unshift raises a RuntimeError on a frozen array when the array would not be modified"
-  fails "Array#[] raises a RangeError when the length is out of range of Fixnum"
-  fails "Array#[] raises a RangeError when the start index is out of range of Fixnum"
-  fails "Array#[]= checks frozen before attempting to coerce arguments"
-  fails "Array#[]= raises a RuntimeError on a frozen array"
-end

data/spec/filters/unsupported/basicobject.rb

@@ -1,14 +0,0 @@
-opal_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,52 +0,0 @@
-opal_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"
-end

data/spec/filters/unsupported/class.rb

@@ -1,4 +0,0 @@
-opal_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_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_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_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/fixnum.rb

@@ -1,14 +0,0 @@
-opal_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,43 +0,0 @@
-opal_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
-end

data/spec/filters/unsupported/freeze.rb

@@ -1,53 +0,0 @@
-opal_filter "freezing" do
-  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 "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#freeze on a Symbol has no effect since it is already frozen"
-  fails "Kernel#freeze prevents self from being further modified"
-  fails "Kernel#freeze returns self"
-  fails "Kernel#frozen? on a Symbol returns true"
-  fails "Kernel#frozen? returns true if self is frozen"
-  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#const_set on a frozen module raises a RuntimeError before setting the name"
-  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#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"
-  fails "A singleton method definition raises RuntimeError if frozen"
-  fails "A method definition inside a metaclass scope raises RuntimeError if frozen"
-  fails "Hash literal does not change encoding of literal string keys during creation"
-  fails "Hash literal freezes string keys on initialization"
-end

data/spec/filters/unsupported/hash.rb

@@ -1,51 +0,0 @@
-opal_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 causes future comparisons on the receiver to be made by identity"
-  fails "Hash#compare_by_identity does not copy string keys"
-  fails "Hash#compare_by_identity perists over #dups"
-  fails "Hash#compare_by_identity persists over #clones"
-  fails "Hash#compare_by_identity raises a RuntimeError on frozen hashes"
-  fails "Hash#compare_by_identity regards #clone'd objects as having different identities"
-  fails "Hash#compare_by_identity regards #dup'd objects as having different identities"
-  fails "Hash#compare_by_identity regards references to the same object as having the same identity"
-  fails "Hash#compare_by_identity returns self"
-  fails "Hash#compare_by_identity uses #equal? semantics, but doesn't actually call #equal? to determine identity"
-  fails "Hash#compare_by_identity uses the semantics of BasicObject#equal? to determine key identity"
-  fails "Hash#compare_by_identity? returns false by default"
-  fails "Hash#compare_by_identity? returns true once #compare_by_identity has been invoked on self"
-  fails "Hash#compare_by_identity? returns true when called multiple times on the same ident hash"
-  fails "Hash#compare_by_identity does not call #hash on keys"
-  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_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"
-end

data/spec/filters/unsupported/integer.rb

@@ -1,3 +0,0 @@
-opal_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,31 +0,0 @@
-opal_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"
-end

data/spec/filters/unsupported/language.rb

@@ -1,17 +0,0 @@
-opal_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"
-end

data/spec/filters/unsupported/marshal.rb

@@ -1,46 +0,0 @@
-opal_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,30 +0,0 @@
-opal_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"
-end

data/spec/filters/unsupported/math.rb

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

data/spec/filters/unsupported/module.rb

@@ -1,8 +0,0 @@
-opal_filter "Module" do
-  fails "Module#class_variable_set raises a RuntimeError when self is frozen"
-  fails "Module#define_method is private"
-  fails "Module#define_method raises a RuntimeError if frozen"
-  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#instance_methods makes a private Object instance method public in Kernel"
-end

data/spec/filters/unsupported/pathname.rb

@@ -1,3 +0,0 @@
-opal_filter "Pathname" do
-  fails "Pathname.new is tainted if path is tainted"
-end