opal 0.7.2 → 0.8.0.beta1

data/opal/corelib/string/inheritance.rb

@@ -15,6 +15,8 @@ class String
 end
 
 class String::Wrapper
+  `def.$$is_string = true`
+
   def self.allocate(string = "")
     obj = super()
     `obj.literal = string`
@@ -68,11 +70,26 @@ class String::Wrapper
     @literal
   end
 
-  def to_str
-    self
-  end
+  alias to_str to_s
 
   def inspect
     @literal.inspect
   end
+
+  def +(other)
+    @literal + other
+  end
+
+  def *(other)
+    %x{
+      var result = #{@literal * other};
+
+      if (result.$$is_string) {
+        return #{self.class.allocate(`result`)}
+      }
+      else {
+        return result;
+      }
+    }
+  end
 end

data/opal/corelib/struct.rb

@@ -1,4 +1,8 @@
+require 'corelib/enumerable'
+
 class Struct
+  include Enumerable
+
   def self.new(name = undefined, *args, &block)
     return super unless self == Struct
 
@@ -34,8 +38,6 @@ class Struct
   end
 
   def self.inherited(klass)
-    return if self == Struct
-
     members = @members
 
     klass.instance_eval {
@@ -47,8 +49,6 @@ class Struct
     alias [] new
   end
 
-  include Enumerable
-
   def initialize(*args)
     members.each_with_index {|name, index|
       instance_variable_set "@#{name}", args[index]
@@ -61,11 +61,14 @@ class Struct
 
   def [](name)
     if Integer === name
+      raise IndexError, "offset #{name} too small for struct(size:#{members.size})" if name < -members.size
       raise IndexError, "offset #{name} too large for struct(size:#{members.size})" if name >= members.size
 
       name = members[name]
-    else
+    elsif String === name
       raise NameError, "no member '#{name}' in struct" unless members.include?(name.to_sym)
+    else
+      raise TypeError, "no implicit conversion of #{name.class} into Integer"
     end
 
     instance_variable_get "@#{name}"
@@ -73,11 +76,14 @@ class Struct
 
   def []=(name, value)
     if Integer === name
+      raise IndexError, "offset #{name} too small for struct(size:#{members.size})" if name < -members.size
       raise IndexError, "offset #{name} too large for struct(size:#{members.size})" if name >= members.size
 
       name = members[name]
-    else
+    elsif String === name
       raise NameError, "no member '#{name}' in struct" unless members.include?(name.to_sym)
+    else
+      raise TypeError, "no implicit conversion of #{name.class} into Integer"
     end
 
     instance_variable_set "@#{name}", value
@@ -132,4 +138,22 @@ class Struct
   end
 
   alias to_s inspect
+
+  def to_h
+    members.inject({}) {|h, name| h[name] = self[name]; h}
+  end
+
+  def values_at(*args)
+    args = args.map{|arg| `arg.$$is_range ? #{arg.to_a} : arg`}.flatten
+    %x{
+      var result = [];
+      for (var i = 0, len = args.length; i < len; i++) {
+        if (!args[i].$$is_number) {
+          #{raise TypeError, "no implicit conversion of #{`args[i]`.class} into Integer"}
+        }
+        result.push(#{self[`args[i]`]});
+      }
+      return result;
+    }
+  end
 end

data/opal/corelib/variables.rb

@@ -20,5 +20,5 @@ $SAFE    = 0
 RUBY_PLATFORM       = 'opal'
 RUBY_ENGINE         = 'opal'
 RUBY_VERSION        = '2.1.1'
-RUBY_ENGINE_VERSION = '0.7.2'
-RUBY_RELEASE_DATE   = '2014-04-15'
+RUBY_ENGINE_VERSION = '0.8.0.dev'
+RUBY_RELEASE_DATE   = '2015-02-14'

data/spec/filters/bugs/array.rb

@@ -17,25 +17,10 @@ opal_filter "Array" do
   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"
@@ -81,15 +66,6 @@ opal_filter "Array" do
   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"
 
@@ -203,30 +179,15 @@ opal_filter "Array" do
   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/kernel.rb

@@ -1,10 +1,13 @@
 opal_filter "Kernel" do
-  fails "Kernel.rand returns a float if no argument is passed"
-  fails "Kernel.rand returns an integer for an integer argument"
+  fails "Kernel.Array does not call #to_a on an Array" #something funky with the spec itself
+  fails "Kernel#Array does not call #to_a on an Array" #something funky with the spec itself
 
-  fails "Kernel#<=> returns 0 if self is == to the argument"
-  fails "Kernel#<=> returns nil if self is eql? but not == to the argument"
-  fails "Kernel#<=> returns nil if self.==(arg) returns nil"
-
-  fails "Kernel#equal? returns true only if obj and other are the same object"
+  fails "Kernel.String raises a TypeError if #to_s does not exist"
+  fails "Kernel.String raises a TypeError if respond_to? returns false for #to_s"
+  fails "Kernel.String raises a TypeError if #to_s is not defined, even though #respond_to?(:to_s) returns true"
+  fails "Kernel.String calls #to_s if #respond_to?(:to_s) returns true"
+  fails "Kernel#String raises a TypeError if #to_s does not exist"
+  fails "Kernel#String raises a TypeError if respond_to? returns false for #to_s"
+  fails "Kernel#String raises a TypeError if #to_s is not defined, even though #respond_to?(:to_s) returns true"
+  fails "Kernel#String calls #to_s if #respond_to?(:to_s) returns true"
 end

data/spec/filters/bugs/module.rb

@@ -11,6 +11,16 @@ opal_filter "Module" do
 
   fails "Module#const_defined? should not search parent scopes of classes and modules if inherit is false"
   fails "Module#const_get should not search parent scopes of classes and modules if inherit is false"
+  fails "Module#const_get raises a NameError with the not found constant symbol"
+  fails "Module#const_get calls #to_str to convert the given name to a String"
+  fails "Module#const_get raises a TypeError if conversion to a String by calling #to_str fails"
+  fails "Module#const_get does not search the singleton class of a Class or Module"
+  fails "Module#const_get raises a NameError if the constant is defined in the receiver's supperclass and the inherit flag is false"
+  fails "Module#const_get accepts a toplevel scope qualifier"
+  fails "Module#const_get raises a NameError if a Symbol is a scoped constant name"
+  fails "Module#const_get with dynamically assigned constants searches a module included in the immediate class before the superclass"
+  fails "Module#const_get with dynamically assigned constants searches a module included in the superclass"
+  fails "Module#const_get with dynamically assigned constants searches the superclass chain"
 
   fails "Module#class_variable_set sets the value of a class variable with the given name defined in an included module"
   fails "Module#class_variable_get returns the value of a class variable with the given name defined in an included module"
@@ -28,4 +38,15 @@ opal_filter "Module" do
   fails "Module#module_function as a toggle (no arguments) in a Module body does not affect module_evaled method definitions also if outside the eval itself"
   fails "Module#module_function as a toggle (no arguments) in a Module body has no effect if inside a module_eval if the definitions are outside of it"
   fails "Module#module_function with specific method names creates an independent copy of the method, not a redirect"
+
+  fails "Module#include adds all ancestor modules when a previously included module is included again"
+  fails "Module#include raises a TypeError when the argument is not a Module"
+  fails "Module#include imports instance methods to modules and classes"
+  fails "Module#include doesn't include module if it is included in a super class"
+  fails "Module#include recursively includes new mixins"
+  fails "Module#include preserves ancestor order"
+  fails "Module#include detects cyclic includes"
+  fails "Module#include ignores modules it has already included via module mutual inclusion"
+  fails "Module#include? returns true if the given module is included by self or one of it's ancestors"
+  fails "Module#include? raises a TypeError when no module was given"
 end

data/spec/filters/bugs/opal.rb

@@ -5,10 +5,5 @@ opal_filter "Opal bugs" do
   fails "Array#shift passed a number n as an argument raises an ArgumentError if more arguments are passed"
   fails "Array#pop passed a number n as an argument raises an ArgumentError if more arguments are passed"
 
-  # lacking regexp conversion
-  fails "String#index with Regexp supports \\G which matches at the given start offset"
-  fails "String#index with Regexp starts the search at the given offset"
-  fails "String#index with Regexp returns the index of the first match of regexp"
-
   fails "Kernel#warn requires multiple arguments"
 end

data/spec/filters/bugs/singleton.rb

@@ -1,6 +1,4 @@
 opal_filter "Singleton" do
-  fails "Singleton#_dump returns an empty string"
-  fails "Singleton#_dump returns an empty string from a singleton subclass"
   fails "Singleton.instance returns an instance of the singleton's clone"
   fails "Singleton.instance returns the same instance for multiple class to instance on clones"
 end

data/spec/filters/bugs/string.rb

@@ -1,248 +1,25 @@
 opal_filter "String" do
-  fails "String#=== ignores subclass differences"
-  fails "String#=== returns false if obj does not respond to to_str"
-  fails "String#=== returns obj == self if obj responds to to_str"
-  fails "String#=== returns obj == self if obj responds to to_str"
-
-  fails "String#=~ raises a TypeError if a obj is a string"
-
-  fails "String#[] calls to_int on the given index"
-  fails "String#[] calls to_int on the given index"
-  fails "String#[] raises a TypeError if the given index is nil"
-  fails "String#[] raises a TypeError if the given index can't be converted to an Integer"
-  fails "String#[] with index, length returns nil if the length is negative"
-  fails "String#[] with index, length calls to_int on the given index and the given length"
-  fails "String#[] with index, length calls to_int on the given index and the given length"
-  fails "String#[] with index, length raises a TypeError when idx or length can't be converted to an integer"
-  fails "String#[] with index, length raises a TypeError when the given index or the given length is nil"
-  fails "String#[] with Range returns nil if the beginning of the range falls outside of self"
-  fails "String#[] with Range calls to_int on range arguments"
+  #The following two failures are waiting for https://github.com/opal/opal/issues/710 to be fixed
   fails "String#[] with Range calls to_int on range arguments"
-  fails "String#[] with Range handles repeated application"
-  fails "String#[] with Regexp returns the matching portion of self"
-  fails "String#[] with Regexp returns nil if there is no match"
-  fails "String#[] with Regexp sets $~ to MatchData when there is a match and nil when there's none"
-  fails "String#[] with Regexp, index returns the capture for the given index"
-  fails "String#[] with Regexp, index returns nil if there is no match"
-  fails "String#[] with Regexp, index returns nil if there is no capture for the given index"
-  fails "String#[] with Regexp, index calls to_int on the given index"
-  fails "String#[] with Regexp, index calls to_int on the given index"
-  fails "String#[] with Regexp, index raises a TypeError when the given index can't be converted to Integer"
-  fails "String#[] with Regexp, index raises a TypeError when the given index is nil"
-  fails "String#[] with Regexp, index sets $~ to MatchData when there is a match and nil when there's none"
-  fails "String#[] with String returns other_str if it occurs in self"
-  fails "String#[] with String returns nil if there is no match"
-  fails "String#[] with String doesn't call to_str on its argument"
-  fails "String#[] with String returns a subclass instance when given a subclass instance"
+  fails "String#slice with Range calls to_int on range arguments"
 
-  fails "String#dup does not copy constants defined in the singleton class"
-  fails "String#dup does not modify the original string when changing dupped string"
+  fails "String#clone copies singleton methods"
+  fails "String#clone copies modules included in the singleton class"
+  fails "String#clone does not modify the original string when changing cloned string"
 
-  fails "String#end_with? converts its argument using :to_str"
-  fails "String#end_with? returns true if other is empty"
+  fails "String#dup does not copy constants defined in the singleton class"
 
-  fails "String#each_line accepts a string separator"
-  fails "String#each_line passes self as a whole to the block if the separator is nil"
-  fails "String#each_line yields paragraphs (broken by 2 or more successive newlines) when passed ''"
-  fails "String#each_line uses $/ as the separator when none is given"
   fails "String#each_line yields subclass instances for subclasses"
-  fails "String#each_line tries to convert the separator to a string using to_str"
-  fails "String#each_line tries to convert the separator to a string using to_str"
-  fails "String#each_line does not care if the string is modified while substituting"
-  fails "String#each_line raises a TypeError when the separator can't be converted to a string"
-  fails "String#each_line accept string separator"
-  fails "String#each_line raises a TypeError when the separator is a symbol"
-  fails "String#each_line returns an enumerator when no block given"
-
-  fails "String#gsub with pattern and replacement inserts the replacement around every character when the pattern collapses"
-  fails "String#gsub with pattern and replacement respects $KCODE when the pattern collapses"
-  fails "String#gsub with pattern and replacement doesn't freak out when replacing ^"
-  fails "String#gsub with pattern and replacement returns a copy of self with all occurrences of pattern replaced with replacement"
-  fails "String#gsub with pattern and replacement supports \\G which matches at the beginning of the remaining (non-matched) string"
-  fails "String#gsub with pattern and replacement replaces \\1 sequences with the regexp's corresponding capture"
-  fails "String#gsub with pattern and replacement treats \\1 sequences without corresponding captures as empty strings"
-  fails "String#gsub with pattern and replacement replaces \\& and \\0 with the complete match"
-  fails "String#gsub with pattern and replacement replaces \\` with everything before the current match"
-  fails "String#gsub with pattern and replacement replaces \\' with everything after the current match"
-  fails "String#gsub with pattern and replacement replaces \\+ with the last paren that actually matched"
-  fails "String#gsub with pattern and replacement treats \\+ as an empty string if there was no captures"
-  fails "String#gsub with pattern and replacement maps \\\\ in replacement to \\"
-  fails "String#gsub with pattern and replacement handles pattern collapse without $KCODE"
-  fails "String#gsub with pattern and replacement raises a TypeError when replacement can't be converted to a string"
-  fails "String#gsub with pattern and replacement sets $~ to MatchData of last match and nil when there's none"
-  fails "String#gsub with pattern and Hash returns a copy of self with all occurrences of pattern replaced with the value of the corresponding hash key"
-  fails "String#gsub with pattern and Hash ignores keys that don't correspond to matches"
-  fails "String#gsub with pattern and Hash returns an empty string if the pattern matches but the hash specifies no replacements"
-  fails "String#gsub with pattern and Hash ignores non-String keys"
-  fails "String#gsub with pattern and Hash uses a key's value as many times as needed"
-  fails "String#gsub with pattern and Hash uses the hash's default value for missing keys"
-  fails "String#gsub with pattern and Hash coerces the hash values with #to_s"
-  fails "String#gsub with pattern and Hash coerces the hash values with #to_s"
-  fails "String#gsub with pattern and Hash uses the hash's value set from default_proc for missing keys"
-  fails "String#gsub with pattern and Hash sets $~ to MatchData of last match and nil when there's none for access from outside"
-  fails "String#gsub with pattern and Hash doesn't interpolate special sequences like \\1 for the block's return value"
-  fails "String#gsub with pattern and block sets $~ for access from the block"
-  fails "String#gsub with pattern and block restores $~ after leaving the block"
-  fails "String#gsub with pattern and block sets $~ to MatchData of last match and nil when there's none for access from outside"
-
-  fails "String#index raises a TypeError if passed a Symbol"
 
-  fails "String#intern does not special case certain operators"
-  fails "String#intern special cases +(binary) and -(binary)"
-
-  fails "String#lines accepts a string separator"
-  fails "String#lines should split on the default record separator and return enumerator if not block is given"
-  fails "String#lines splits using default newline separator when none is specified"
-  fails "String#lines splits self using the supplied record separator and passes each substring to the block"
-  fails "String#lines passes self as a whole to the block if the separator is nil"
-  fails "String#lines yields paragraphs (broken by 2 or more successive newlines) when passed ''"
   fails "String#lines yields subclass instances for subclasses"
-  fails "String#lines returns self"
-  fails "String#lines tries to convert the separator to a string using to_str"
-  fails "String#lines tries to convert the separator to a string using to_str"
-  fails "String#lines does not care if the string is modified while substituting"
-  fails "String#lines raises a TypeError when the separator can't be converted to a string"
-  fails "String#lines accept string separator"
-  fails "String#lines raises a TypeError when the separator is a symbol"
-  fails "String#lines returns an array when no block given"
-
-  fails "String#lstrip returns a copy of self with leading whitespace removed"
-
-  fails "String#next returns the successor by increasing the rightmost alphanumeric (digit => digit, letter => letter with same case)"
-  fails "String#next increases the next best alphanumeric (jumping over non-alphanumerics) if there is a carry"
-  fails "String#next increases the next best character if there is a carry for non-alphanumerics"
-  fails "String#next adds an additional character (just left to the last increased one) if there is a carry and no character left to increase"
-
-
-  fails "String#partition with String accepts regexp"
-  fails "String#partition with String sets global vars if regexp used"
-  fails "String#partition with String converts its argument using :to_str"
-  fails "String#partition with String converts its argument using :to_str"
-  fails "String#partition with String raises an error if not convertible to string"
-
-  fails "String#rindex with object raises a TypeError if obj isn't a String, Fixnum or Regexp"
-  fails "String#rindex with object tries to convert obj to a string via to_str"
-  fails "String#rindex with String ignores string subclasses"
-  fails "String#rindex with String returns nil if the substring isn't found"
-  fails "String#rindex with String raises a TypeError when given offset is nil"
-  fails "String#rindex with Regexp behaves the same as String#rindex(string) for escaped string regexps"
-  fails "String#rindex with Regexp returns the index of the first match from the end of string of regexp"
-  fails "String#rindex with Regexp sets $~ to MatchData of match and nil when there's none"
-  fails "String#rindex with Regexp starts the search at the given offset"
-  fails "String#rindex with Regexp supports \\G which matches at the given start offset"
-  fails "String#rindex with Regexp tries to convert start_offset to an integer via to_int"
-  fails "String#rindex with Regexp raises a TypeError when given offset is nil"
-
-  fails "String#rstrip returns a copy of self with trailing whitespace removed"
-  fails "String#rstrip returns a copy of self with all trailing whitespace and NULL bytes removed"
-
-  fails "String#slice calls to_int on the given index"
-  fails "String#slice calls to_int on the given index"
-  fails "String#slice raises a TypeError if the given index is nil"
-  fails "String#slice raises a TypeError if the given index can't be converted to an Integer"
-  fails "String#slice with index, length returns nil if the length is negative"
-  fails "String#slice with index, length calls to_int on the given index and the given length"
-  fails "String#slice with index, length calls to_int on the given index and the given length"
-  fails "String#slice with index, length raises a TypeError when idx or length can't be converted to an integer"
-  fails "String#slice with index, length raises a TypeError when the given index or the given length is nil"
-  fails "String#slice with Range returns nil if the beginning of the range falls outside of self"
-  fails "String#slice with Range calls to_int on range arguments"
-  fails "String#slice with Range calls to_int on range arguments"
-  fails "String#slice with Range handles repeated application"
-  fails "String#slice with Regexp returns the matching portion of self"
-  fails "String#slice with Regexp returns nil if there is no match"
-  fails "String#slice with Regexp sets $~ to MatchData when there is a match and nil when there's none"
-  fails "String#slice with Regexp, index returns the capture for the given index"
-  fails "String#slice with Regexp, index returns nil if there is no match"
-  fails "String#slice with Regexp, index returns nil if there is no capture for the given index"
-  fails "String#slice with Regexp, index calls to_int on the given index"
-  fails "String#slice with Regexp, index calls to_int on the given index"
-  fails "String#slice with Regexp, index raises a TypeError when the given index can't be converted to Integer"
-  fails "String#slice with Regexp, index raises a TypeError when the given index is nil"
-  fails "String#slice with Regexp, index sets $~ to MatchData when there is a match and nil when there's none"
-  fails "String#slice with String returns other_str if it occurs in self"
-  fails "String#slice with String returns nil if there is no match"
-  fails "String#slice with String doesn't call to_str on its argument"
-  fails "String#slice with String returns a subclass instance when given a subclass instance"
-  fails "String#slice with Regexp, group"
 
   fails "String#split with String returns subclass instances based on self"
-  fails "String#split with Regexp respects $KCODE when splitting between characters"
   fails "String#split with Regexp includes all captures in the result array"
   fails "String#split with Regexp does not include non-matching captures in the result array"
   fails "String#split with Regexp returns subclass instances based on self"
   fails "String#split with Regexp does not call constructor on created subclass instances"
   fails "String#split with String does not call constructor on created subclass instances"
 
-  fails "String#squeeze negates sets starting with ^"
-  fails "String#squeeze squeezes all chars in a sequence"
-  fails "String#squeeze raises an ArgumentError when the parameter is out of sequence"
-
-  fails "String#start_with? ignores arguments not convertible to string"
-  fails "String#start_with? converts its argument using :to_str"
-
-  fails "String#strip returns a new string with leading and trailing whitespace removed"
-  fails "String#strip returns a copy of self with trailing NULL bytes and whitespace"
-
-  fails "String#sub with pattern, replacement supports \\G which matches at the beginning of the string"
-  fails "String#sub with pattern, replacement replaces \\1 sequences with the regexp's corresponding capture"
-  fails "String#sub with pattern, replacement treats \\1 sequences without corresponding captures as empty strings"
-  fails "String#sub with pattern, replacement replaces \\& and \\0 with the complete match"
-  fails "String#sub with pattern, replacement replaces \\` with everything before the current match"
-  fails "String#sub with pattern, replacement replaces \\' with everything after the current match"
-  fails "String#sub with pattern, replacement replaces \\+ with the last paren that actually matched"
-  fails "String#sub with pattern, replacement treats \\+ as an empty string if there was no captures"
-  fails "String#sub with pattern, replacement sets $~ to MatchData of match and nil when there's none"
-  fails "String#sub with pattern and block sets $~ for access from the block"
-  fails "String#sub with pattern and block sets $~ to MatchData of last match and nil when there's none for access from outside"
-  fails "String#sub with pattern and block doesn't raise a RuntimeError if the string is modified while substituting"
-
-  fails "String#succ returns the successor by increasing the rightmost alphanumeric (digit => digit, letter => letter with same case)"
-  fails "String#succ increases the next best alphanumeric (jumping over non-alphanumerics) if there is a carry"
-  fails "String#succ increases the next best character if there is a carry for non-alphanumerics"
-  fails "String#succ adds an additional character (just left to the last increased one) if there is a carry and no character left to increase"
-
-  fails "String#sum returns a basic n-bit checksum of the characters in self"
-  fails "String#sum tries to convert n to an integer using to_int"
-  fails "String#sum tries to convert n to an integer using to_int"
-  fails "String#sum returns sum of the bytes in self if n less or equal to zero"
-
-  fails "String#to_str returns a new instance of String when called on a subclass"
-
-  fails "String#to_sym does not special case certain operators"
-  fails "String#to_sym special cases +(binary) and -(binary)"
-
-  fails "String#tr raises an ArgumentError a descending range in the replacement as containing just the start character"
-  fails "String#tr raises an ArgumentError a descending range in the source as empty"
-  fails "String#tr translates chars not in from_string when it starts with a ^"
-  fails "String#tr tries to convert from_str and to_str to strings using to_str"
-  fails "String#tr tries to convert from_str and to_str to strings using to_str"
-
-  fails "String#tr_s translates chars not in from_string when it starts with a ^"
-  fails "String#tr_s tries to convert from_str and to_str to strings using to_str"
-
-  fails "String#sub with pattern, replacement replaces \\\\\\+ with \\\\+"
-  fails "String#sub with pattern, replacement replaces \\\\\1 with \\"
-  fails "String#sub with pattern, replacement replaces \\\1 with \1"
-  fails "String#sub with pattern and Hash returns a copy of self with the first occurrence of pattern replaced with the value of the corresponding hash key"
-  fails "String#sub with pattern and Hash removes keys that don't correspond to matches"
-  fails "String#sub with pattern and Hash ignores non-String keys"
-  fails "String#sub with pattern and Hash uses a key's value only a single time"
-  fails "String#sub with pattern and Hash uses the hash's default value for missing keys"
-  fails "String#sub with pattern and Hash coerces the hash values with #to_s"
-  fails "String#sub with pattern and Hash uses the hash's value set from default_proc for missing keys"
-  fails "String#sub with pattern and Hash sets $~ to MatchData of first match and nil when there's none for access from outside"
-  fails "String#sub with pattern and Hash doesn't interpolate special sequences like \\1 for the block's return value"
-  fails "String#sub with pattern and Hash untrusts the result if the original string is untrusted"
-  fails "String#sub with pattern and Hash untrusts the result if a hash value is untrusted"
-  fails "String#sub with pattern and Hash taints the result if the original string is tainted"
-  fails "String#sub with pattern and Hash taints the result if a hash value is tainted"
-
-
-
-  fails "String#casecmp independent of case for non-ASCII characters returns -1 when numerically less than other"
-  fails "String#casecmp independent of case for non-ASCII characters returns 1 when numerically greater than other"
-
   fails "String#byteslice returns the character code of the character at the given index"
   fails "String#byteslice returns nil if index is outside of self"
   fails "String#byteslice calls to_int on the given index"
@@ -266,95 +43,72 @@ opal_filter "String" do
   fails "String#byteslice with Range works with Range subclasses"
   fails "String#byteslice with Range handles repeated application"
 
-  fails "String#count counts occurrences of chars from the intersection of the specified sets"
-  fails "String#count negates sets starting with ^"
-  fails "String#count counts all chars in a sequence"
-  fails "String#count raises if the given sequences are invalid"
-  fails "String#count calls #to_str to convert each set arg to a String"
-  fails "String#count raises a TypeError when a set arg can't be converted to a string"
-
-  fails "String#delete returns a new string with the chars from the intersection of sets removed"
-  fails "String#delete raises an ArgumentError when given no arguments"
-  fails "String#delete negates sets starting with ^"
-  fails "String#delete deletes all chars in a sequence"
-  fails "String#delete respects backslash for escaping a -"
-  fails "String#delete raises if the given ranges are invalid"
-  fails "String#delete taints result when self is tainted"
-  fails "String#delete tries to convert each set arg to a string using to_str"
-  fails "String#delete raises a TypeError when one set arg can't be converted to a string"
-  fails "String#delete returns subclass instances when called on a subclass"
+  fails "String#getbyte returns an Integer if given a valid index"
+  fails "String#getbyte starts indexing at 0"
+  fails "String#getbyte counts from the end of the String if given a negative argument"
+  fails "String#getbyte returns an Integer between 0 and 255"
+  fails "String#getbyte regards a multi-byte character as having multiple bytes"
+  fails "String#getbyte mirrors the output of #bytes"
+  fails "String#getbyte interprets bytes relative to the String's encoding"
+  fails "String#getbyte returns nil for out-of-bound indexes"
+  fails "String#getbyte regards the empty String as containing no bytes"
+  fails "String#getbyte raises a TypeError unless its argument can be coerced into an Integer"
 
   fails "String#each_byte returns an enumerator when no block given"
   fails "String#each_byte keeps iterating from the old position (to new string end) when self changes"
   fails "String#each_byte passes each byte in self to the given block"
 
-  fails "String#== returns obj == self if obj responds to to_str"
-  fails "String#== returns false if obj does not respond to to_str"
-  fails "String#eql? when given a non-String returns false"
-
-  fails "String#hex treats leading characters of self as a string of hex digits"
-
-  fails "String#initialize with an argument raises a RuntimeError on a frozen instance when self-replacing"
-  fails "String#initialize with an argument raises a RuntimeError on a frozen instance that is modified"
-  fails "String#initialize with an argument raises a TypeError if other can't be converted to string"
-  fails "String#initialize with an argument tries to convert other to string using to_str"
-  fails "String#initialize with an argument replaces the encoding of self with that of other"
-  fails "String#initialize with an argument does not trust self if other is trusted"
-  fails "String#initialize with an argument untrusts self if other is untrusted"
-  fails "String#initialize with an argument does not untaint self if other is untainted"
-  fails "String#initialize with an argument taints self if other is tainted"
-  fails "String#initialize with an argument replaces the content of self with other"
-  fails "String#initialize with an argument returns self"
-  fails "String#initialize with no arguments does not raise an exception when frozen"
-  fails "String#initialize is a private method"
-
-  fails "String#upto passes successive values, starting at self and ending at other_string, to the block"
-  fails "String#upto calls the block once even when start eqals stop"
-  fails "String#upto doesn't call block with self even if self is less than stop but stop length is less than self length"
-  fails "String#upto doesn't call block if stop is less than self and stop length is less than self length"
-  fails "String#upto doesn't call the block if self is greater than stop"
-  fails "String#upto stops iterating as soon as the current value's character count gets higher than stop's"
-  fails "String#upto returns self"
-  fails "String#upto tries to convert other to string using to_str"
-  fails "String#upto raises a TypeError if other can't be converted to a string"
-  fails "String#upto does not work with symbols"
-  fails "String#upto returns an enumerator when no block given"
-  fails "String#upto returns non-alphabetic characters in the ASCII range for single letters"
-  fails "String#upto stops before the last value if exclusive"
-  fails "String#upto on sequence of numbers calls the block as Integer#upto"
-
-  fails "String#* always taints the result when self is tainted"
-  fails "String#* returns subclass instances"
-  fails "String#* raises a RangeError when given integer is a Bignum"
-  fails "String#* raises an ArgumentError when given integer is negative"
-  fails "String#* tries to convert the given argument to an integer using to_int"
-
-  fails "String.new returns a binary String"
-  fails "String.new raises TypeError on inconvertible object"
-  fails "String.new is called on subclasses"
-  fails "String.new returns an instance of a subclass"
-  fails "String.new returns a new string given a string argument"
-  fails "String.new returns a fully-formed String"
-
-  fails "String#+ taints the result when self or other is tainted"
-  fails "String#+ when self is in an ASCII-incompatible encoding incompatible with the argument's encoding uses self's encoding if both are empty"
-  fails "String#+ when self is in an ASCII-incompatible encoding incompatible with the argument's encoding uses self's encoding if the argument is empty"
-  fails "String#+ when self is in an ASCII-incompatible encoding incompatible with the argument's encoding uses the argument's encoding if self is empty"
-  fails "String#+ when self is in an ASCII-incompatible encoding incompatible with the argument's encoding raises Encoding::CompatibilityError if neither are empty"
-  fails "String#+ when the argument is in an ASCII-incompatible encoding incompatible with self's encoding uses self's encoding if both are empty"
-  fails "String#+ when the argument is in an ASCII-incompatible encoding incompatible with self's encoding uses self's encoding if the argument is empty"
-  fails "String#+ when the argument is in an ASCII-incompatible encoding incompatible with self's encoding uses the argument's encoding if self is empty"
-  fails "String#+ when the argument is in an ASCII-incompatible encoding incompatible with self's encoding raises Encoding::CompatibilityError if neither are empty"
-  fails "String#+ when self and the argument are in different ASCII-compatible encodings uses self's encoding if both are ASCII-only"
-  fails "String#+ when self and the argument are in different ASCII-compatible encodings uses self's encoding if the argument is ASCII-only"
-  fails "String#+ when self and the argument are in different ASCII-compatible encodings uses the argument's encoding if self is ASCII-only"
-  fails "String#+ when self and the argument are in different ASCII-compatible encodings raises Encoding::CompatibilityError if neither are ASCII-only"
-  fails "String#+ when self is ASCII-8BIT and argument is US-ASCII uses ASCII-8BIT encoding"
-
-  fails "String#rpartition with String raises an error if not convertible to string"
-  fails "String#rpartition with String converts its argument using :to_str"
-  fails "String#rpartition with String affects $~"
-  fails "String#rpartition with String accepts regexp"
-  fails "String#rpartition with String always returns 3 elements"
-  fails "String#rpartition with String returns an array of substrings based on splitting on the given string"
+  fails "String#to_c returns a Complex object"
+  fails "String#to_c understands integers"
+  fails "String#to_c understands negative integers"
+  fails "String#to_c understands fractions (numerator/denominator) for the real part"
+  fails "String#to_c understands fractions (numerator/denominator) for the imaginary part"
+  fails "String#to_c understands negative fractions (-numerator/denominator) for the real part"
+  fails "String#to_c understands negative fractions (-numerator/denominator) for the imaginary part"
+  fails "String#to_c understands floats (a.b) for the real part"
+  fails "String#to_c understands floats (a.b) for the imaginary part"
+  fails "String#to_c understands negative floats (-a.b) for the real part"
+  fails "String#to_c understands negative floats (-a.b) for the imaginary part"
+  fails "String#to_c understands an integer followed by 'i' to mean that integer is the imaginary part"
+  fails "String#to_c understands a negative integer followed by 'i' to mean that negative integer is the imaginary part"
+  fails "String#to_c understands an 'i' by itself as denoting a complex number with an imaginary part of 1"
+  fails "String#to_c understands a '-i' by itself as denoting a complex number with an imaginary part of -1"
+  fails "String#to_c understands 'a+bi' to mean a complex number with 'a' as the real part, 'b' as the imaginary"
+  fails "String#to_c understands 'a-bi' to mean a complex number with 'a' as the real part, '-b' as the imaginary"
+  fails "String#to_c understands scientific notation for the real part"
+  fails "String#to_c understands negative scientific notation for the real part"
+  fails "String#to_c understands scientific notation for the imaginary part"
+  fails "String#to_c understands negative scientific notation for the imaginary part"
+  fails "String#to_c understands scientific notation for the real and imaginary part in the same String"
+  fails "String#to_c understands negative scientific notation for the real and imaginary part in the same String"
+  fails "String#to_c returns a complex number with 0 as the real part, 0 as the imaginary part for unrecognised Strings"
+
+  fails "String#to_r returns a Rational object"
+  fails "String#to_r returns (0/1) for the empty String"
+  fails "String#to_r returns (n/1) for a String starting with a decimal _n_"
+  fails "String#to_r ignores trailing characters"
+  fails "String#to_r ignores leading spaces"
+  fails "String#to_r does not ignore arbitrary, non-numeric leading characters"
+  fails "String#to_r treats leading hypens as minus signs"
+  fails "String#to_r does not treat a leading period without a numeric prefix as a decimal point"
+  fails "String#to_r understands decimal points"
+  fails "String#to_r ignores underscores between numbers"
+  fails "String#to_r understands a forward slash as separating the numerator from the denominator"
+  fails "String#to_r returns (0/1) for Strings it can't parse"
+
+  fails "String#dump taints the result if self is tainted"
+  fails "String#dump untrusts the result if self is untrusted"
+  fails "String#dump returns a subclass instance"
+  fails "String#dump returns a string with special characters replaced with \\<char> notation"
+  fails "String#dump returns a string with \" and \\ escaped with a backslash"
+  fails "String#dump returns a string with \\#<char> when # is followed by $, @, {"
+  fails "String#dump returns a string with # not escaped when followed by any other character"
+  fails "String#dump returns a string with printable non-alphanumeric characters unescaped"
+  fails "String#dump returns a string with numeric characters unescaped"
+  fails "String#dump returns a string with upper-case alpha characters unescaped"
+  fails "String#dump returns a string with lower-case alpha characters unescaped"
+  fails "String#dump returns a string with non-printing ASCII characters replaced by \\x notation"
+  fails "String#dump returns a string with non-printing single-byte UTF-8 characters replaced by \\x notation"
+  fails "String#dump returns a string with multi-byte UTF-8 characters replaced by \\u{} notation with lower-case hex digits"
+  fails "String#dump includes .force_encoding(name) if the encoding isn't ASCII compatible"
 end