opal 0.4.4 → 0.5.0

data/spec/rubyspec/core/nil/nil_spec.rb

@@ -1,7 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-
-describe "NilClass#nil?" do
-  it "returns true" do
-    nil.nil?.should == true
-  end
-end

data/spec/rubyspec/core/nil/or_spec.rb

@@ -1,11 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-
-describe "NilClass#|" do
-  it "returns false if other is nil or false, otherwise true" do
-    (nil | nil).should == false
-    (nil | true).should == true
-    (nil | false).should == false
-    (nil | "").should == true
-    (nil | mock('x')).should == true
-  end
-end

data/spec/rubyspec/core/nil/to_a_spec.rb

@@ -1,7 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-
-describe "NilClass#to_a" do
-  it "returns an empty array" do
-    nil.to_a.should == []
-  end
-end

data/spec/rubyspec/core/nil/to_f_spec.rb

@@ -1,11 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-
-describe "NilClass#to_f" do
-  it "returns 0.0" do
-    nil.to_f.should == 0.0
-  end
-
-  it "does not cause NilClass to be coerced to Float" do
-    (0.0 == nil).should == false
-  end
-end

data/spec/rubyspec/core/nil/to_h_spec.rb

@@ -1,10 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-
-ruby_version_is "2.0" do
-  describe "NilClass#to_h" do
-    it "returns an empty hash" do
-      nil.to_h.should == {}
-      nil.to_h.default.should == nil
-    end
-  end
-end

data/spec/rubyspec/core/nil/to_i_spec.rb

@@ -1,11 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-
-describe "NilClass#to_i" do
-  it "returns 0" do
-    nil.to_i.should == 0
-  end
-
-  it "does not cause NilClass to be coerced to Fixnum" do
-    (0 == nil).should == false
-  end
-end

data/spec/rubyspec/core/nil/to_s_spec.rb

@@ -1,7 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-
-describe "NilClass#to_s" do
-  it "returns the string ''" do
-    nil.to_s.should == ""
-  end
-end

data/spec/rubyspec/core/nil/xor_spec.rb

@@ -1,11 +0,0 @@
-require File.expand_path('../../../spec_helper', __FILE__)
-
-describe "NilClass#^" do
-  it "returns false if other is nil or false, otherwise true" do
-    (nil ^ nil).should == false
-    (nil ^ true).should == true
-    (nil ^ false).should == false
-    (nil ^ "").should == true
-    (nil ^ mock('x')).should == true
-  end
-end

data/spec/rubyspec/core/numeric/to_s_spec.rb

@@ -1,8 +0,0 @@
-describe "Numeric#to_s when no base given" do
-  it "returns self converted to a String using base 10" do
-    255.to_s.should == '255'
-    3.to_s.should == '3'
-    0.to_s.should == '0'
-    (-9002).to_s.should == '-9002'
-  end
-end

data/spec/rubyspec/core/range/begin_spec.rb

@@ -1,9 +0,0 @@
-describe "Range#begin" do
-  it "returns the first element of self" do
-    (-1..1).begin.should == -1
-    (0..1).begin.should == 0
-    ('Q'..'T').begin.should == 'Q'
-    ('Q'...'T').begin.should == 'Q'
-    (0.5..2.4).begin.should == 0.5
-  end  
-end

data/spec/rubyspec/core/range/case_compare_spec.rb

@@ -1,15 +0,0 @@
-describe "Range#===" do
-  it "returns true if other is an element of self" do
-    ((0..5) === 2).should == true
-    ((-5..5) === 0).should == true
-    ((-1...1) === 10.5).should == false
-    ((-10..-2) === -2.5).should == true
-    (('C'..'X') === 'M').should == true
-    (('C'..'X') === 'A').should == false
-    (('B'...'W') === 'W').should == false
-    (('B'...'W') === 'Q').should == true
-    ((0.5..2.4) === 2).should == true
-    ((0.5..2.4) === 2.5).should == false
-    ((0.5...2.4) === 2.4).should == false
-  end
-end

data/spec/rubyspec/core/range/end_spec.rb

@@ -1,9 +0,0 @@
-describe "Range#end" do
-  it "end returns the last element of self" do
-    (-1..1).end.should == 1
-    (0..1).end.should == 1
-    ("A".."Q").end.should == "Q"
-    ("A"..."Q").end.should == "Q"
-    (0.5..2.4).end.should == 2.4
-  end
-end

data/spec/rubyspec/core/regexp/match_spec.rb

@@ -1,95 +0,0 @@
-describe "Regexp#=~ on a successful match" do
-  it "returns the index of the first character of the matching region" do
-    (/(.)(.)(.)/ =~ "abc").should == 0
-  end
-end
-
-describe "Regexp#match on a successful match" do
-  it "returns a MatchData object" do
-    /(.)(.)(.)/.match("abc").should be_kind_of(MatchData)
-  end
-
-  it "resets $~ if passed nil" do
-    # set $~
-    /./.match("a")
-    $~.should be_kind_of(MatchData)
-
-    /1/.match(nil)
-    $~.should be_nil
-  end
-
-  it "returns a MatchData object that exposes pre_match and post_match strings for inline regexp" do
-    re = /note: /i
-    result = re.match('preamble NOTE: This is just a test.')
-    result.pre_match.should == 'preamble '
-    result.post_match.should == 'This is just a test.'
-  end
-
-  it "returns a MatchData object that exposes pre_match and post_match strings for constructed regexp" do
-    re = Regexp.new(/note: /i)
-    result = re.match('preamble NOTE: This is just a test.')
-    result.pre_match.should == 'preamble '
-    result.post_match.should == 'This is just a test.'
-  end
-
-  it "sets $` and $' variables on match" do
-    re = /note: /i
-    re.match('preamble NOTE: This is just a test.')
-    $`.should == 'preamble '
-    $'.should == 'This is just a test.'
-  end
-
-  it "resets $` and $' when no match" do
-    re = /note: /i
-    re.match('preamble NOTE: This is just a test.')
-    $`.should_not be_nil
-    $'.should_not be_nil
-    re.match(nil)
-    $`.should be_nil
-    $'.should be_nil
-  end
-
-  it "returns a MatchData object that exposes match array" do
-    re = /(note): (.*)/i
-    result = re.match('preamble NOTE: This is just a test.')
-    result.length.should == 3
-    result.size.should == 3
-    result.captures.should == ['NOTE', 'This is just a test.']
-    result.to_a.should == ['NOTE: This is just a test.', 'NOTE', 'This is just a test.']
-    result[1].should == ['NOTE']
-    result.values_at(1, -1).should == ['NOTE', 'This is just a test.']
-    result.values_at(-3, 0).should == [nil, 'NOTE: This is just a test.']
-  end
-
-  it "replaces undefined with nil in match array" do
-    re = /(a(b)c)?(def)/
-    result = re.match("def")
-    result.to_a.size.should == 4
-    result.to_a.should == ["def", nil, nil, "def"]
-  end
-
-  it "returns a MatchData object that exposes regexp and string" do
-    re = /(note): (.*)/i
-    result = re.match('preamble NOTE: This is just a test.')
-    result.string.should == 'preamble NOTE: This is just a test.'
-    result.regexp.to_s.should == re.to_s
-  end
-
-  it "returns a MatchData object that provides access to offset of 0th element only" do
-    re = /(note): (.*)/i
-    result = re.match('preamble NOTE: This is just a test.')
-    result.begin(0).should == 9
-    result.begin(1).should == 9
-    lambda { result.begin(2) }.should raise_error(ArgumentError)
-  end
-end
-
-describe :regexp_match do
-  it "returns nil if there is no match" do
-    /xyz/.match("abxyc").should be_nil
-  end
-
-  it "returns nil if the object is nil" do
-    /xyz/.match(nil).should be_nil
-  end
-end

data/spec/rubyspec/core/string/capitalize_spec.rb

@@ -1,10 +0,0 @@
-describe "String#capitalize" do
-  it "returns a copy of self with the first character converted to uppercase and the remainder to lowercase" do
-    "".capitalize.should == ""
-    "h".capitalize.should == "H"
-    "H".capitalize.should == "H"
-    "hello".capitalize.should == "Hello"
-    "HELLO".capitalize.should == "Hello"
-    "123ABC".capitalize.should == "123abc"
-  end
-end

data/spec/rubyspec/core/string/casecmp_spec.rb

@@ -1,16 +0,0 @@
-describe "String#casecmp" do
-  it "returns -1 when less than other" do
-    "a".casecmp("b").should == -1
-    "A".casecmp("b").should == -1
-  end
-
-  it "returns 0 when equal to other" do
-    "a".casecmp("a").should == 0
-    "A".casecmp("a").should == 0
-  end
-
-  it "returns 1 when greater than other" do
-    "b".casecmp("a").should == 1
-    "B".casecmp("a").should == 1
-  end
-end

data/spec/rubyspec/core/string/center_spec.rb

@@ -1,49 +0,0 @@
-# -*- encoding: utf-8 -*-
-require File.expand_path('../../../spec_helper', __FILE__)
-require File.expand_path('../fixtures/classes.rb', __FILE__)
-
-describe "String#center with length, padding" do
-  it "returns a new string of specified length with self centered and padded with padstr" do
-    "one".center(9, '.').should       == "...one..."
-    "hello".center(20, '123').should  == "1231231hello12312312"
-    "middle".center(13, '-').should   == "---middle----"
-
-    "".center(1, "abcd").should == "a"
-    "".center(2, "abcd").should == "aa"
-    "".center(3, "abcd").should == "aab"
-    "".center(4, "abcd").should == "abab"
-    "".center(6, "xy").should == "xyxxyx"
-    "".center(11, "12345").should == "12345123451"
-
-    "|".center(2, "abcd").should == "|a"
-    "|".center(3, "abcd").should == "a|a"
-    "|".center(4, "abcd").should == "a|ab"
-    "|".center(5, "abcd").should == "ab|ab"
-    "|".center(6, "xy").should == "xy|xyx"
-    "|".center(7, "xy").should == "xyx|xyx"
-    "|".center(11, "12345").should == "12345|12345"
-    "|".center(12, "12345").should == "12345|123451"
-
-    "||".center(3, "abcd").should == "||a"
-    "||".center(4, "abcd").should == "a||a"
-    "||".center(5, "abcd").should == "a||ab"
-    "||".center(6, "abcd").should == "ab||ab"
-    "||".center(8, "xy").should == "xyx||xyx"
-    "||".center(12, "12345").should == "12345||12345"
-    "||".center(13, "12345").should == "12345||123451"
-  end
-
-  it "pads with whitespace if no padstr is given" do
-    "two".center(5).should    == " two "
-    "hello".center(20).should == "       hello        "
-  end
-
-  it "returns self if it's longer than or as long as the specified length" do
-    "".center(0).should == ""
-    "".center(-1).should == ""
-    "hello".center(4).should == "hello"
-    "hello".center(-1).should == "hello"
-    "this".center(3).should == "this"
-    "radiology".center(8, '-').should == "radiology"
-  end
-end

data/spec/rubyspec/core/string/chomp_spec.rb

@@ -1,48 +0,0 @@
-describe "String#chomp with separator" do
-  it "returns a new string with the given record separator removed" do
-    "hello".chomp("llo").should == "he"
-    "hellollo".chomp("llo").should == "hello"
-  end
-
-  it "removes carriage return (except \\r) chars multiple times when separator is an empty string" do
-    "".chomp("").should == ""
-    "hello".chomp("").should == "hello"
-    "hello\n".chomp("").should == "hello"
-    "hello\nx".chomp("").should == "hello\nx"
-    "hello\r\n".chomp("").should == "hello"
-    "hello\r\n\r\n\n\n\r\n".chomp("").should == "hello"
-
-    "hello\r".chomp("").should == "hello\r"
-    "hello\n\r".chomp("").should == "hello\n\r"
-    "hello\r\r\r\n".chomp("").should == "hello\r\r"
-  end
-
-  it "removes carriage return chars(\\n, \\r, \\r\\n) when separator is \\n" do
-    "hello".chomp("\n").should == "hello"
-    "hello\n".chomp("\n").should == "hello"
-    "hello\r\n".chomp("\n").should == "hello"
-    "hello\n\r".chomp("\n").should == "hello\n"
-    "hello\r".chomp("\n").should == "hello"
-    "hello \n there".chomp("\n").should == "hello \n there"
-    "hello\r\n\r\n\n\n\r\n".chomp("\n").should == "hello\r\n\r\n\n\n"
-
-    "hello\n\r".chomp("\r").should == "hello\n"
-    "hello\n\r\n".chomp("\r\n").should == "hello\n"
-  end
-
-  it "removes separator character" do
-    "hello)".chomp(")").should == "hello"
-    "hello*)".chomp("*)").should == "hello"
-  end
-
-  it "returns self if the separator is nil" do
-    "hello\n\n".chomp(nil).should == "hello\n\n"
-  end
-
-  it "returns an empty string when called on an empty string" do
-    "".chomp("\n").should == ""
-    "".chomp("\r").should == ""
-    "".chomp("").should == ""
-    "".chomp(nil).should == ""
-  end
-end

data/spec/rubyspec/core/string/downcase_spec.rb

@@ -1,6 +0,0 @@
-describe "String#downcase" do
-  it "returns a copy of self with all uppercase letters downcased" do
-    "hELLO".downcase.should == "hello"
-    "hello".downcase.should == "hello"
-  end
-end

data/spec/rubyspec/core/string/empty_spec.rb

@@ -1,7 +0,0 @@
-describe "String#empty?" do
-  it "returns true if the string has a length of zero" do
-    "hello".empty?.should == false
-    " ".empty?.should == false
-    "".empty?.should == true
-  end
-end

data/spec/rubyspec/core/string/end_with_spec.rb

@@ -1,16 +0,0 @@
-describe "String#end_with?" do
-  it "returns true only if ends with match" do
-    s = "hello"
-    s.end_with?('o').should be_true
-    s.end_with?('llo').should be_true
-    s.end_with?('ll').should be_false
-  end
-
-  it "returns true only if any ending match" do
-    "hello".end_with?('x', 'y', 'llo', 'z').should be_true
-  end
-
-  it "should not return true if suffix length is 1 greater than string length" do
-    "-".end_with?(' +').should be_false
-  end
-end

data/spec/rubyspec/core/string/include_spec.rb

@@ -1,6 +0,0 @@
-describe "String#include?" do
-  it "returns true if self contains other_str" do
-    "hello".include?("lo").should == true
-    "hello".include?("ol").should == false
-  end
-end

data/spec/rubyspec/core/string/index_spec.rb

@@ -1,405 +0,0 @@
-# -*- encoding: utf-8 -*-
-require File.expand_path('../../../spec_helper', __FILE__)
-require File.expand_path('../fixtures/classes.rb', __FILE__)
-
-describe "String#index" do
-  it "raises a TypeError if passed nil" do
-    lambda { "abc".index nil }.should raise_error(TypeError)
-  end
-
-  it "raises a TypeError if passed a boolean" do
-    lambda { "abc".index true }.should raise_error(TypeError)
-  end
-
-  not_compliant_on :opal do
-    it "raises a TypeError if passed a Symbol" do
-      lambda { "abc".index :a }.should raise_error(TypeError)
-    end
-
-    it "calls #to_str to convert the first argument" do
-      char = mock("string index char")
-      char.should_receive(:to_str).and_return("b")
-      "abc".index(char).should == 1
-    end
-
-    it "calls #to_int to convert the second argument" do
-      offset = mock("string index offset")
-      offset.should_receive(:to_int).and_return(1)
-      "abc".index("c", offset).should == 2
-    end
-  end
-
-  ruby_version_is ""..."1.9" do
-    it "does not call #to_int to convert the first argument" do
-      char = mock("string index char")
-      char.should_not_receive(:to_int)
-      lambda { "abc".index char }.should raise_error(TypeError)
-    end
-  end
-
-  ruby_version_is "1.9" do
-    it "raises a TypeError if passed a Fixnum" do
-      lambda { "abc".index 97 }.should raise_error(TypeError)
-    end
-  end
-end
-
-ruby_version_is ""..."1.9" do
-  describe "String#index with Fixnum" do
-    it "returns the index of the first occurrence of the given character" do
-      "hello".index(?e).should == 1
-      "hello".index(?l).should == 2
-    end
-
-    it "character values over 255 (256th ASCII character) always result in nil" do
-      # A naive implementation could try to use % 256
-      "hello".index(?e + 256 * 3).should == nil
-    end
-
-    it "negative character values always result in nil" do
-      # A naive implementation could try to use % 256
-      "hello".index(-(256 - ?e)).should == nil
-    end
-
-    it "starts the search at the given offset" do
-      "blablabla".index(?b, 0).should == 0
-      "blablabla".index(?b, 1).should == 3
-      "blablabla".index(?b, 2).should == 3
-      "blablabla".index(?b, 3).should == 3
-      "blablabla".index(?b, 4).should == 6
-      "blablabla".index(?b, 5).should == 6
-      "blablabla".index(?b, 6).should == 6
-
-      "blablabla".index(?a, 0).should == 2
-      "blablabla".index(?a, 2).should == 2
-      "blablabla".index(?a, 3).should == 5
-      "blablabla".index(?a, 4).should == 5
-      "blablabla".index(?a, 5).should == 5
-      "blablabla".index(?a, 6).should == 8
-      "blablabla".index(?a, 7).should == 8
-      "blablabla".index(?a, 8).should == 8
-    end
-
-    it "starts the search at offset + self.length if offset is negative" do
-      str = "blablabla"
-
-      [?a, ?b].each do |needle|
-        (-str.length .. -1).each do |offset|
-          p offset
-          str.index(needle, offset).should ==
-          str.index(needle, offset + str.length)
-        end
-      end
-
-      "blablabla".index(?b, -9).should == 0
-    end
-
-    it "returns nil if offset + self.length is < 0 for negative offsets" do
-      "blablabla".index(?b, -10).should == nil
-      "blablabla".index(?b, -20).should == nil
-    end
-
-    it "returns nil if the character isn't found" do
-      "hello".index(0).should == nil
-
-      "hello".index(?H).should == nil
-      "hello".index(?z).should == nil
-      "hello".index(?e, 2).should == nil
-
-      "blablabla".index(?b, 7).should == nil
-      "blablabla".index(?b, 10).should == nil
-
-      "blablabla".index(?a, 9).should == nil
-      "blablabla".index(?a, 20).should == nil
-    end
-  end
-end
-
-describe "String#index with String" do
-  it "behaves the same as String#index(char) for one-character strings" do
-    ["blablabla", "hello cruel world...!"].each do |str|
-      str.split("").uniq.each do |str|
-        chr = str[0]
-        str.index(str).should == str.index(chr)
-
-        0.upto(str.size + 1) do |start|
-          str.index(str, start).should == str.index(chr, start)
-        end
-
-        (-str.size - 1).upto(-1) do |start|
-          str.index(str, start).should == str.index(chr, start)
-        end
-      end
-    end
-  end
-
-  it "returns the index of the first occurrence of the given substring" do
-    "blablabla".index("").should == 0
-    "blablabla".index("b").should == 0
-    "blablabla".index("bla").should == 0
-    "blablabla".index("blabla").should == 0
-    "blablabla".index("blablabla").should == 0
-
-    "blablabla".index("l").should == 1
-    "blablabla".index("la").should == 1
-    "blablabla".index("labla").should == 1
-    "blablabla".index("lablabla").should == 1
-
-    "blablabla".index("a").should == 2
-    "blablabla".index("abla").should == 2
-    "blablabla".index("ablabla").should == 2
-  end
-
-  it "doesn't set $~" do
-    $~ = nil
-
-    'hello.'.index('ll')
-    $~.should == nil
-  end
-
-  it "ignores string subclasses" do
-    "blablabla".index(StringSpecs::MyString.new("bla")).should == 0
-    StringSpecs::MyString.new("blablabla").index("bla").should == 0
-    StringSpecs::MyString.new("blablabla").index(StringSpecs::MyString.new("bla")).should == 0
-  end
-
-  it "starts the search at the given offset" do
-    "blablabla".index("bl", 0).should == 0
-    "blablabla".index("bl", 1).should == 3
-    "blablabla".index("bl", 2).should == 3
-    "blablabla".index("bl", 3).should == 3
-
-    "blablabla".index("bla", 0).should == 0
-    "blablabla".index("bla", 1).should == 3
-    "blablabla".index("bla", 2).should == 3
-    "blablabla".index("bla", 3).should == 3
-
-    "blablabla".index("blab", 0).should == 0
-    "blablabla".index("blab", 1).should == 3
-    "blablabla".index("blab", 2).should == 3
-    "blablabla".index("blab", 3).should == 3
-
-    "blablabla".index("la", 1).should == 1
-    "blablabla".index("la", 2).should == 4
-    "blablabla".index("la", 3).should == 4
-    "blablabla".index("la", 4).should == 4
-
-    "blablabla".index("lab", 1).should == 1
-    "blablabla".index("lab", 2).should == 4
-    "blablabla".index("lab", 3).should == 4
-    "blablabla".index("lab", 4).should == 4
-
-    "blablabla".index("ab", 2).should == 2
-    "blablabla".index("ab", 3).should == 5
-    "blablabla".index("ab", 4).should == 5
-    "blablabla".index("ab", 5).should == 5
-
-    "blablabla".index("", 0).should == 0
-    "blablabla".index("", 1).should == 1
-    "blablabla".index("", 2).should == 2
-    "blablabla".index("", 7).should == 7
-    "blablabla".index("", 8).should == 8
-    "blablabla".index("", 9).should == 9
-  end
-
-  it "starts the search at offset + self.length if offset is negative" do
-    str = "blablabla"
-
-    ["bl", "bla", "blab", "la", "lab", "ab", ""].each do |needle|
-      (-str.length .. -1).each do |offset|
-        str.index(needle, offset).should ==
-        str.index(needle, offset + str.length)
-      end
-    end
-  end
-
-  it "returns nil if the substring isn't found" do
-    "blablabla".index("B").should == nil
-    "blablabla".index("z").should == nil
-    "blablabla".index("BLA").should == nil
-    "blablabla".index("blablablabla").should == nil
-    "blablabla".index("", 10).should == nil
-    "blablabla".index("", 10).should == nil
-
-    "12345".index("", 6).should == nil
-    "hello".index("he", 1).should == nil
-    "hello".index("he", 2).should == nil
-  end
-
-  with_feature :encoding do
-    it "returns the character index of a multibyte character" do
-      "ありがとう".index("が").should == 2
-    end
-
-    it "returns the character index after offset" do
-      "われわれ".index("わ", 1).should == 2
-    end
-
-    it "raises an Encoding::CompatibilityError if the encodings are incompatible" do
-      char = "れ".encode Encoding::EUC_JP
-      lambda do
-        "あれ".index char
-      end.should raise_error(Encoding::CompatibilityError)
-    end
-  end
-end
-
-describe "String#index with Regexp" do
-  it "behaves the same as String#index(string) for escaped string regexps" do
-    ["blablabla", "hello cruel world...!"].each do |str|
-      ["", "b", "bla", "lab", "o c", "d."].each do |needle|
-        regexp = Regexp.new(Regexp.escape(needle))
-        str.index(regexp).should == str.index(needle)
-
-        0.upto(str.size + 1) do |start|
-          str.index(regexp, start).should == str.index(needle, start)
-        end
-
-        (-str.size - 1).upto(-1) do |start|
-          str.index(regexp, start).should == str.index(needle, start)
-        end
-      end
-    end
-  end
-
-  it "returns the index of the first match of regexp" do
-    "blablabla".index(/bla/).should == 0
-    "blablabla".index(/BLA/i).should == 0
-
-    "blablabla".index(/.{0}/).should == 0
-    "blablabla".index(/.{6}/).should == 0
-    "blablabla".index(/.{9}/).should == 0
-
-    "blablabla".index(/.*/).should == 0
-    "blablabla".index(/.+/).should == 0
-
-    "blablabla".index(/lab|b/).should == 0
-
-    not_compliant_on :opal do
-      "blablabla".index(/\A/).should == 0
-      "blablabla".index(/\Z/).should == 9
-      "blablabla".index(/\z/).should == 9
-      "blablabla\n".index(/\Z/).should == 9
-      "blablabla\n".index(/\z/).should == 10
-    end
-
-    "blablabla".index(/^/).should == 0
-    "\nblablabla".index(/^/).should == 0
-
-    not_compliant_on :opal do
-      "b\nablabla".index(/$/).should == 1
-      "bl\nablabla".index(/$/).should == 2
-    end
-
-    "blablabla".index(/.l./).should == 0
-  end
-
-  it "sets $~ to MatchData of match and nil when there's none" do
-    'hello.'.index(/.(.)/)
-    $~[0].should == 'he'
-
-    'hello.'.index(/not/)
-    $~.should == nil
-  end
-
-  it "starts the search at the given offset" do
-    "blablabla".index(/.{0}/, 5).should == 5
-    "blablabla".index(/.{1}/, 5).should == 5
-    "blablabla".index(/.{2}/, 5).should == 5
-    "blablabla".index(/.{3}/, 5).should == 5
-    "blablabla".index(/.{4}/, 5).should == 5
-
-    "blablabla".index(/.{0}/, 3).should == 3
-    "blablabla".index(/.{1}/, 3).should == 3
-    "blablabla".index(/.{2}/, 3).should == 3
-    "blablabla".index(/.{5}/, 3).should == 3
-    "blablabla".index(/.{6}/, 3).should == 3
-
-    "blablabla".index(/.l./, 0).should == 0
-    "blablabla".index(/.l./, 1).should == 3
-    "blablabla".index(/.l./, 2).should == 3
-    "blablabla".index(/.l./, 3).should == 3
-
-    "xblaxbla".index(/x./, 0).should == 0
-    "xblaxbla".index(/x./, 1).should == 4
-    "xblaxbla".index(/x./, 2).should == 4
-
-    not_compliant_on :opal do
-      "blablabla\n".index(/\Z/, 9).should == 9
-    end
-  end
-
-  it "starts the search at offset + self.length if offset is negative" do
-    str = "blablabla"
-
-    ["bl", "bla", "blab", "la", "lab", "ab", ""].each do |needle|
-      (-str.length .. -1).each do |offset|
-        str.index(needle, offset).should ==
-        str.index(needle, offset + str.length)
-      end
-    end
-  end
-
-  it "returns nil if the substring isn't found" do
-    "blablabla".index(/BLA/).should == nil
-
-    "blablabla".index(/.{10}/).should == nil
-    "blaxbla".index(/.x/, 3).should == nil
-    "blaxbla".index(/..x/, 2).should == nil
-  end
-
-  it "returns nil if the Regexp matches the empty string and the offset is out of range" do
-    "ruby".index(//,12).should be_nil
-  end
-
-  not_compliant_on :opal do
-    it "supports \\G which matches at the given start offset" do
-      "helloYOU.".index(/\GYOU/, 5).should == 5
-      "helloYOU.".index(/\GYOU/).should == nil
-
-      re = /\G.+YOU/
-      # The # marks where \G will match.
-      [
-        ["#hi!YOUall.", 0],
-        ["h#i!YOUall.", 1],
-        ["hi#!YOUall.", 2],
-        ["hi!#YOUall.", nil]
-      ].each do |spec|
-
-        start = spec[0].index("#")
-        str = spec[0].delete("#")
-
-        str.index(re, start).should == spec[1]
-      end
-    end
-  end
-
-  not_compliant_on :opal do
-    it "converts start_offset to an integer via to_int" do
-      obj = mock('1')
-      obj.should_receive(:to_int).and_return(1)
-      "RWOARW".index(/R./, obj).should == 4
-    end
-  end
-
-  with_feature :encoding do
-    it "returns the character index of a multibyte character" do
-      "ありがとう".index(/が/).should == 2
-    end
-
-    it "returns the character index after offset" do
-      "われわれ".index(/わ/, 1).should == 2
-    end
-
-    it "treats the offset as a character index" do
-      "われわわれ".index(/わ/, 3).should == 3
-    end
-
-    it "raises an Encoding::CompatibilityError if the encodings are incompatible" do
-      re = Regexp.new "れ".encode(Encoding::EUC_JP)
-      lambda do
-        "あれ".index re
-      end.should raise_error(Encoding::CompatibilityError)
-    end
-  end
-end