Revision: 3829 http://trac.macosforge.org/projects/ruby/changeset/3829 Author: lsansonetti@apple.com Date: 2010-03-19 15:26:45 -0700 (Fri, 19 Mar 2010) Log Message: ----------- the slice specs can now be run (except the 1.9 extensions) Modified Paths: -------------- MacRuby/trunk/spec/frozen/core/string/shared/slice.rb MacRuby/trunk/spec/frozen/tags/macruby/core/string/slice_tags.txt Added Paths: ----------- MacRuby/trunk/spec/frozen/core/string/slice_spec.rb Removed Paths: ------------- MacRuby/trunk/spec/frozen/core/string/slice_spec_disabled.rb Modified: MacRuby/trunk/spec/frozen/core/string/shared/slice.rb =================================================================== --- MacRuby/trunk/spec/frozen/core/string/shared/slice.rb 2010-03-19 22:26:15 UTC (rev 3828) +++ MacRuby/trunk/spec/frozen/core/string/shared/slice.rb 2010-03-19 22:26:45 UTC (rev 3829) @@ -407,4 +407,5 @@ end end -language_version __FILE__, "slice" +# XXX MacRuby cannot parse this because of named captures +#language_version __FILE__, "slice" Copied: MacRuby/trunk/spec/frozen/core/string/slice_spec.rb (from rev 3806, MacRuby/trunk/spec/frozen/core/string/slice_spec_disabled.rb) =================================================================== --- MacRuby/trunk/spec/frozen/core/string/slice_spec.rb (rev 0) +++ MacRuby/trunk/spec/frozen/core/string/slice_spec.rb 2010-03-19 22:26:45 UTC (rev 3829) @@ -0,0 +1,479 @@ +require File.dirname(__FILE__) + '/../../spec_helper' +require File.dirname(__FILE__) + '/fixtures/classes.rb' +require File.dirname(__FILE__) + '/shared/slice.rb' + +describe "String#slice" do + it_behaves_like :string_slice, :slice +end + +describe "String#slice with index, length" do + it_behaves_like :string_slice_index_length, :slice +end + +describe "String#slice with Range" do + it_behaves_like :string_slice_range, :slice +end + +describe "String#slice with Regexp" do + it_behaves_like :string_slice_regexp, :slice +end + +describe "String#slice with Regexp, index" do + it_behaves_like :string_slice_regexp_index, :slice +end + +=begin +# XXX MacRuby cannot parse this because of named captures. +ruby_version_is "1.9" do + describe "String#slice with Regexp, group" do + it_behaves_like :string_slice_regexp_group, :slice + end +end +=end + +describe "String#slice with String" do + it_behaves_like :string_slice_string, :slice +end + +describe "String#slice! with index" do + it "deletes and return the char at the given position" do + a = "hello" + a.slice!(1).should == ?e + a.should == "hllo" + a.slice!(-1).should == ?o + a.should == "hll" + end + + it "returns nil if idx is outside of self" do + a = "hello" + a.slice!(20).should == nil + a.should == "hello" + a.slice!(-20).should == nil + a.should == "hello" + end + + ruby_version_is ""..."1.9" do + it "raises a TypeError if self is frozen" do + lambda { "hello".freeze.slice!(1) }.should raise_error(TypeError) + end + end + + ruby_version_is "1.9" do + it "raises a RuntimeError if self is frozen" do + lambda { "hello".freeze.slice!(1) }.should raise_error(RuntimeError) + lambda { "hello".freeze.slice!(10) }.should raise_error(RuntimeError) + lambda { "".freeze.slice!(0) }.should raise_error(RuntimeError) + end + end + + ruby_version_is ""..."1.9" do + it "doesn't raise a TypeError if self is frozen and idx is outside of self" do + "hello".freeze.slice!(10).should be_nil + "".freeze.slice!(0).should be_nil + end + end + + it "calls to_int on index" do + "hello".slice!(0.5).should == ?h + + obj = mock('1') + # MRI calls this twice so we can't use should_receive here. + def obj.to_int() 1 end + "hello".slice!(obj).should == ?e + + obj = mock('1') + def obj.respond_to?(name) name == :to_int ? true : super; end + def obj.method_missing(name, *) name == :to_int ? 1 : super; end + "hello".slice!(obj).should == ?e + end +end + +describe "String#slice! with index, length" do + it "deletes and returns the substring at idx and the given length" do + a = "hello" + a.slice!(1, 2).should == "el" + a.should == "hlo" + + a.slice!(1, 0).should == "" + a.should == "hlo" + + a.slice!(-2, 4).should == "lo" + a.should == "h" + end + + it "always taints resulting strings when self is tainted" do + str = "hello world" + str.taint + + str.slice!(0, 0).tainted?.should == true + str.slice!(2, 1).tainted?.should == true + end + + it "returns nil if the given position is out of self" do + a = "hello" + a.slice(10, 3).should == nil + a.should == "hello" + + a.slice(-10, 20).should == nil + a.should == "hello" + end + + it "returns nil if the length is negative" do + a = "hello" + a.slice(4, -3).should == nil + a.should == "hello" + end + + ruby_version_is "1.9" do + it "raises a RuntimeError if self is frozen" do + lambda { "hello".freeze.slice!(1, 2) }.should raise_error(RuntimeError) + lambda { "hello".freeze.slice!(10, 3) }.should raise_error(RuntimeError) + lambda { "hello".freeze.slice!(-10, 3)}.should raise_error(RuntimeError) + lambda { "hello".freeze.slice!(4, -3) }.should raise_error(RuntimeError) + lambda { "hello".freeze.slice!(10, 3) }.should raise_error(RuntimeError) + lambda { "hello".freeze.slice!(-10, 3)}.should raise_error(RuntimeError) + lambda { "hello".freeze.slice!(4, -3) }.should raise_error(RuntimeError) + end + end + + it "calls to_int on idx and length" do + "hello".slice!(0.5, 2.5).should == "he" + + obj = mock('2') + def obj.to_int() 2 end + "hello".slice!(obj, obj).should == "ll" + + obj = mock('2') + def obj.respond_to?(name) name == :to_int; end + def obj.method_missing(name, *) name == :to_int ? 2 : super; end + "hello".slice!(obj, obj).should == "ll" + end + + it "returns subclass instances" do + s = StringSpecs::MyString.new("hello") + s.slice!(0, 0).should be_kind_of(StringSpecs::MyString) + s.slice!(0, 4).should be_kind_of(StringSpecs::MyString) + end +end + +describe "String#slice! Range" do + it "deletes and return the substring given by the offsets of the range" do + a = "hello" + a.slice!(1..3).should == "ell" + a.should == "ho" + a.slice!(0..0).should == "h" + a.should == "o" + a.slice!(0...0).should == "" + a.should == "o" + + # Edge Case? + "hello".slice!(-3..-9).should == "" + end + + it "returns nil if the given range is out of self" do + a = "hello" + a.slice!(-6..-9).should == nil + a.should == "hello" + + b = "hello" + b.slice!(10..20).should == nil + b.should == "hello" + end + + it "always taints resulting strings when self is tainted" do + str = "hello world" + str.taint + + str.slice!(0..0).tainted?.should == true + str.slice!(2..3).tainted?.should == true + end + + it "returns subclass instances" do + s = StringSpecs::MyString.new("hello") + s.slice!(0...0).should be_kind_of(StringSpecs::MyString) + s.slice!(0..4).should be_kind_of(StringSpecs::MyString) + end + + it "calls to_int on range arguments" do + from = mock('from') + to = mock('to') + + # So we can construct a range out of them... + def from.<=>(o) 0 end + def to.<=>(o) 0 end + + def from.to_int() 1 end + def to.to_int() -2 end + + "hello there".slice!(from..to).should == "ello ther" + + from = mock('from') + to = mock('to') + + def from.<=>(o) 0 end + def to.<=>(o) 0 end + + def from.respond_to?(name) name == :to_int; end + def from.method_missing(name) name == :to_int ? 1 : super; end + def to.respond_to?(name) name == :to_int; end + def to.method_missing(name) name == :to_int ? -2 : super; end + + "hello there".slice!(from..to).should == "ello ther" + end + + it "works with Range subclasses" do + a = "GOOD" + range_incl = StringSpecs::MyRange.new(1, 2) + + a.slice!(range_incl).should == "OO" + end + + ruby_version_is ""..."1.9" do + it "raises a TypeError if self is frozen" do + lambda { "hello".freeze.slice!(1..3) }.should raise_error(TypeError) + end + + ruby_bug "#1551", "1.9.2" do + it "doesn't raise a TypeError if self is frozen but the given range is out of self" do + "hello".freeze.slice!(10..20).should == nil + end + end + end + + ruby_version_is "1.9" do + it "raises a RuntimeError if self is frozen" do + lambda { "hello".freeze.slice!(1..3) }.should raise_error(RuntimeError) + lambda { "hello".freeze.slice!(10..20)}.should raise_error(RuntimeError) + end + end +end + +describe "String#slice! with Regexp" do + it "deletes and returns the first match from self" do + s = "this is a string" + s.slice!(/s.*t/).should == 's is a st' + s.should == 'thiring' + + c = "hello hello" + c.slice!(/llo/).should == "llo" + c.should == "he hello" + end + + it "returns nil if there was no match" do + s = "this is a string" + s.slice!(/zzz/).should == nil + s.should == "this is a string" + end + + it "always taints resulting strings when self or regexp is tainted" do + strs = ["hello world"] + strs += strs.map { |s| s.dup.taint } + + strs.each do |str| + str = str.dup + str.slice!(//).tainted?.should == str.tainted? + str.slice!(/hello/).tainted?.should == str.tainted? + + tainted_re = /./ + tainted_re.taint + + str.slice!(tainted_re).tainted?.should == true + end + end + + it "doesn't taint self when regexp is tainted" do + s = "hello" + s.slice!(/./.taint) + s.tainted?.should == false + end + + it "returns subclass instances" do + s = StringSpecs::MyString.new("hello") + s.slice!(//).should be_kind_of(StringSpecs::MyString) + s.slice!(/../).should be_kind_of(StringSpecs::MyString) + end + + # This currently fails, but passes in a pure Rubinius environment (without mspec) + # probably because mspec uses match internally for its operation + it "sets $~ to MatchData when there is a match and nil when there's none" do + 'hello'.slice!(/./) + $~[0].should == 'h' + + 'hello'.slice!(/not/) + $~.should == nil + end + + ruby_version_is ""..."1.9" do + it "raises a TypeError if self is frozen" do + lambda { "this is a string".freeze.slice!(/s.*t/) }.should raise_error(TypeError) + end + end + + ruby_version_is "1.9" do + it "raises a RuntimeError if self is frozen" do + lambda { "this is a string".freeze.slice!(/s.*t/) }.should raise_error(RuntimeError) + lambda { "this is a string".freeze.slice!(/zzz/) }.should raise_error(RuntimeError) + lambda { "this is a string".freeze.slice!(/zzz/) }.should raise_error(RuntimeError) + end + end +end + +describe "String#slice! with Regexp, index" do + it "deletes and returns the capture for idx from self" do + str = "hello there" + str.slice!(/[aeiou](.)\1/, 0).should == "ell" + str.should == "ho there" + str.slice!(/(t)h/, 1).should == "t" + str.should == "ho here" + end + + it "always taints resulting strings when self or regexp is tainted" do + strs = ["hello world"] + strs += strs.map { |s| s.dup.taint } + + strs.each do |str| + str = str.dup + str.slice!(//, 0).tainted?.should == str.tainted? + str.slice!(/hello/, 0).tainted?.should == str.tainted? + + tainted_re = /(.)(.)(.)/ + tainted_re.taint + + str.slice!(tainted_re, 1).tainted?.should == true + end + end + + it "doesn't taint self when regexp is tainted" do + s = "hello" + s.slice!(/(.)(.)/.taint, 1) + s.tainted?.should == false + end + + it "returns nil if there was no match" do + s = "this is a string" + s.slice!(/x(zzz)/, 1).should == nil + s.should == "this is a string" + end + + it "returns nil if there is no capture for idx" do + "hello there".slice!(/[aeiou](.)\1/, 2).should == nil + # You can't refer to 0 using negative indices + "hello there".slice!(/[aeiou](.)\1/, -2).should == nil + end + + it "calls to_int on idx" do + obj = mock('2') + def obj.to_int() 2 end + + "har".slice!(/(.)(.)(.)/, 1.5).should == "h" + "har".slice!(/(.)(.)(.)/, obj).should == "a" + + obj = mock('2') + def obj.respond_to?(name) name == :to_int; end + def obj.method_missing(name) name == :to_int ? 2: super; end + "har".slice!(/(.)(.)(.)/, obj).should == "a" + end + + it "returns subclass instances" do + s = StringSpecs::MyString.new("hello") + s.slice!(/(.)(.)/, 0).should be_kind_of(StringSpecs::MyString) + s.slice!(/(.)(.)/, 1).should be_kind_of(StringSpecs::MyString) + end + + it "sets $~ to MatchData when there is a match and nil when there's none" do + 'hello'[/.(.)/, 0] + $~[0].should == 'he' + + 'hello'[/.(.)/, 1] + $~[1].should == 'e' + + 'hello'[/not/, 0] + $~.should == nil + end + + ruby_version_is ""..."1.9" do + it "raises a TypeError if self is frozen" do + lambda { "this is a string".freeze.slice!(/s.*t/) }.should raise_error(TypeError) + end + + it "doesn't raise a TypeError if self is frozen but there is no match" do + "this is a string".freeze.slice!(/zzz/, 0).should == nil + end + + it "doesn't raise a TypeError if self is frozen but there is no capture for idx" do + "this is a string".freeze.slice!(/(.)/, 2).should == nil + end + end + + ruby_version_is "1.9" do + it "raises a RuntimeError if self is frozen" do + lambda { "this is a string".freeze.slice!(/s.*t/) }.should raise_error(RuntimeError) + lambda { "this is a string".freeze.slice!(/zzz/, 0)}.should raise_error(RuntimeError) + lambda { "this is a string".freeze.slice!(/(.)/, 2)}.should raise_error(RuntimeError) + end + end +end + +describe "String#slice! with String" do + it "removes and returns the first occurrence of other_str from self" do + c = "hello hello" + c.slice!('llo').should == "llo" + c.should == "he hello" + end + + it "taints resulting strings when other is tainted" do + strs = ["", "hello world", "hello"] + strs += strs.map { |s| s.dup.taint } + + strs.each do |str| + str = str.dup + strs.each do |other| + other = other.dup + r = str.slice!(other) + + r.tainted?.should == !r.nil? & other.tainted? + end + end + end + + it "doesn't set $~" do + $~ = nil + + 'hello'.slice!('ll') + $~.should == nil + end + + it "returns nil if self does not contain other" do + a = "hello" + a.slice!('zzz').should == nil + a.should == "hello" + end + + it "doesn't call to_str on its argument" do + o = mock('x') + o.should_not_receive(:to_str) + + lambda { "hello".slice!(o) }.should raise_error(TypeError) + end + + it "returns a subclass instance when given a subclass instance" do + s = StringSpecs::MyString.new("el") + r = "hello".slice!(s) + r.should == "el" + r.should be_kind_of(StringSpecs::MyString) + end + + ruby_version_is ""..."1.9" do + it "raises a TypeError if self is frozen" do + lambda { "hello hello".freeze.slice!('llo') }.should raise_error(TypeError) + end + end + + ruby_version_is "1.9" do + it "raises a RuntimeError if self is frozen" do + lambda { "hello hello".freeze.slice!('llo') }.should raise_error(RuntimeError) + lambda { "this is a string".freeze.slice!('zzz')}.should raise_error(RuntimeError) + lambda { "this is a string".freeze.slice!('zzz')}.should raise_error(RuntimeError) + end + end +end Deleted: MacRuby/trunk/spec/frozen/core/string/slice_spec_disabled.rb =================================================================== --- MacRuby/trunk/spec/frozen/core/string/slice_spec_disabled.rb 2010-03-19 22:26:15 UTC (rev 3828) +++ MacRuby/trunk/spec/frozen/core/string/slice_spec_disabled.rb 2010-03-19 22:26:45 UTC (rev 3829) @@ -1,476 +0,0 @@ -require File.dirname(__FILE__) + '/../../spec_helper' -require File.dirname(__FILE__) + '/fixtures/classes.rb' -require File.dirname(__FILE__) + '/shared/slice.rb' - -describe "String#slice" do - it_behaves_like :string_slice, :slice -end - -describe "String#slice with index, length" do - it_behaves_like :string_slice_index_length, :slice -end - -describe "String#slice with Range" do - it_behaves_like :string_slice_range, :slice -end - -describe "String#slice with Regexp" do - it_behaves_like :string_slice_regexp, :slice -end - -describe "String#slice with Regexp, index" do - it_behaves_like :string_slice_regexp_index, :slice -end - -ruby_version_is "1.9" do - describe "String#slice with Regexp, group" do - it_behaves_like :string_slice_regexp_group, :slice - end -end - -describe "String#slice with String" do - it_behaves_like :string_slice_string, :slice -end - -describe "String#slice! with index" do - it "deletes and return the char at the given position" do - a = "hello" - a.slice!(1).should == ?e - a.should == "hllo" - a.slice!(-1).should == ?o - a.should == "hll" - end - - it "returns nil if idx is outside of self" do - a = "hello" - a.slice!(20).should == nil - a.should == "hello" - a.slice!(-20).should == nil - a.should == "hello" - end - - ruby_version_is ""..."1.9" do - it "raises a TypeError if self is frozen" do - lambda { "hello".freeze.slice!(1) }.should raise_error(TypeError) - end - end - - ruby_version_is "1.9" do - it "raises a RuntimeError if self is frozen" do - lambda { "hello".freeze.slice!(1) }.should raise_error(RuntimeError) - lambda { "hello".freeze.slice!(10) }.should raise_error(RuntimeError) - lambda { "".freeze.slice!(0) }.should raise_error(RuntimeError) - end - end - - ruby_version_is ""..."1.9" do - it "doesn't raise a TypeError if self is frozen and idx is outside of self" do - "hello".freeze.slice!(10).should be_nil - "".freeze.slice!(0).should be_nil - end - end - - it "calls to_int on index" do - "hello".slice!(0.5).should == ?h - - obj = mock('1') - # MRI calls this twice so we can't use should_receive here. - def obj.to_int() 1 end - "hello".slice!(obj).should == ?e - - obj = mock('1') - def obj.respond_to?(name) name == :to_int ? true : super; end - def obj.method_missing(name, *) name == :to_int ? 1 : super; end - "hello".slice!(obj).should == ?e - end -end - -describe "String#slice! with index, length" do - it "deletes and returns the substring at idx and the given length" do - a = "hello" - a.slice!(1, 2).should == "el" - a.should == "hlo" - - a.slice!(1, 0).should == "" - a.should == "hlo" - - a.slice!(-2, 4).should == "lo" - a.should == "h" - end - - it "always taints resulting strings when self is tainted" do - str = "hello world" - str.taint - - str.slice!(0, 0).tainted?.should == true - str.slice!(2, 1).tainted?.should == true - end - - it "returns nil if the given position is out of self" do - a = "hello" - a.slice(10, 3).should == nil - a.should == "hello" - - a.slice(-10, 20).should == nil - a.should == "hello" - end - - it "returns nil if the length is negative" do - a = "hello" - a.slice(4, -3).should == nil - a.should == "hello" - end - - ruby_version_is "1.9" do - it "raises a RuntimeError if self is frozen" do - lambda { "hello".freeze.slice!(1, 2) }.should raise_error(RuntimeError) - lambda { "hello".freeze.slice!(10, 3) }.should raise_error(RuntimeError) - lambda { "hello".freeze.slice!(-10, 3)}.should raise_error(RuntimeError) - lambda { "hello".freeze.slice!(4, -3) }.should raise_error(RuntimeError) - lambda { "hello".freeze.slice!(10, 3) }.should raise_error(RuntimeError) - lambda { "hello".freeze.slice!(-10, 3)}.should raise_error(RuntimeError) - lambda { "hello".freeze.slice!(4, -3) }.should raise_error(RuntimeError) - end - end - - it "calls to_int on idx and length" do - "hello".slice!(0.5, 2.5).should == "he" - - obj = mock('2') - def obj.to_int() 2 end - "hello".slice!(obj, obj).should == "ll" - - obj = mock('2') - def obj.respond_to?(name) name == :to_int; end - def obj.method_missing(name, *) name == :to_int ? 2 : super; end - "hello".slice!(obj, obj).should == "ll" - end - - it "returns subclass instances" do - s = StringSpecs::MyString.new("hello") - s.slice!(0, 0).should be_kind_of(StringSpecs::MyString) - s.slice!(0, 4).should be_kind_of(StringSpecs::MyString) - end -end - -describe "String#slice! Range" do - it "deletes and return the substring given by the offsets of the range" do - a = "hello" - a.slice!(1..3).should == "ell" - a.should == "ho" - a.slice!(0..0).should == "h" - a.should == "o" - a.slice!(0...0).should == "" - a.should == "o" - - # Edge Case? - "hello".slice!(-3..-9).should == "" - end - - it "returns nil if the given range is out of self" do - a = "hello" - a.slice!(-6..-9).should == nil - a.should == "hello" - - b = "hello" - b.slice!(10..20).should == nil - b.should == "hello" - end - - it "always taints resulting strings when self is tainted" do - str = "hello world" - str.taint - - str.slice!(0..0).tainted?.should == true - str.slice!(2..3).tainted?.should == true - end - - it "returns subclass instances" do - s = StringSpecs::MyString.new("hello") - s.slice!(0...0).should be_kind_of(StringSpecs::MyString) - s.slice!(0..4).should be_kind_of(StringSpecs::MyString) - end - - it "calls to_int on range arguments" do - from = mock('from') - to = mock('to') - - # So we can construct a range out of them... - def from.<=>(o) 0 end - def to.<=>(o) 0 end - - def from.to_int() 1 end - def to.to_int() -2 end - - "hello there".slice!(from..to).should == "ello ther" - - from = mock('from') - to = mock('to') - - def from.<=>(o) 0 end - def to.<=>(o) 0 end - - def from.respond_to?(name) name == :to_int; end - def from.method_missing(name) name == :to_int ? 1 : super; end - def to.respond_to?(name) name == :to_int; end - def to.method_missing(name) name == :to_int ? -2 : super; end - - "hello there".slice!(from..to).should == "ello ther" - end - - it "works with Range subclasses" do - a = "GOOD" - range_incl = StringSpecs::MyRange.new(1, 2) - - a.slice!(range_incl).should == "OO" - end - - ruby_version_is ""..."1.9" do - it "raises a TypeError if self is frozen" do - lambda { "hello".freeze.slice!(1..3) }.should raise_error(TypeError) - end - - ruby_bug "#1551", "1.9.2" do - it "doesn't raise a TypeError if self is frozen but the given range is out of self" do - "hello".freeze.slice!(10..20).should == nil - end - end - end - - ruby_version_is "1.9" do - it "raises a RuntimeError if self is frozen" do - lambda { "hello".freeze.slice!(1..3) }.should raise_error(RuntimeError) - lambda { "hello".freeze.slice!(10..20)}.should raise_error(RuntimeError) - end - end -end - -describe "String#slice! with Regexp" do - it "deletes and returns the first match from self" do - s = "this is a string" - s.slice!(/s.*t/).should == 's is a st' - s.should == 'thiring' - - c = "hello hello" - c.slice!(/llo/).should == "llo" - c.should == "he hello" - end - - it "returns nil if there was no match" do - s = "this is a string" - s.slice!(/zzz/).should == nil - s.should == "this is a string" - end - - it "always taints resulting strings when self or regexp is tainted" do - strs = ["hello world"] - strs += strs.map { |s| s.dup.taint } - - strs.each do |str| - str = str.dup - str.slice!(//).tainted?.should == str.tainted? - str.slice!(/hello/).tainted?.should == str.tainted? - - tainted_re = /./ - tainted_re.taint - - str.slice!(tainted_re).tainted?.should == true - end - end - - it "doesn't taint self when regexp is tainted" do - s = "hello" - s.slice!(/./.taint) - s.tainted?.should == false - end - - it "returns subclass instances" do - s = StringSpecs::MyString.new("hello") - s.slice!(//).should be_kind_of(StringSpecs::MyString) - s.slice!(/../).should be_kind_of(StringSpecs::MyString) - end - - # This currently fails, but passes in a pure Rubinius environment (without mspec) - # probably because mspec uses match internally for its operation - it "sets $~ to MatchData when there is a match and nil when there's none" do - 'hello'.slice!(/./) - $~[0].should == 'h' - - 'hello'.slice!(/not/) - $~.should == nil - end - - ruby_version_is ""..."1.9" do - it "raises a TypeError if self is frozen" do - lambda { "this is a string".freeze.slice!(/s.*t/) }.should raise_error(TypeError) - end - end - - ruby_version_is "1.9" do - it "raises a RuntimeError if self is frozen" do - lambda { "this is a string".freeze.slice!(/s.*t/) }.should raise_error(RuntimeError) - lambda { "this is a string".freeze.slice!(/zzz/) }.should raise_error(RuntimeError) - lambda { "this is a string".freeze.slice!(/zzz/) }.should raise_error(RuntimeError) - end - end -end - -describe "String#slice! with Regexp, index" do - it "deletes and returns the capture for idx from self" do - str = "hello there" - str.slice!(/[aeiou](.)\1/, 0).should == "ell" - str.should == "ho there" - str.slice!(/(t)h/, 1).should == "t" - str.should == "ho here" - end - - it "always taints resulting strings when self or regexp is tainted" do - strs = ["hello world"] - strs += strs.map { |s| s.dup.taint } - - strs.each do |str| - str = str.dup - str.slice!(//, 0).tainted?.should == str.tainted? - str.slice!(/hello/, 0).tainted?.should == str.tainted? - - tainted_re = /(.)(.)(.)/ - tainted_re.taint - - str.slice!(tainted_re, 1).tainted?.should == true - end - end - - it "doesn't taint self when regexp is tainted" do - s = "hello" - s.slice!(/(.)(.)/.taint, 1) - s.tainted?.should == false - end - - it "returns nil if there was no match" do - s = "this is a string" - s.slice!(/x(zzz)/, 1).should == nil - s.should == "this is a string" - end - - it "returns nil if there is no capture for idx" do - "hello there".slice!(/[aeiou](.)\1/, 2).should == nil - # You can't refer to 0 using negative indices - "hello there".slice!(/[aeiou](.)\1/, -2).should == nil - end - - it "calls to_int on idx" do - obj = mock('2') - def obj.to_int() 2 end - - "har".slice!(/(.)(.)(.)/, 1.5).should == "h" - "har".slice!(/(.)(.)(.)/, obj).should == "a" - - obj = mock('2') - def obj.respond_to?(name) name == :to_int; end - def obj.method_missing(name) name == :to_int ? 2: super; end - "har".slice!(/(.)(.)(.)/, obj).should == "a" - end - - it "returns subclass instances" do - s = StringSpecs::MyString.new("hello") - s.slice!(/(.)(.)/, 0).should be_kind_of(StringSpecs::MyString) - s.slice!(/(.)(.)/, 1).should be_kind_of(StringSpecs::MyString) - end - - it "sets $~ to MatchData when there is a match and nil when there's none" do - 'hello'[/.(.)/, 0] - $~[0].should == 'he' - - 'hello'[/.(.)/, 1] - $~[1].should == 'e' - - 'hello'[/not/, 0] - $~.should == nil - end - - ruby_version_is ""..."1.9" do - it "raises a TypeError if self is frozen" do - lambda { "this is a string".freeze.slice!(/s.*t/) }.should raise_error(TypeError) - end - - it "doesn't raise a TypeError if self is frozen but there is no match" do - "this is a string".freeze.slice!(/zzz/, 0).should == nil - end - - it "doesn't raise a TypeError if self is frozen but there is no capture for idx" do - "this is a string".freeze.slice!(/(.)/, 2).should == nil - end - end - - ruby_version_is "1.9" do - it "raises a RuntimeError if self is frozen" do - lambda { "this is a string".freeze.slice!(/s.*t/) }.should raise_error(RuntimeError) - lambda { "this is a string".freeze.slice!(/zzz/, 0)}.should raise_error(RuntimeError) - lambda { "this is a string".freeze.slice!(/(.)/, 2)}.should raise_error(RuntimeError) - end - end -end - -describe "String#slice! with String" do - it "removes and returns the first occurrence of other_str from self" do - c = "hello hello" - c.slice!('llo').should == "llo" - c.should == "he hello" - end - - it "taints resulting strings when other is tainted" do - strs = ["", "hello world", "hello"] - strs += strs.map { |s| s.dup.taint } - - strs.each do |str| - str = str.dup - strs.each do |other| - other = other.dup - r = str.slice!(other) - - r.tainted?.should == !r.nil? & other.tainted? - end - end - end - - it "doesn't set $~" do - $~ = nil - - 'hello'.slice!('ll') - $~.should == nil - end - - it "returns nil if self does not contain other" do - a = "hello" - a.slice!('zzz').should == nil - a.should == "hello" - end - - it "doesn't call to_str on its argument" do - o = mock('x') - o.should_not_receive(:to_str) - - lambda { "hello".slice!(o) }.should raise_error(TypeError) - end - - it "returns a subclass instance when given a subclass instance" do - s = StringSpecs::MyString.new("el") - r = "hello".slice!(s) - r.should == "el" - r.should be_kind_of(StringSpecs::MyString) - end - - ruby_version_is ""..."1.9" do - it "raises a TypeError if self is frozen" do - lambda { "hello hello".freeze.slice!('llo') }.should raise_error(TypeError) - end - end - - ruby_version_is "1.9" do - it "raises a RuntimeError if self is frozen" do - lambda { "hello hello".freeze.slice!('llo') }.should raise_error(RuntimeError) - lambda { "this is a string".freeze.slice!('zzz')}.should raise_error(RuntimeError) - lambda { "this is a string".freeze.slice!('zzz')}.should raise_error(RuntimeError) - end - end -end Modified: MacRuby/trunk/spec/frozen/tags/macruby/core/string/slice_tags.txt =================================================================== --- MacRuby/trunk/spec/frozen/tags/macruby/core/string/slice_tags.txt 2010-03-19 22:26:15 UTC (rev 3828) +++ MacRuby/trunk/spec/frozen/tags/macruby/core/string/slice_tags.txt 2010-03-19 22:26:45 UTC (rev 3829) @@ -1,28 +1,10 @@ -critical:String#slice! with index calls to_int on index -fails:String#slice! with index raises a TypeError if self is frozen -fails:String#slice! with index doesn't raise a TypeError if self is frozen and idx is outside of self -fails:String#slice! with index, length deletes and returns the substring at idx and the given length -fails:String#slice! with index, length returns nil if the length is negative -fails:String#slice! with index, length raises a TypeError if self is frozen -fails:String#slice! with index, length doesn't raise a TypeError if self is frozen but the given position is out of self -fails:String#slice! with index, length doesn't raise a TypeError if self is frozen but length is negative -fails:String#slice! with index, length calls to_int on idx and length -fails:String#slice! with index, length returns subclass instances -fails:String#slice! Range returns subclass instances -fails:String#slice! Range calls to_int on range arguments -fails:String#slice! Range works with Range subclasses -fails:String#slice! Range raises a TypeError if self is frozen -fails:String#slice! Range doesn't raise a TypeError if self is frozen but the given range is out of self -fails:String#slice! with Regexp doesn't taint self when regexp is tainted -fails:String#slice! with Regexp returns subclass instances -fails:String#slice! with Regexp raises a TypeError if self is frozen -fails:String#slice! with Regexp doesn't raise a TypeError if self is frozen but there is no match -fails:String#slice! with Regexp, index doesn't taint self when regexp is tainted -fails:String#slice! with Regexp, index calls to_int on idx -fails:String#slice! with Regexp, index returns subclass instances -fails:String#slice! with Regexp, index raises a TypeError if self is frozen -fails:String#slice! with Regexp, index doesn't raise a TypeError if self is frozen but there is no match -fails:String#slice! with Regexp, index doesn't raise a TypeError if self is frozen but there is no capture for idx fails:String#slice! with String returns a subclass instance when given a subclass instance -fails:String#slice! with String raises a TypeError if self is frozen -fails:String#slice! with String doesn't raise a TypeError if self is frozen but self does not contain other \ No newline at end of file +fails:String#slice! with Regexp, index returns subclass instances +fails:String#slice! with Regexp returns subclass instances +fails:String#slice! Range returns subclass instances +fails:String#slice! with index, length returns subclass instances +fails:String#slice with String returns a subclass instance when given a subclass instance +fails:String#slice with Regexp, index returns subclass instances +fails:String#slice with Regexp returns subclass instances +fails:String#slice with Range returns subclass instances +fails:String#slice with index, length returns subclass instances