opal-cj 0.7.0.beta1

data/opal/corelib/variables.rb

@@ -0,0 +1,24 @@
+# regexp matches
+$& = $~ = $` = $' = nil
+
+# requires
+$LOADED_FEATURES = $" = `Opal.loaded_features`
+$LOAD_PATH       = $: = []
+
+# split lines
+$/ = "\n"
+$, = nil
+
+ARGV = []
+ARGF = Object.new
+ENV  = {}
+
+$VERBOSE = false
+$DEBUG   = false
+$SAFE    = 0
+
+RUBY_PLATFORM       = 'opal'
+RUBY_ENGINE         = 'opal'
+RUBY_VERSION        = '2.1.1'
+RUBY_ENGINE_VERSION = '0.6.1'
+RUBY_RELEASE_DATE   = '2014-04-15'

data/opal/opal.rb

@@ -0,0 +1,32 @@
+require 'corelib/runtime'
+require 'corelib/helpers'
+require 'corelib/module'
+require 'corelib/class'
+require 'corelib/basic_object'
+require 'corelib/kernel'
+require 'corelib/nil_class'
+require 'corelib/boolean'
+require 'corelib/error'
+require 'corelib/regexp'
+require 'corelib/comparable'
+require 'corelib/enumerable'
+require 'corelib/enumerator'
+require 'corelib/array'
+require 'corelib/array/inheritance'
+require 'corelib/hash'
+require 'corelib/string'
+require 'corelib/string/inheritance'
+require 'corelib/match_data'
+require 'corelib/numeric'
+require 'corelib/complex'
+require 'corelib/rational'
+require 'corelib/proc'
+require 'corelib/method'
+require 'corelib/range'
+require 'corelib/time'
+require 'corelib/struct'
+require 'corelib/io'
+require 'corelib/main'
+require 'corelib/variables'
+require 'corelib/dir'
+require 'corelib/file'

data/package.json

@@ -0,0 +1,9 @@
+{
+  "dependencies": {
+    "glob": "latest",
+    "js-yaml": "latest"
+  },
+  "devDependencies": {
+    "doxx": "latest"
+  }
+}

data/spec/filters/bugs/array.rb

@@ -0,0 +1,232 @@
+opal_filter "Array" do
+  fails "Array#clone copies singleton methods"
+
+  fails "Array#combination generates from a defensive copy, ignoring mutations"
+  fails "Array#combination yields a partition consisting of only singletons"
+  fails "Array#combination yields [] when length is 0"
+  fails "Array#combination yields a copy of self if the argument is the size of the receiver"
+  fails "Array#combination yields nothing if the argument is out of bounds"
+  fails "Array#combination yields the expected combinations"
+  fails "Array#combination yields nothing for out of bounds length and return self"
+  fails "Array#combination returns self when a block is given"
+  fails "Array#combination returns an enumerator when no block is provided"
+
+  fails "Array#<=> calls <=> left to right and return first non-0 result"
+  fails "Array#<=> returns -1 if the arrays have same length and a pair of corresponding elements returns -1 for <=>"
+  fails "Array#<=> returns +1 if the arrays have same length and a pair of corresponding elements returns +1 for <=>"
+  fails "Array#<=> tries to convert the passed argument to an Array using #to_ary"
+  fails "Array#<=> returns nil when the argument is not array-like"
+
+  fails "Array#delete may be given a block that is executed if no element matches object"
+  fails "Array#delete returns the last element in the array for which object is equal under #=="
+
+  fails "Array.[] can unpack 2 or more nested referenced array"
+
+  fails "Array#[]= sets elements in the range arguments when passed ranges"
+
+  fails "Array#flatten does not call flatten on elements"
+  fails "Array#flatten with a non-Array object in the Array ignores the return value of #to_ary if it is nil"
+  fails "Array#flatten with a non-Array object in the Array raises a TypeError if the return value of #to_ary is not an Array"
+  fails "Array#flatten raises a TypeError when the passed Object can't be converted to an Integer"
+  fails "Array#flatten tries to convert passed Objects to Integers using #to_int"
+
+  fails "Array#flatten! does not call flatten! on elements"
+  fails "Array#flatten! flattens any elements which responds to #to_ary, using the return value of said method"
+  fails "Array#flatten! raises a TypeError when the passed Object can't be converted to an Integer"
+  fails "Array#flatten! tries to convert passed Objects to Integers using #to_int"
+  fails "Array#flatten! should not check modification by size"
+
+  fails "Array#initialize with (size, object=nil) sets the array to the values returned by the block before break is executed"
+  fails "Array#initialize with (size, object=nil) returns the value passed to break"
+  fails "Array#initialize with (size, object=nil) uses the block value instead of using the default value"
+  fails "Array#initialize with (size, object=nil) yields the index of the element and sets the element to the value of the block"
+  fails "Array#initialize with (size, object=nil) raises a TypeError if the size argument is not an Integer type"
+  fails "Array#initialize with (size, object=nil) calls #to_int to convert the size argument to an Integer when object is not given"
+  fails "Array#initialize with (size, object=nil) calls #to_int to convert the size argument to an Integer when object is given"
+  fails "Array#initialize with (size, object=nil) raises an ArgumentError if size is too large"
+  fails "Array#initialize with (size, object=nil) sets the array to size and fills with the object"
+  fails "Array#initialize with (array) calls #to_ary to convert the value to an array"
+  fails "Array#initialize preserves the object's identity even when changing its value"
+
+  fails "Array#& determines equivalence between elements in the sense of eql?"
+
+  fails "Array#- removes an identical item even when its #eql? isn't reflexive"
+  fails "Array#- doesn't remove an item with the same hash but not #eql?"
+  fails "Array#- removes an item identified as equivalent via #hash and #eql?"
+
+  fails "Array#* raises a TypeError is the passed argument is nil"
+  fails "Array#* converts the passed argument to a String rather than an Integer"
+  fails "Array#* raises a TypeError if the argument can neither be converted to a string nor an integer"
+  fails "Array#* tires to convert the passed argument to an Integer using #to_int"
+  fails "Array#* tries to convert the passed argument to a String using #to_str"
+  fails "Array#* with a string uses the same separator with nested arrays"
+  fails "Array#* with a string returns a string formed by concatenating each element.to_str separated by separator"
+
+  fails "Array.new with (size, object=nil) raises an ArgumentError if size is too large"
+  fails "Array.new with (array) calls #to_ary to convert the value to an array"
+  fails "Array.new with (size, object=nil) calls #to_int to convert the size argument to an Integer when object is given"
+  fails "Array.new with (size, object=nil) calls #to_int to convert the size argument to an Integer when object is not given"
+  fails "Array.new with (size, object=nil) raises a TypeError if the size argument is not an Integer type"
+
+  fails "Array#permutation generates from a defensive copy, ignoring mutations"
+  fails "Array#permutation returns an Enumerator which works as expected even when the array was modified"
+  fails "Array#permutation truncates Float arguments"
+  fails "Array#permutation handles nested Arrays correctly"
+  fails "Array#permutation handles duplicate elements correctly"
+  fails "Array#permutation returns no permutations when the given length has no permutations"
+  fails "Array#permutation returns the empty permutation([]) when called on an empty Array"
+  fails "Array#permutation returns the empty permutation ([[]]) when the given length is 0"
+  fails "Array#permutation yields all permutations of given length to the block then returns self when called with block and argument"
+  fails "Array#permutation yields all permutations to the block then returns self when called with block but no arguments"
+  fails "Array#permutation returns an Enumerator of permutations of given length when called with an argument but no block"
+  fails "Array#permutation returns an Enumerator of all permutations when called without a block or arguments"
+
+  fails "Array#product when given an empty block returns self"
+  fails "Array#product when given a block will ignore unreasonable numbers of products and yield anyway"
+  fails "Array#product when given a block yields all combinations in turn"
+  fails "Array#product does not attempt to produce an unreasonable number of products"
+  fails "Array#product returns an empty array when the argument is an empty array"
+  fails "Array#product has no required argument"
+  fails "Array#product returns the expected result"
+  fails "Array#product returns converted arguments using :to_ary"
+
+  fails "Array#rassoc does not check the last element in each contained but speficically the second"
+  fails "Array#rassoc calls elem == obj on the second element of each contained array"
+
+  fails "Array#repeated_combination generates from a defensive copy, ignoring mutations"
+  fails "Array#repeated_combination accepts sizes larger than the original array"
+  fails "Array#repeated_combination yields a partition consisting of only singletons"
+  fails "Array#repeated_combination yields nothing when the array is empty and num is non zero"
+  fails "Array#repeated_combination yields [] when length is 0"
+  fails "Array#repeated_combination yields the expected repeated_combinations"
+  fails "Array#repeated_combination yields nothing for negative length and return self"
+  fails "Array#repeated_combination returns self when a block is given"
+  fails "Array#repeated_combination returns an enumerator when no block is provided"
+
+  fails "Array#repeated_permutation generates from a defensive copy, ignoring mutations"
+  fails "Array#repeated_permutation allows permutations larger than the number of elements"
+  fails "Array#repeated_permutation returns an Enumerator which works as expected even when the array was modified"
+  fails "Array#repeated_permutation truncates Float arguments"
+  fails "Array#repeated_permutation handles duplicate elements correctly"
+  fails "Array#repeated_permutation does not yield when called on an empty Array with a nonzero argument"
+  fails "Array#repeated_permutation yields the empty repeated_permutation ([[]]) when the given length is 0"
+  fails "Array#repeated_permutation yields all repeated_permutations to the block then returns self when called with block but no arguments"
+  fails "Array#repeated_permutation returns an Enumerator of all repeated permutations of given length when called without a block"
+
+  fails "Array#rindex rechecks the array size during iteration"
+
+  fails "Array#rotate! with an argument n raises a TypeError if not passed an integer-like argument"
+  fails "Array#rotate! with an argument n coerces the argument using to_int"
+  fails "Array#rotate! with an argument n moves the first (n % size) elements at the end and returns self"
+  fails "Array#rotate! when passed no argument moves the first element to the end and returns self"
+  fails "Array#rotate! raises a RuntimeError on a frozen array"
+  fails "Array#rotate! does nothing and returns self when the length is zero or one"
+  fails "Array#rotate with an argument n raises a TypeError if not passed an integer-like argument"
+  fails "Array#rotate with an argument n coerces the argument using to_int"
+  fails "Array#rotate with an argument n returns a copy of the array with the first (n % size) elements moved at the end"
+  fails "Array#rotate when passed no argument returns a copy of the array with the first element moved at the end"
+  fails "Array#rotate does not return subclass instance for Array subclasses"
+  fails "Array#rotate does not return self"
+  fails "Array#rotate does not mutate the receiver"
+  fails "Array#rotate returns a copy of the array when its length is one or zero"
+
+  fails "Array#sample calls #rand on the Object passed by the :random key in the arguments Hash"
+  fails "Array#sample calls #to_hash to convert the passed Object"
+  fails "Array#sample calls #to_int on the Object returned by #rand"
+  fails "Array#sample calls #to_int on the first argument and #to_hash on the second when passed Objects"
+  fails "Array#sample calls #to_int to convert the count when passed an Object"
+  fails "Array#sample does not return the same value if the Array has unique values"
+  fails "Array#sample ignores an Object passed for the RNG if it does not define #rand"
+  fails "Array#sample raises ArgumentError when passed a negative count"
+  fails "Array#sample raises a RangeError if the value is equal to the Array size"
+  fails "Array#sample raises a RangeError if the value is less than zero"
+  fails "Array#sample returns at most the number of elements in the Array"
+  fails "Array#sample when the object returned by #rand is not a Fixnum but responds to #to_int calls #to_int on the Object"
+  fails "Array#sample when the object returned by #rand is not a Fixnum but responds to #to_int raises a RangeError if the value is equal to the Array size"
+  fails "Array#sample when the object returned by #rand is not a Fixnum but responds to #to_int raises a RangeError if the value is less than zero"
+  fails "Array#sample with options calls #rand on the Object passed by the :random key in the arguments Hash"
+  fails "Array#sample with options calls #to_hash to convert the passed Object"
+  fails "Array#sample with options calls #to_int on the first argument and #to_hash on the second when passed Objects"
+  fails "Array#sample with options ignores an Object passed for the RNG if it does not define #rand"
+  fails "Array#sample with options when the object returned by #rand is a Fixnum raises a RangeError if the value is equal to the Array size"
+  fails "Array#sample with options when the object returned by #rand is a Fixnum raises a RangeError if the value is less than zero"
+  fails "Array#sample with options when the object returned by #rand is a Fixnum uses the fixnum as index"
+
+  fails "Array#select returns a new array of elements for which block is true"
+
+  fails "Array#shuffle attempts coercion via #to_hash"
+  fails "Array#shuffle is not destructive"
+  fails "Array#shuffle returns the same values, in a usually different order"
+  fails "Array#shuffle calls #rand on the Object passed by the :random key in the arguments Hash"
+  fails "Array#shuffle ignores an Object passed for the RNG if it does not define #rand"
+  fails "Array#shuffle accepts a Float for the value returned by #rand"
+  fails "Array#shuffle calls #to_int on the Object returned by #rand"
+  fails "Array#shuffle raises a RangeError if the value is less than zero"
+  fails "Array#shuffle raises a RangeError if the value is equal to one"
+
+  fails "Array#shuffle! returns the same values, in a usually different order"
+
+  fails "Array#slice! calls to_int on range arguments"
+  fails "Array#slice! calls to_int on start and length arguments"
+  fails "Array#slice! does not expand array with indices out of bounds"
+  fails "Array#slice! does not expand array with negative indices out of bounds"
+  fails "Array#slice! removes and return elements in range"
+  fails "Array#slice! removes and returns elements in end-exclusive ranges"
+
+  fails "Array#sort_by! makes some modification even if finished sorting when it would break in the given block"
+  fails "Array#sort_by! returns the specified value when it would break in the given block"
+  fails "Array#sort_by! raises a RuntimeError on an empty frozen array"
+  fails "Array#sort_by! raises a RuntimeError on a frozen array"
+  fails "Array#sort_by! completes when supplied a block that always returns the same result"
+  fails "Array#sort_by! returns an Enumerator if not given a block"
+  fails "Array#sort_by! sorts array in place by passing each element to the given block"
+
+  fails "Array#uniq compares elements based on the value returned from the block"
+  fails "Array#uniq compares elements with matching hash codes with #eql?"
+  fails "Array#uniq handles nil and false like any other values"
+  fails "Array#uniq uses eql? semantics"
+  fails "Array#uniq yields items in order"
+
+  fails "Array#uniq! compares elements based on the value returned from the block"
+
+  fails "Array#values_at returns an array of elements at the indexes when passed indexes"
+  fails "Array#values_at calls to_int on its indices"
+  fails "Array#values_at returns an array of elements in the ranges when passes ranges"
+  fails "Array#values_at calls to_int on arguments of ranges when passes ranges"
+  fails "Array#values_at does not return subclass instance on Array subclasses"
+  fails "Array#values_at when passed ranges returns an array of elements in the ranges"
+  fails "Array#values_at when passed ranges calls to_int on arguments of ranges"
+  fails "Array#values_at when passed a range fills with nil if the index is out of the range"
+  fails "Array#values_at when passed a range on an empty array fills with nils if the index is out of the range"
+
+
+  fails "Array#zip calls #to_ary to convert the argument to an Array"
+  fails "Array#zip uses #each to extract arguments' elements when #to_ary fails"
+
+  fails "Array#hash returns the same value if arrays are #eql?"
+  fails "Array#hash returns same hash code for arrays with the same content"
+  fails "Array#hash ignores array class differences"
+  fails "Array#hash calls to_int on result of calling hash on each element"
+  fails "Array#hash returns the same fixnum for arrays with the same content"
+
+  fails "Array#partition returns in the left array values for which the block evaluates to true"
+  fails "Array#partition returns two arrays"
+  fails "Array#partition does not return subclass instances on Array subclasses"
+
+  fails "Array#| acts as if using an intermediate hash to collect values"
+
+  # recursive arrays
+  fails "Array#join raises an ArgumentError when the Array is recursive"
+  fails "Array#uniq! properly handles recursive arrays"
+  fails "Array#| properly handles recursive arrays"
+  fails "Array#<=> properly handles recursive arrays"
+  fails "Array#eql? handles well recursive arrays"
+  fails "Array#== handles well recursive arrays"
+  fails "Array#flatten raises an ArgumentError on recursive arrays"
+  fails "Array#flatten! raises an ArgumentError on recursive arrays"
+  fails "Array#partition properly handles recursive arrays"
+  fails "Array#& properly handles recursive arrays"
+  fails "Array#values_at properly handles recursive arrays"
+  fails "Array#hash returns the same hash for equal recursive arrays through hashes"
+  fails "Array#hash returns the same hash for equal recursive arrays"
+end

data/spec/filters/bugs/basic_object.rb

@@ -0,0 +1,14 @@
+opal_filter "BasicObject" do
+  fails "BasicObject#instance_eval evaluates strings"
+  fails "BasicObject#singleton_method_added is called when a method is defined with alias_method in the singleton class"
+  fails "BasicObject#singleton_method_added is called when a method is defined with syntax alias in the singleton class"
+  fails "BasicObject instance metaclass contains methods defined for the BasicObject instance"
+  fails "BasicObject instance metaclass has BasicObject as superclass"
+  fails "BasicObject instance metaclass is an instance of Class"
+  fails "BasicObject metaclass contains methods for the BasicObject class"
+  fails "BasicObject metaclass has Class as superclass"
+  fails "BasicObject does not define built-in constants (according to defined?)"
+  fails "BasicObject does not define built-in constants (according to const_defined?)"
+  fails "BasicObject raises NameError when referencing built-in constants"
+  fails "BasicObject raises NoMethodError for nonexistent methods after #method_missing is removed"
+end

data/spec/filters/bugs/class.rb

@@ -0,0 +1,21 @@
+opal_filter "Class" do
+  fails "Class#allocate returns a fully-formed instance of Module"
+  fails "Class#allocate raises TypeError for #superclass"
+
+  fails "Class#dup stores the new name if assigned to a constant"
+  fails "Class#dup sets the name from the class to nil if not assigned to a constant"
+  fails "Class#dup retains the correct ancestor chain for the singleton class"
+  fails "Class#dup retains an included module in the ancestor chain for the singleton class"
+  fails "Class#dup duplicates both the class and the singleton class"
+
+  fails "Class#initialize_copy raises a TypeError when called on already initialized classes"
+  fails "Class#initialize_copy raises a TypeError when called on BasicObject"
+  fails "Class#initialize raises a TypeError when called on already initialized classes"
+  fails "Class#initialize raises a TypeError when called on BasicObject"
+  fails "Class#initialize when given the Class raises a TypeError"
+
+  fails "Class.new raises a TypeError if passed a metaclass"
+  fails "Class#new passes the block to #initialize"
+
+  fails "Class#superclass for a singleton class of a class returns the singleton class of its superclass"
+end

data/spec/filters/bugs/enumerable.rb

@@ -0,0 +1,69 @@
+opal_filter "Enumerable" do
+  fails "Enumerable#cycle passed a number n as an argument raises an ArgumentError if more arguments are passed"
+
+  fails "Enumerable#grep can use $~ in the block when used with a Regexp"
+
+  fails "Enumerable#inject returns nil when fails(legacy rubycon)"
+  fails "Enumerable#inject without inject arguments(legacy rubycon)"
+
+  fails "Enumerable#reduce returns nil when fails(legacy rubycon)"
+  fails "Enumerable#reduce without inject arguments(legacy rubycon)"
+
+  fails "Enumerable#chunk does not yield the object passed to #chunk if it is nil"
+  fails "Enumerable#chunk yields an element and an object value-equal but not identical to the object passed to #chunk"
+  fails "Enumerable#chunk raises a RuntimeError if the block returns a Symbol starting with an underscore other than :_alone or :_separator"
+  fails "Enumerable#chunk does not return elements for which the block returns nil"
+  fails "Enumerable#chunk does not return elements for which the block returns :_separator"
+  fails "Enumerable#chunk returns elements for which the block returns :_alone in separate Arrays"
+  fails "Enumerable#chunk returns elements of the Enumerable in an Array of Arrays, [v, ary], where 'ary' contains the consecutive elements for which the block returned the value 'v'"
+  fails "Enumerable#chunk yields the current element and the current chunk to the block"
+  fails "Enumerable#chunk returns an Enumerator if given a block"
+  fails "Enumerable#chunk raises an ArgumentError if called without a block"
+  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#chunk with [initial_state] does not yield the object passed to #chunk if it is nil"
+
+  fails "Enumerable#each_cons gathers whole arrays as elements when each yields multiple"
+  fails "Enumerable#each_cons returns an enumerator if no block"
+  fails "Enumerable#each_cons yields only as much as needed"
+  fails "Enumerable#each_cons works when n is >= full length"
+  fails "Enumerable#each_cons tries to convert n to an Integer using #to_int"
+  fails "Enumerable#each_cons raises an Argument Error if there is not a single parameter > 0"
+  fails "Enumerable#each_cons passes element groups to the block"
+
+  fails "Enumerable#each_entry passes extra arguments to #each"
+  fails "Enumerable#each_entry passes through the values yielded by #each_with_index"
+  fails "Enumerable#each_entry returns an enumerator if no block"
+  fails "Enumerable#each_entry yields multiple arguments as an array"
+
+  fails "Enumerable#minmax_by gathers whole arrays as elements when each yields multiple"
+  fails "Enumerable#minmax_by is able to return the maximum for enums that contain nils"
+  fails "Enumerable#minmax_by uses min/max.<=>(current) to determine order"
+  fails "Enumerable#minmax_by returns the object that appears first in #each in case of a tie"
+  fails "Enumerable#minmax_by returns the object for whom the value returned by block is the largest"
+  fails "Enumerable#minmax_by returns nil if #each yields no objects"
+  fails "Enumerable#minmax_by returns an enumerator if no block"
+
+  fails "Enumerable#minmax gathers whole arrays as elements when each yields multiple"
+  fails "Enumerable#minmax returns the minimum when using a block rule"
+  fails "Enumerable#minmax raises a NoMethodError for elements without #<=>"
+  fails "Enumerable#minmax raises an ArgumentError when elements are incomparable"
+  fails "Enumerable#minmax returns [nil, nil] for an empty Enumerable"
+  fails "Enumerable#minmax min should return the minimum element"
+
+  fails "Enumerable#reverse_each gathers whole arrays as elements when each yields multiple"
+
+  fails "Enumerable#sort gathers whole arrays as elements when each yields multiple"
+  fails "Enumerable#sort raises an error if objects can't be compared"
+  fails "Enumerable#sort compare values returned by block with 0"
+  fails "Enumerable#sort sorts enumerables that contain nils"
+  fails "Enumerable#sort raises a NoMethodError if elements do not define <=>"
+  fails "Enumerable#sort yields elements to the provided block"
+  fails "Enumerable#sort sorts by the natural order as defined by <=>"
+
+  fails "Enumerable#take_while calls the block with initial args when yielded with multiple arguments"
+
+  fails "Enumerable#zip passes each element of the result array to a block and return nil if a block is given"
+  fails "Enumerable#zip converts arguments to arrays using #to_ary"
+  fails "Enumerable#zip converts arguments to enums using #to_enum"
+  fails "Enumerable#zip gathers whole arrays as elements when each yields multiple"
+end

data/spec/filters/bugs/enumerator.rb

@@ -0,0 +1,3 @@
+opal_filter "Enumerator" do
+  fails "Enumerator#each requires multiple arguments" # arity issue
+end

data/spec/filters/bugs/hash.rb

@@ -0,0 +1,128 @@
+opal_filter "Hash" do
+  fails "Hash.[] coerces a single argument which responds to #to_ary"
+  fails "Hash.[] ignores elements that are not arrays"
+  fails "Hash.[] calls to_hash"
+  fails "Hash.[] returns an instance of a subclass when passed an Array"
+  fails "Hash.[] returns instances of subclasses"
+  fails "Hash.[] returns an instance of the class it's called on"
+  fails "Hash.[] does not call #initialize on the subclass instance"
+  fails "Hash.[] passed an array treats elements that are 1 element arrays as keys with value nil"
+  fails "Hash.[] passed a single argument which responds to #to_hash coerces it and returns a copy"
+  fails "Hash.[] removes the default_proc"
+
+  fails "Hash#assoc only returns the first matching key-value pair for identity hashes"
+
+  fails "Hash#default_proc= uses :to_proc on its argument"
+
+  fails "Hash#each properly expands (or not) child class's 'each'-yielded args"
+  fails "Hash#each yields the key only to a block expecting |key,|"
+
+  fails "Hash#each_pair properly expands (or not) child class's 'each'-yielded args"
+  fails "Hash#each_pair yields the key only to a block expecting |key,|"
+
+  fails "Hash#== compares the values in self to values in other hash"
+  fails "Hash#== returns true iff other Hash has the same number of keys and each key-value pair matches"
+  fails "Hash#== compares keys with matching hash codes via eql?"
+  fails "Hash#== compares keys with eql? semantics"
+  fails "Hash#== computes equality for recursive hashes & arrays"
+  fails "Hash#== computes equality for complex recursive hashes"
+  fails "Hash#== does not compare keys with different hash codes via eql?"
+  fails "Hash#== first compares keys via hash"
+
+  fails "Hash#eql? compares the values in self to values in other hash"
+  fails "Hash#eql? returns true iff other Hash has the same number of keys and each key-value pair matches"
+  fails "Hash#eql? compares keys with matching hash codes via eql?"
+  fails "Hash#eql? compares keys with eql? semantics"
+  fails "Hash#eql? computes equality for recursive hashes & arrays"
+  fails "Hash#eql? computes equality for complex recursive hashes"
+  fails "Hash#eql? does not compare keys with different hash codes via eql?"
+  fails "Hash#eql? first compares keys via hash"
+  fails "Hash#eql? does not compare values when keys don't match"
+
+  fails "Hash#[] calls subclass implementations of default"
+  fails "Hash#[] does not create copies of the immediate default value"
+  fails "Hash#[] compares keys with eql? semantics"
+  fails "Hash#[] compares key via hash"
+  fails "Hash#[] does not compare keys with different #hash values via #eql?"
+  fails "Hash#[] compares keys with the same #hash value via #eql?"
+  fails "Hash#[] finds a value via an identical key even when its #eql? isn't reflexive"
+
+  fails "Hash#[]= stores unequal keys that hash to the same value"
+  fails "Hash#[]= associates the key with the value and return the value"
+
+  fails "Hash#fetch raises an ArgumentError when not passed one or two arguments"
+
+  fails "Hash#flatten recursively flattens Array values to the given depth"
+  fails "Hash#flatten raises a TypeError if given a non-Integer argument"
+
+  fails "Hash#has_key? compares keys with the same #hash value via #eql?"
+  fails "Hash#has_key? returns true if argument is a key"
+
+  fails "Hash#hash returns the same hash for recursive hashes through arrays"
+  fails "Hash#hash returns the same hash for recursive hashes"
+  fails "Hash#hash generates a hash for recursive hash structures"
+  fails "Hash#hash returns a value which doesn't depend on the hash order"
+
+  fails "Hash#include? compares keys with the same #hash value via #eql?"
+  fails "Hash#include? returns true if argument is a key"
+
+  fails "Hash#invert compares new keys with eql? semantics"
+
+  fails "Hash#initialize_copy does not transfer default values"
+  fails "Hash#initialize_copy calls to_hash on hash subclasses"
+  fails "Hash#initialize_copy tries to convert the passed argument to a hash using #to_hash"
+  fails "Hash#initialize_copy replaces the contents of self with other"
+
+  fails "Hash#inspect handles hashes with recursive values"
+
+  fails "Hash#key? compares keys with the same #hash value via #eql?"
+  fails "Hash#key? returns true if argument is a key"
+
+  fails "Hash#member? compares keys with the same #hash value via #eql?"
+  fails "Hash#member? returns true if argument is a key"
+
+  fails "Hash#merge returns subclass instance for subclasses"
+
+  fails "Hash.new raises an ArgumentError if more than one argument is passed"
+  fails "Hash.new raises an ArgumentError if passed both default argument and default block"
+
+  fails "Hash#rassoc uses #== to compare the argument to the values"
+
+  fails "Hash#rehash reorganizes the hash by recomputing all key hash codes"
+
+  fails "Hash#reject returns subclass instance for subclasses"
+  fails "Hash#reject processes entries with the same order as reject!"
+  fails "Hash#reject! removes keys from self for which the block yields true"
+  fails "Hash#reject! is equivalent to delete_if if changes are made"
+  fails "Hash#reject! returns nil if no changes were made"
+  fails "Hash#reject! processes entries with the same order as delete_if"
+  fails "Hash#reject! returns an Enumerator if called on a non-empty hash without a block"
+  fails "Hash#reject! returns an Enumerator if called on an empty hash without a block"
+
+  fails "Hash#replace tries to convert the passed argument to a hash using #to_hash"
+  fails "Hash#replace does not transfer default values"
+
+  fails "Hash#select returns a Hash of entries for which block is true"
+
+  fails "Hash#shift returns (computed) default for empty hashes"
+
+  fails "Hash#store stores unequal keys that hash to the same value"
+  fails "Hash#store associates the key with the value and return the value"
+
+  fails "Hash#sort converts self to a nested array of [key, value] arrays and sort with Array#sort"
+  fails "Hash#sort works when some of the keys are themselves arrays"
+  fails "Hash#sort uses block to sort array if passed a block"
+
+  fails "Hash#to_h returns self for Hash instances"
+
+  fails "Hash#to_s handles hashes with recursive values"
+
+  fails "Hash.try_convert does not rescue exceptions raised by #to_hash"
+  fails "Hash.try_convert sends #to_hash to the argument and raises TypeError if it's not a kind of Hash"
+  fails "Hash.try_convert sends #to_hash to the argument and returns the result if it's a kind of Hash"
+  fails "Hash.try_convert sends #to_hash to the argument and returns the result if it's a Hash"
+  fails "Hash.try_convert sends #to_hash to the argument and returns the result if it's nil"
+  fails "Hash.try_convert returns nil when the argument does not respond to #to_hash"
+  fails "Hash.try_convert returns the argument if it's a kind of Hash"
+  fails "Hash.try_convert returns the argument if it's a Hash"
+end