diff options
Diffstat (limited to 'spec/ruby/core/symbol')
34 files changed, 1146 insertions, 0 deletions
diff --git a/spec/ruby/core/symbol/all_symbols_spec.rb b/spec/ruby/core/symbol/all_symbols_spec.rb new file mode 100644 index 0000000000..689f6211de --- /dev/null +++ b/spec/ruby/core/symbol/all_symbols_spec.rb @@ -0,0 +1,19 @@ +require_relative '../../spec_helper' + +describe "Symbol.all_symbols" do + it "returns an array of Symbols" do + all_symbols = Symbol.all_symbols + all_symbols.should.instance_of?(Array) + all_symbols.each { |s| s.should.instance_of?(Symbol) } + end + + it "includes symbols that are strongly referenced" do + symbol = "symbol_specs_#{rand(5_000_000)}".to_sym + Symbol.all_symbols.should.include?(symbol) + end + + it "includes symbols that are referenced in source code but not yet executed" do + Symbol.all_symbols.any? { |s| s.to_s == 'symbol_specs_referenced_in_source_code' }.should == true + :symbol_specs_referenced_in_source_code + end +end diff --git a/spec/ruby/core/symbol/capitalize_spec.rb b/spec/ruby/core/symbol/capitalize_spec.rb new file mode 100644 index 0000000000..a93d951e6a --- /dev/null +++ b/spec/ruby/core/symbol/capitalize_spec.rb @@ -0,0 +1,41 @@ +# -*- encoding: utf-8 -*- +require_relative '../../spec_helper' + +describe "Symbol#capitalize" do + it "returns a Symbol" do + :glark.capitalize.should.instance_of?(Symbol) + end + + it "converts the first character to uppercase if it is ASCII" do + :lower.capitalize.should == :Lower + end + + it "leaves the first character alone if it is not an alphabetical character" do + :"£1.20".capitalize.should == :"£1.20" + end + + it "capitalizes the first character if it is Unicode" do + :"äöü".capitalize.should == :"Äöü" + :"aou".capitalize.should == :"Aou" + end + + it "converts subsequent uppercase ASCII characters to their lowercase equivalents" do + :lOWER.capitalize.should == :Lower + end + + it "leaves ASCII characters already in the correct case as they were" do + :Title.capitalize.should == :Title + end + + it "works with both upper- and lowercase ASCII characters in the same Symbol" do + :mIxEd.capitalize.should == :Mixed + end + + it "leaves lowercase Unicode characters (except in first position) as they were" do + "a\u{00DF}C".to_sym.capitalize.should == :"Aßc" + end + + it "leaves non-alphabetic ASCII characters as they were" do + "Glark?!?".to_sym.capitalize.should == :"Glark?!?" + end +end diff --git a/spec/ruby/core/symbol/case_compare_spec.rb b/spec/ruby/core/symbol/case_compare_spec.rb new file mode 100644 index 0000000000..0c6bc1eda5 --- /dev/null +++ b/spec/ruby/core/symbol/case_compare_spec.rb @@ -0,0 +1,11 @@ +require_relative '../../spec_helper' + +describe "Symbol#===" do + it "returns true when the argument is a Symbol" do + (Symbol === :ruby).should == true + end + + it "returns false when the argument is a String" do + (Symbol === 'ruby').should == false + end +end diff --git a/spec/ruby/core/symbol/casecmp_spec.rb b/spec/ruby/core/symbol/casecmp_spec.rb new file mode 100644 index 0000000000..dcb77a8350 --- /dev/null +++ b/spec/ruby/core/symbol/casecmp_spec.rb @@ -0,0 +1,152 @@ +# -*- encoding: utf-8 -*- +require_relative '../../spec_helper' + +describe "Symbol#casecmp with Symbol" do + it "compares symbols without regard to case" do + :abcdef.casecmp(:abcde).should == 1 + :aBcDeF.casecmp(:abcdef).should == 0 + :abcdef.casecmp(:abcdefg).should == -1 + :abcdef.casecmp(:ABCDEF).should == 0 + end + + it "doesn't consider non-ascii characters equal that aren't" do + # -- Latin-1 -- + upper_a_tilde = "\xC3".b.to_sym + upper_a_umlaut = "\xC4".b.to_sym + lower_a_tilde = "\xE3".b.to_sym + lower_a_umlaut = "\xE4".b.to_sym + + lower_a_tilde.casecmp(lower_a_umlaut).should_not == 0 + lower_a_umlaut.casecmp(lower_a_tilde).should_not == 0 + upper_a_tilde.casecmp(upper_a_umlaut).should_not == 0 + upper_a_umlaut.casecmp(upper_a_tilde).should_not == 0 + + # -- UTF-8 -- + upper_a_tilde = :"Ã" + lower_a_tilde = :"ã" + upper_a_umlaut = :"Ä" + lower_a_umlaut = :"ä" + + lower_a_tilde.casecmp(lower_a_umlaut).should_not == 0 + lower_a_umlaut.casecmp(lower_a_tilde).should_not == 0 + upper_a_tilde.casecmp(upper_a_umlaut).should_not == 0 + upper_a_umlaut.casecmp(upper_a_tilde).should_not == 0 + end + + it "doesn't do case mapping for non-ascii characters" do + # -- Latin-1 -- + upper_a_tilde = "\xC3".b.to_sym + upper_a_umlaut = "\xC4".b.to_sym + lower_a_tilde = "\xE3".b.to_sym + lower_a_umlaut = "\xE4".b.to_sym + + upper_a_tilde.casecmp(lower_a_tilde).should == -1 + upper_a_umlaut.casecmp(lower_a_umlaut).should == -1 + lower_a_tilde.casecmp(upper_a_tilde).should == 1 + lower_a_umlaut.casecmp(upper_a_umlaut).should == 1 + + # -- UTF-8 -- + upper_a_tilde = :"Ã" + lower_a_tilde = :"ã" + upper_a_umlaut = :"Ä" + lower_a_umlaut = :"ä" + + upper_a_tilde.casecmp(lower_a_tilde).should == -1 + upper_a_umlaut.casecmp(lower_a_umlaut).should == -1 + lower_a_tilde.casecmp(upper_a_tilde).should == 1 + lower_a_umlaut.casecmp(upper_a_umlaut).should == 1 + end + + it "returns 0 for empty strings in different encodings" do + ''.to_sym.casecmp(''.encode("UTF-32LE").to_sym).should == 0 + end +end + +describe "Symbol#casecmp" do + it "returns nil if other is a String" do + :abc.casecmp("abc").should == nil + end + + it "returns nil if other is an Integer" do + :abc.casecmp(1).should == nil + end + + it "returns nil if other is an object" do + obj = mock("string <=>") + :abc.casecmp(obj).should == nil + end +end + +describe 'Symbol#casecmp?' do + it "compares symbols without regard to case" do + :abcdef.casecmp?(:abcde).should == false + :aBcDeF.casecmp?(:abcdef).should == true + :abcdef.casecmp?(:abcdefg).should == false + :abcdef.casecmp?(:ABCDEF).should == true + end + + it "doesn't consider non-ascii characters equal that aren't" do + # -- Latin-1 -- + upper_a_tilde = "\xC3".b.to_sym + upper_a_umlaut = "\xC4".b.to_sym + lower_a_tilde = "\xE3".b.to_sym + lower_a_umlaut = "\xE4".b.to_sym + + lower_a_tilde.casecmp?(lower_a_umlaut).should_not == true + lower_a_umlaut.casecmp?(lower_a_tilde).should_not == true + upper_a_tilde.casecmp?(upper_a_umlaut).should_not == true + upper_a_umlaut.casecmp?(upper_a_tilde).should_not == true + + # -- UTF-8 -- + upper_a_tilde = :"Ã" + lower_a_tilde = :"ã" + upper_a_umlaut = :"Ä" + lower_a_umlaut = :"ä" + + lower_a_tilde.casecmp?(lower_a_umlaut).should_not == true + lower_a_umlaut.casecmp?(lower_a_tilde).should_not == true + upper_a_tilde.casecmp?(upper_a_umlaut).should_not == true + upper_a_umlaut.casecmp?(upper_a_tilde).should_not == true + end + + it "doesn't do case mapping for non-ascii and non-unicode characters" do + # -- Latin-1 -- + upper_a_tilde = "\xC3".b.to_sym + upper_a_umlaut = "\xC4".b.to_sym + lower_a_tilde = "\xE3".b.to_sym + lower_a_umlaut = "\xE4".b.to_sym + + upper_a_tilde.casecmp?(lower_a_tilde).should == false + upper_a_umlaut.casecmp?(lower_a_umlaut).should == false + lower_a_tilde.casecmp?(upper_a_tilde).should == false + lower_a_umlaut.casecmp?(upper_a_umlaut).should == false + end + + it 'does case mapping for unicode characters' do + # -- UTF-8 -- + upper_a_tilde = :"Ã" + lower_a_tilde = :"ã" + upper_a_umlaut = :"Ä" + lower_a_umlaut = :"ä" + + upper_a_tilde.casecmp?(lower_a_tilde).should == true + upper_a_umlaut.casecmp?(lower_a_umlaut).should == true + lower_a_tilde.casecmp?(upper_a_tilde).should == true + lower_a_umlaut.casecmp?(upper_a_umlaut).should == true + end + + it 'returns nil when comparing characters with different encodings' do + # -- Latin-1 -- + upper_a_tilde = "\xC3".b.to_sym + + # -- UTF-8 -- + lower_a_tilde = :"ã" + + upper_a_tilde.casecmp?(lower_a_tilde).should == nil + lower_a_tilde.casecmp?(upper_a_tilde).should == nil + end + + it "returns true for empty symbols in different encodings" do + ''.to_sym.should.casecmp?(''.encode("UTF-32LE").to_sym) + end +end diff --git a/spec/ruby/core/symbol/comparison_spec.rb b/spec/ruby/core/symbol/comparison_spec.rb new file mode 100644 index 0000000000..6d56176e97 --- /dev/null +++ b/spec/ruby/core/symbol/comparison_spec.rb @@ -0,0 +1,51 @@ +require_relative '../../spec_helper' + +describe "Symbol#<=> with Symbol" do + it "compares individual characters based on their ascii value" do + ascii_order = Array.new(256) { |x| x.chr.to_sym } + sort_order = ascii_order.sort + sort_order.should == ascii_order + end + + it "returns -1 when self is less than other" do + (:this <=> :those).should == -1 + end + + it "returns 0 when self is equal to other" do + (:yep <=> :yep).should == 0 + end + + it "returns 1 when self is greater than other" do + (:yoddle <=> :griddle).should == 1 + end + + it "considers symbol that comes lexicographically first to be less if the symbols have same size" do + (:aba <=> :abc).should == -1 + (:abc <=> :aba).should == 1 + end + + it "doesn't consider shorter string to be less if longer string starts with shorter one" do + (:abc <=> :abcd).should == -1 + (:abcd <=> :abc).should == 1 + end + + it "compares shorter string with corresponding number of first chars of longer string" do + (:abx <=> :abcd).should == 1 + (:abcd <=> :abx).should == -1 + end +end + +describe "Symbol#<=>" do + it "returns nil if other is a String" do + (:abc <=> "abc").should == nil + end + + it "returns nil if other is an Integer" do + (:abc <=> 1).should == nil + end + + it "returns nil if other is an object" do + obj = mock("string <=>") + (:abc <=> obj).should == nil + end +end diff --git a/spec/ruby/core/symbol/downcase_spec.rb b/spec/ruby/core/symbol/downcase_spec.rb new file mode 100644 index 0000000000..76418aa9da --- /dev/null +++ b/spec/ruby/core/symbol/downcase_spec.rb @@ -0,0 +1,25 @@ +# -*- encoding: utf-8 -*- +require_relative '../../spec_helper' + +describe "Symbol#downcase" do + it "returns a Symbol" do + :glark.downcase.should.instance_of?(Symbol) + end + + it "converts uppercase ASCII characters to their lowercase equivalents" do + :lOwEr.downcase.should == :lower + end + + it "leaves lowercase Unicode characters as they were" do + "\u{E0}Bc".to_sym.downcase.should == :"àbc" + end + + it "uncapitalizes all Unicode characters" do + "ÄÖÜ".to_sym.downcase.should == :"äöü" + "AOU".to_sym.downcase.should == :"aou" + end + + it "leaves non-alphabetic ASCII characters as they were" do + "Glark?!?".to_sym.downcase.should == :"glark?!?" + end +end diff --git a/spec/ruby/core/symbol/dup_spec.rb b/spec/ruby/core/symbol/dup_spec.rb new file mode 100644 index 0000000000..eef3078030 --- /dev/null +++ b/spec/ruby/core/symbol/dup_spec.rb @@ -0,0 +1,7 @@ +require_relative '../../spec_helper' + +describe "Symbol#dup" do + it "returns self" do + :a_symbol.dup.should.equal?(:a_symbol) + end +end diff --git a/spec/ruby/core/symbol/element_reference_spec.rb b/spec/ruby/core/symbol/element_reference_spec.rb new file mode 100644 index 0000000000..df6bc15ddb --- /dev/null +++ b/spec/ruby/core/symbol/element_reference_spec.rb @@ -0,0 +1,6 @@ +require_relative '../../spec_helper' +require_relative 'shared/slice' + +describe "Symbol#[]" do + it_behaves_like :symbol_slice, :[] +end diff --git a/spec/ruby/core/symbol/empty_spec.rb b/spec/ruby/core/symbol/empty_spec.rb new file mode 100644 index 0000000000..1d90a59a5b --- /dev/null +++ b/spec/ruby/core/symbol/empty_spec.rb @@ -0,0 +1,11 @@ +require_relative '../../spec_helper' + +describe "Symbol#empty?" do + it "returns true if self is empty" do + :"".empty?.should == true + end + + it "returns false if self is non-empty" do + :"a".empty?.should == false + end +end diff --git a/spec/ruby/core/symbol/encoding_spec.rb b/spec/ruby/core/symbol/encoding_spec.rb new file mode 100644 index 0000000000..732fd62e26 --- /dev/null +++ b/spec/ruby/core/symbol/encoding_spec.rb @@ -0,0 +1,23 @@ +# encoding: utf-8 + +require_relative '../../spec_helper' + +describe "Symbol#encoding for ASCII symbols" do + it "is US-ASCII" do + :foo.encoding.name.should == "US-ASCII" + end + + it "is US-ASCII after converting to string" do + :foo.to_s.encoding.name.should == "US-ASCII" + end +end + +describe "Symbol#encoding for UTF-8 symbols" do + it "is UTF-8" do + :åäö.encoding.name.should == "UTF-8" + end + + it "is UTF-8 after converting to string" do + :åäö.to_s.encoding.name.should == "UTF-8" + end +end diff --git a/spec/ruby/core/symbol/end_with_spec.rb b/spec/ruby/core/symbol/end_with_spec.rb new file mode 100644 index 0000000000..4b9f5a4996 --- /dev/null +++ b/spec/ruby/core/symbol/end_with_spec.rb @@ -0,0 +1,8 @@ +# -*- encoding: utf-8 -*- + +require_relative '../../spec_helper' +require_relative '../../shared/string/end_with' + +describe "Symbol#end_with?" do + it_behaves_like :end_with, :to_sym +end diff --git a/spec/ruby/core/symbol/equal_value_spec.rb b/spec/ruby/core/symbol/equal_value_spec.rb new file mode 100644 index 0000000000..3fe997d02a --- /dev/null +++ b/spec/ruby/core/symbol/equal_value_spec.rb @@ -0,0 +1,14 @@ +require_relative '../../spec_helper' + +describe "Symbol#==" do + it "only returns true when the other is exactly the same symbol" do + (:ruby == :ruby).should == true + (:ruby == :"ruby").should == true + (:ruby == :'ruby').should == true + (:@ruby == :@ruby).should == true + + (:ruby == :@ruby).should == false + (:foo == :bar).should == false + (:ruby == 'ruby').should == false + end +end diff --git a/spec/ruby/core/symbol/fixtures/classes.rb b/spec/ruby/core/symbol/fixtures/classes.rb new file mode 100644 index 0000000000..6552f6ee38 --- /dev/null +++ b/spec/ruby/core/symbol/fixtures/classes.rb @@ -0,0 +1,3 @@ +module SymbolSpecs + class MyRange < Range; end +end diff --git a/spec/ruby/core/symbol/id2name_spec.rb b/spec/ruby/core/symbol/id2name_spec.rb new file mode 100644 index 0000000000..2caa89fc37 --- /dev/null +++ b/spec/ruby/core/symbol/id2name_spec.rb @@ -0,0 +1,6 @@ +require_relative '../../spec_helper' +require_relative 'shared/id2name' + +describe "Symbol#id2name" do + it_behaves_like :symbol_id2name, :id2name +end diff --git a/spec/ruby/core/symbol/inspect_spec.rb b/spec/ruby/core/symbol/inspect_spec.rb new file mode 100644 index 0000000000..f2269996af --- /dev/null +++ b/spec/ruby/core/symbol/inspect_spec.rb @@ -0,0 +1,131 @@ +require_relative '../../spec_helper' + +describe "Symbol#inspect" do + symbols = { + fred: ":fred", + :fred? => ":fred?", + :fred! => ":fred!", + :BAD! => ":BAD!", + :_BAD! => ":_BAD!", + :$ruby => ":$ruby", + :@ruby => ":@ruby", + :@@ruby => ":@@ruby", + :"$ruby!" => ":\"$ruby!\"", + :"$ruby?" => ":\"$ruby?\"", + :"@ruby!" => ":\"@ruby!\"", + :"@ruby?" => ":\"@ruby?\"", + :"@@ruby!" => ":\"@@ruby!\"", + :"@@ruby?" => ":\"@@ruby?\"", + + :$-w => ":$-w", + :"$-ww" => ":\"$-ww\"", + :"$+" => ":$+", + :"$~" => ":$~", + :"$:" => ":$:", + :"$?" => ":$?", + :"$<" => ":$<", + :"$_" => ":$_", + :"$/" => ":$/", + :"$'" => ":$'", + :"$\"" => ":$\"", + :"$$" => ":$$", + :"$." => ":$.", + :"$," => ":$,", + :"$`" => ":$`", + :"$!" => ":$!", + :"$;" => ":$;", + :"$\\" => ":$\\", + :"$=" => ":$=", + :"$*" => ":$*", + :"$>" => ":$>", + :"$&" => ":$&", + :"$@" => ":$@", + :"$1234" => ":$1234", + + :-@ => ":-@", + :+@ => ":+@", + :% => ":%", + :& => ":&", + :* => ":*", + :** => ":**", + :"/" => ":/", # lhs quoted for emacs happiness + :< => ":<", + :<= => ":<=", + :<=> => ":<=>", + :== => ":==", + :=== => ":===", + :=~ => ":=~", + :> => ":>", + :>= => ":>=", + :>> => ":>>", + :[] => ":[]", + :[]= => ":[]=", + :"\<\<" => ":\<\<", + :^ => ":^", + :"`" => ":`", # for emacs, and justice! + :~ => ":~", + :| => ":|", + + :"!" => ":!", + :"!=" => ":!=", + :"!~" => ":!~", + :"\$" => ":\"$\"", # for justice! + :"&&" => ":\"&&\"", + :"'" => ":\"\'\"", + :"," => ":\",\"", + :"." => ":\".\"", + :".." => ":\"..\"", + :"..." => ":\"...\"", + :":" => ":\":\"", + :"::" => ":\"::\"", + :";" => ":\";\"", + :"=" => ":\"=\"", + :"=>" => ":\"=>\"", + :"\?" => ":\"?\"", # rawr! + :"@" => ":\"@\"", + :"||" => ":\"||\"", + :"|||" => ":\"|||\"", + :"++" => ":\"++\"", + + :"\"" => ":\"\\\"\"", + :"\"\"" => ":\"\\\"\\\"\"", + + :"9" => ":\"9\"", + :"foo bar" => ":\"foo bar\"", + :"*foo" => ":\"*foo\"", + :"foo " => ":\"foo \"", + :" foo" => ":\" foo\"", + :" " => ":\" \"", + + :"ê" => [":ê", ":\"\\u00EA\""], + :"测" => [":测", ":\"\\u6D4B\""], + :"🦊" => [":🦊", ":\"\\u{1F98A}\""], + } + + expected_by_encoding = Encoding::default_external == Encoding::UTF_8 ? 0 : 1 + symbols.each do |input, expected| + expected = expected[expected_by_encoding] if expected.is_a?(Array) + it "returns self as a symbol literal for #{expected}" do + input.inspect.should == expected + end + end + + it "quotes BINARY symbols" do + sym = "foo\xA4".b.to_sym + sym.inspect.should == ':"foo\xA4"' + end + + it "quotes symbols in non-ASCII-compatible encodings" do + Encoding.list.reject(&:ascii_compatible?).reject(&:dummy?).each do |encoding| + sym = "foo".encode(encoding).to_sym + sym.inspect.should == ':"foo"' + end + end + + it "quotes and escapes symbols in dummy encodings" do + Encoding.list.select(&:dummy?).each do |encoding| + sym = "abcd".dup.force_encoding(encoding).to_sym + sym.inspect.should == ':"\x61\x62\x63\x64"' + end + end +end diff --git a/spec/ruby/core/symbol/intern_spec.rb b/spec/ruby/core/symbol/intern_spec.rb new file mode 100644 index 0000000000..9d0914c7fb --- /dev/null +++ b/spec/ruby/core/symbol/intern_spec.rb @@ -0,0 +1,11 @@ +require_relative '../../spec_helper' + +describe "Symbol#intern" do + it "returns self" do + :foo.intern.should == :foo + end + + it "returns a Symbol" do + :foo.intern.should.is_a?(Symbol) + end +end diff --git a/spec/ruby/core/symbol/length_spec.rb b/spec/ruby/core/symbol/length_spec.rb new file mode 100644 index 0000000000..27bee575ef --- /dev/null +++ b/spec/ruby/core/symbol/length_spec.rb @@ -0,0 +1,6 @@ +require_relative '../../spec_helper' +require_relative 'shared/length' + +describe "Symbol#length" do + it_behaves_like :symbol_length, :length +end diff --git a/spec/ruby/core/symbol/match_spec.rb b/spec/ruby/core/symbol/match_spec.rb new file mode 100644 index 0000000000..7b165218c6 --- /dev/null +++ b/spec/ruby/core/symbol/match_spec.rb @@ -0,0 +1,77 @@ +require_relative '../../spec_helper' + +describe :symbol_match, shared: true do + it "returns the index of the beginning of the match" do + :abc.send(@method, /b/).should == 1 + end + + it "returns nil if there is no match" do + :a.send(@method, /b/).should == nil + end + + it "sets the last match pseudo-variables" do + :a.send(@method, /(.)/).should == 0 + $1.should == "a" + end +end + +describe "Symbol#=~" do + it_behaves_like :symbol_match, :=~ +end + +describe "Symbol#match" do + it "returns the MatchData" do + result = :abc.match(/b/) + result.should.is_a?(MatchData) + result[0].should == 'b' + end + + it "returns nil if there is no match" do + :a.match(/b/).should == nil + end + + it "sets the last match pseudo-variables" do + :a.match(/(.)/)[0].should == 'a' + $1.should == "a" + end + + describe "when passed a block" do + it "yields the MatchData" do + :abc.match(/./) {|m| ScratchPad.record m } + ScratchPad.recorded.should.is_a?(MatchData) + end + + it "returns the block result" do + :abc.match(/./) { :result }.should == :result + end + + it "does not yield if there is no match" do + ScratchPad.record [] + :b.match(/a/) {|m| ScratchPad << m } + ScratchPad.recorded.should == [] + end + end +end + +describe "Symbol#match?" do + before :each do + # Resetting Regexp.last_match + /DONTMATCH/.match '' + end + + context "when matches the given regex" do + it "returns true but does not set Regexp.last_match" do + :string.match?(/string/i).should == true + Regexp.last_match.should == nil + end + end + + it "returns false when does not match the given regex" do + :string.match?(/STRING/).should == false + end + + it "takes matching position as the 2nd argument" do + :string.match?(/str/i, 0).should == true + :string.match?(/str/i, 1).should == false + end +end diff --git a/spec/ruby/core/symbol/name_spec.rb b/spec/ruby/core/symbol/name_spec.rb new file mode 100644 index 0000000000..f9b631266c --- /dev/null +++ b/spec/ruby/core/symbol/name_spec.rb @@ -0,0 +1,17 @@ +require_relative '../../spec_helper' + +describe "Symbol#name" do + it "returns string" do + :ruby.name.should == "ruby" + :ルビー.name.should == "ルビー" + end + + it "returns same string instance" do + :"ruby_3".name.should.equal?(:ruby_3.name) + :"ruby_#{1+2}".name.should.equal?(:ruby_3.name) + end + + it "returns frozen string" do + :symbol.name.should.frozen? + end +end diff --git a/spec/ruby/core/symbol/next_spec.rb b/spec/ruby/core/symbol/next_spec.rb new file mode 100644 index 0000000000..97fe913739 --- /dev/null +++ b/spec/ruby/core/symbol/next_spec.rb @@ -0,0 +1,6 @@ +require_relative '../../spec_helper' +require_relative 'shared/succ' + +describe "Symbol#next" do + it_behaves_like :symbol_succ, :next +end diff --git a/spec/ruby/core/symbol/shared/id2name.rb b/spec/ruby/core/symbol/shared/id2name.rb new file mode 100644 index 0000000000..00a9c7d7dc --- /dev/null +++ b/spec/ruby/core/symbol/shared/id2name.rb @@ -0,0 +1,30 @@ +describe :symbol_id2name, shared: true do + it "returns the string corresponding to self" do + :rubinius.send(@method).should == "rubinius" + :squash.send(@method).should == "squash" + :[].send(@method).should == "[]" + :@ruby.send(@method).should == "@ruby" + :@@ruby.send(@method).should == "@@ruby" + end + + it "returns a String in the same encoding as self" do + string = "ruby".encode("US-ASCII") + symbol = string.to_sym + + symbol.send(@method).encoding.should == Encoding::US_ASCII + end + + ruby_version_is "3.4" do + it "warns about mutating returned string" do + -> { :bad!.send(@method).upcase! }.should complain(/warning: string returned by :bad!.to_s will be frozen in the future/) + end + + it "does not warn about mutation when Warning[:deprecated] is false" do + deprecated = Warning[:deprecated] + Warning[:deprecated] = false + -> { :bad!.send(@method).upcase! }.should_not complain + ensure + Warning[:deprecated] = deprecated + end + end +end diff --git a/spec/ruby/core/symbol/shared/length.rb b/spec/ruby/core/symbol/shared/length.rb new file mode 100644 index 0000000000..692e8c57e3 --- /dev/null +++ b/spec/ruby/core/symbol/shared/length.rb @@ -0,0 +1,23 @@ +# -*- encoding: utf-8 -*- + +describe :symbol_length, shared: true do + it "returns 0 for empty name" do + :''.send(@method).should == 0 + end + + it "returns 1 for name formed by a NUL character" do + :"\x00".send(@method).should == 1 + end + + it "returns 3 for name formed by 3 ASCII characters" do + :one.send(@method).should == 3 + end + + it "returns 4 for name formed by 4 ASCII characters" do + :four.send(@method).should == 4 + end + + it "returns 4 for name formed by 1 multibyte and 3 ASCII characters" do + :"\xC3\x9Cber".send(@method).should == 4 + end +end diff --git a/spec/ruby/core/symbol/shared/slice.rb b/spec/ruby/core/symbol/shared/slice.rb new file mode 100644 index 0000000000..4e3a35240c --- /dev/null +++ b/spec/ruby/core/symbol/shared/slice.rb @@ -0,0 +1,262 @@ +require_relative '../fixtures/classes' + +describe :symbol_slice, shared: true do + describe "with an Integer index" do + it "returns the character code of the element at the index" do + :symbol.send(@method, 1).should == ?y + end + + it "returns nil if the index starts from the end and is greater than the length" do + :symbol.send(@method, -10).should == nil + end + + it "returns nil if the index is greater than the length" do + :symbol.send(@method, 42).should == nil + end + end + + describe "with an Integer index and length" do + describe "and a positive index and length" do + it "returns a slice" do + :symbol.send(@method, 1,3).should == "ymb" + end + + it "returns a blank slice if the length is 0" do + :symbol.send(@method, 0,0).should == "" + :symbol.send(@method, 1,0).should == "" + end + + it "returns a slice of all remaining characters if the given length is greater than the actual length" do + :symbol.send(@method, 1,100).should == "ymbol" + end + + it "returns nil if the index is greater than the length" do + :symbol.send(@method, 10,1).should == nil + end + end + + describe "and a positive index and negative length" do + it "returns nil" do + :symbol.send(@method, 0,-1).should == nil + :symbol.send(@method, 1,-1).should == nil + end + end + + describe "and a negative index and positive length" do + it "returns a slice starting from the end upto the length" do + :symbol.send(@method, -3,2).should == "bo" + end + + it "returns a blank slice if the length is 0" do + :symbol.send(@method, -1,0).should == "" + end + + it "returns a slice of all remaining characters if the given length is larger than the actual length" do + :symbol.send(@method, -4,100).should == "mbol" + end + + it "returns nil if the index is past the start" do + :symbol.send(@method, -10,1).should == nil + end + end + + describe "and a negative index and negative length" do + it "returns nil" do + :symbol.send(@method, -1,-1).should == nil + end + end + + describe "and a Float length" do + it "converts the length to an Integer" do + :symbol.send(@method, 2,2.5).should == "mb" + end + end + + describe "and a nil length" do + it "raises a TypeError" do + -> { :symbol.send(@method, 1,nil) }.should.raise(TypeError) + end + end + + describe "and a length that cannot be converted into an Integer" do + it "raises a TypeError when given an Array" do + -> { :symbol.send(@method, 1,Array.new) }.should.raise(TypeError) + end + + it "raises a TypeError when given an Hash" do + -> { :symbol.send(@method, 1,Hash.new) }.should.raise(TypeError) + end + + it "raises a TypeError when given an Object" do + -> { :symbol.send(@method, 1,Object.new) }.should.raise(TypeError) + end + end + end + + describe "with a Float index" do + it "converts the index to an Integer" do + :symbol.send(@method, 1.5).should == ?y + end + end + + describe "with a nil index" do + it "raises a TypeError" do + -> { :symbol.send(@method, nil) }.should.raise(TypeError) + end + end + + describe "with an index that cannot be converted into an Integer" do + it "raises a TypeError when given an Array" do + -> { :symbol.send(@method, Array.new) }.should.raise(TypeError) + end + + it "raises a TypeError when given an Hash" do + -> { :symbol.send(@method, Hash.new) }.should.raise(TypeError) + end + + it "raises a TypeError when given an Object" do + -> { :symbol.send(@method, Object.new) }.should.raise(TypeError) + end + end + + describe "with a Range slice" do + describe "that is within bounds" do + it "returns a slice if both range values begin at the start and are within bounds" do + :symbol.send(@method, 1..4).should == "ymbo" + end + + it "returns a slice if the first range value begins at the start and the last begins at the end" do + :symbol.send(@method, 1..-1).should == "ymbol" + end + + it "returns a slice if the first range value begins at the end and the last begins at the end" do + :symbol.send(@method, -4..-1).should == "mbol" + end + end + + describe "that is out of bounds" do + it "returns nil if the first range value begins past the end" do + :symbol.send(@method, 10..12).should == nil + end + + it "returns a blank string if the first range value is within bounds and the last range value is not" do + :symbol.send(@method, -2..-10).should == "" + :symbol.send(@method, 2..-10).should == "" + end + + it "returns nil if the first range value starts from the end and is within bounds and the last value starts from the end and is greater than the length" do + :symbol.send(@method, -10..-12).should == nil + end + + it "returns nil if the first range value starts from the end and is out of bounds and the last value starts from the end and is less than the length" do + :symbol.send(@method, -10..-2).should == nil + end + end + + describe "with Float values" do + it "converts the first value to an Integer" do + :symbol.send(@method, 0.5..2).should == "sym" + end + + it "converts the last value to an Integer" do + :symbol.send(@method, 0..2.5).should == "sym" + end + end + end + + describe "with a Range subclass slice" do + it "returns a slice" do + range = SymbolSpecs::MyRange.new(1, 4) + :symbol.send(@method, range).should == "ymbo" + end + end + + describe "with a Regex slice" do + describe "without a capture index" do + it "returns a string of the match" do + :symbol.send(@method, /[^bol]+/).should == "sym" + end + + it "returns nil if the expression does not match" do + :symbol.send(@method, /0-9/).should == nil + end + + it "sets $~ to the MatchData if there is a match" do + :symbol.send(@method, /[^bol]+/) + $~[0].should == "sym" + end + + it "does not set $~ if there if there is not a match" do + :symbol.send(@method, /[0-9]+/) + $~.should == nil + end + end + + describe "with a capture index" do + it "returns a string of the complete match if the capture index is 0" do + :symbol.send(@method, /(sy)(mb)(ol)/, 0).should == "symbol" + end + + it "returns a string for the matched capture at the given index" do + :symbol.send(@method, /(sy)(mb)(ol)/, 1).should == "sy" + :symbol.send(@method, /(sy)(mb)(ol)/, -1).should == "ol" + end + + it "returns nil if there is no capture for the index" do + :symbol.send(@method, /(sy)(mb)(ol)/, 4).should == nil + :symbol.send(@method, /(sy)(mb)(ol)/, -4).should == nil + end + + it "converts the index to an Integer" do + :symbol.send(@method, /(sy)(mb)(ol)/, 1.5).should == "sy" + end + + describe "and an index that cannot be converted to an Integer" do + it "raises a TypeError when given an Hash" do + -> { :symbol.send(@method, /(sy)(mb)(ol)/, Hash.new) }.should.raise(TypeError) + end + + it "raises a TypeError when given an Array" do + -> { :symbol.send(@method, /(sy)(mb)(ol)/, Array.new) }.should.raise(TypeError) + end + + it "raises a TypeError when given an Object" do + -> { :symbol.send(@method, /(sy)(mb)(ol)/, Object.new) }.should.raise(TypeError) + end + end + + it "raises a TypeError if the index is nil" do + -> { :symbol.send(@method, /(sy)(mb)(ol)/, nil) }.should.raise(TypeError) + end + + it "sets $~ to the MatchData if there is a match" do + :symbol.send(@method, /(sy)(mb)(ol)/, 0) + $~[0].should == "symbol" + $~[1].should == "sy" + $~[2].should == "mb" + $~[3].should == "ol" + end + + it "does not set $~ to the MatchData if there is not a match" do + :symbol.send(@method, /0-9/, 0) + $~.should == nil + end + end + end + + describe "with a String slice" do + it "does not set $~" do + $~ = nil + :symbol.send(@method, "sym") + $~.should == nil + end + + it "returns a string if there is match" do + :symbol.send(@method, "ymb").should == "ymb" + end + + it "returns nil if there is not a match" do + :symbol.send(@method, "foo").should == nil + end + end +end diff --git a/spec/ruby/core/symbol/shared/succ.rb b/spec/ruby/core/symbol/shared/succ.rb new file mode 100644 index 0000000000..dde298207e --- /dev/null +++ b/spec/ruby/core/symbol/shared/succ.rb @@ -0,0 +1,18 @@ +require_relative '../../../spec_helper' + +describe :symbol_succ, shared: true do + it "returns a successor" do + :abcd.send(@method).should == :abce + :THX1138.send(@method).should == :THX1139 + end + + it "propagates a 'carry'" do + :"1999zzz".send(@method).should == :"2000aaa" + :ZZZ9999.send(@method).should == :AAAA0000 + end + + it "increments non-alphanumeric characters when no alphanumeric characters are present" do + :"<<koala>>".send(@method).should == :"<<koalb>>" + :"***".send(@method).should == :"**+" + end +end diff --git a/spec/ruby/core/symbol/size_spec.rb b/spec/ruby/core/symbol/size_spec.rb new file mode 100644 index 0000000000..5e2aa8d4d2 --- /dev/null +++ b/spec/ruby/core/symbol/size_spec.rb @@ -0,0 +1,6 @@ +require_relative '../../spec_helper' +require_relative 'shared/length' + +describe "Symbol#size" do + it_behaves_like :symbol_length, :size +end diff --git a/spec/ruby/core/symbol/slice_spec.rb b/spec/ruby/core/symbol/slice_spec.rb new file mode 100644 index 0000000000..d2421c474c --- /dev/null +++ b/spec/ruby/core/symbol/slice_spec.rb @@ -0,0 +1,6 @@ +require_relative '../../spec_helper' +require_relative 'shared/slice' + +describe "Symbol#slice" do + it_behaves_like :symbol_slice, :slice +end diff --git a/spec/ruby/core/symbol/start_with_spec.rb b/spec/ruby/core/symbol/start_with_spec.rb new file mode 100644 index 0000000000..cd43279003 --- /dev/null +++ b/spec/ruby/core/symbol/start_with_spec.rb @@ -0,0 +1,8 @@ +# -*- encoding: utf-8 -*- +require_relative '../../spec_helper' +require_relative 'fixtures/classes' +require_relative '../../shared/string/start_with' + +describe "Symbol#start_with?" do + it_behaves_like :start_with, :to_sym +end diff --git a/spec/ruby/core/symbol/succ_spec.rb b/spec/ruby/core/symbol/succ_spec.rb new file mode 100644 index 0000000000..694bfff862 --- /dev/null +++ b/spec/ruby/core/symbol/succ_spec.rb @@ -0,0 +1,6 @@ +require_relative '../../spec_helper' +require_relative 'shared/succ' + +describe "Symbol#succ" do + it_behaves_like :symbol_succ, :succ +end diff --git a/spec/ruby/core/symbol/swapcase_spec.rb b/spec/ruby/core/symbol/swapcase_spec.rb new file mode 100644 index 0000000000..95fc29e32b --- /dev/null +++ b/spec/ruby/core/symbol/swapcase_spec.rb @@ -0,0 +1,29 @@ +# -*- encoding: utf-8 -*- +require_relative '../../spec_helper' + +describe "Symbol#swapcase" do + it "returns a Symbol" do + :glark.swapcase.should.instance_of?(Symbol) + end + + it "converts lowercase ASCII characters to their uppercase equivalents" do + :lower.swapcase.should == :LOWER + end + + it "converts uppercase ASCII characters to their lowercase equivalents" do + :UPPER.swapcase.should == :upper + end + + it "works with both upper- and lowercase ASCII characters in the same Symbol" do + :mIxEd.swapcase.should == :MiXeD + end + + it "swaps the case for Unicode characters" do + "äÖü".to_sym.swapcase.should == :"ÄöÜ" + "aOu".to_sym.swapcase.should == :"AoU" + end + + it "leaves non-alphabetic ASCII characters as they were" do + "Glark?!?".to_sym.swapcase.should == :"gLARK?!?" + end +end diff --git a/spec/ruby/core/symbol/symbol_spec.rb b/spec/ruby/core/symbol/symbol_spec.rb new file mode 100644 index 0000000000..3534686a08 --- /dev/null +++ b/spec/ruby/core/symbol/symbol_spec.rb @@ -0,0 +1,19 @@ +require_relative '../../spec_helper' + +describe "Symbol" do + it "includes Comparable" do + Symbol.include?(Comparable).should == true + end + + it ".allocate raises a TypeError" do + -> do + Symbol.allocate + end.should.raise(TypeError) + end + + it ".new is undefined" do + -> do + Symbol.new + end.should.raise(NoMethodError) + end +end diff --git a/spec/ruby/core/symbol/to_proc_spec.rb b/spec/ruby/core/symbol/to_proc_spec.rb new file mode 100644 index 0000000000..93ed1e9e9b --- /dev/null +++ b/spec/ruby/core/symbol/to_proc_spec.rb @@ -0,0 +1,78 @@ +require_relative '../../spec_helper' + +describe "Symbol#to_proc" do + it "returns a new Proc" do + proc = :to_s.to_proc + proc.should.is_a?(Proc) + end + + it "sends self to arguments passed when calling #call on the Proc" do + obj = mock("Receiving #to_s") + obj.should_receive(:to_s).and_return("Received #to_s") + :to_s.to_proc.call(obj).should == "Received #to_s" + end + + it "returns a Proc with #lambda? true" do + pr = :to_s.to_proc + pr.should.lambda? + end + + it "produces a Proc with arity -2" do + pr = :to_s.to_proc + pr.arity.should == -2 + end + + it "produces a Proc that always returns [[:req], [:rest]] for #parameters" do + pr = :to_s.to_proc + pr.parameters.should == [[:req], [:rest]] + end + + it "only calls public methods" do + body = proc do + public def pub; @a << :pub end + protected def pro; @a << :pro end + private def pri; @a << :pri end + attr_reader :a + end + + @a = [] + singleton_class.class_eval(&body) + tap(&:pub) + proc{tap(&:pro)}.should.raise(NoMethodError, /protected method [`']pro' called/) + proc{tap(&:pri)}.should.raise(NoMethodError, /private method [`']pri' called/) + @a.should == [:pub] + + @a = [] + c = Class.new(&body) + o = c.new + o.instance_variable_set(:@a, []) + o.tap(&:pub) + proc{tap(&:pro)}.should.raise(NoMethodError, /protected method [`']pro' called/) + proc{o.tap(&:pri)}.should.raise(NoMethodError, /private method [`']pri' called/) + o.a.should == [:pub] + end + + it "raises an ArgumentError when calling #call on the Proc without receiver" do + -> { + :object_id.to_proc.call + }.should.raise(ArgumentError, /no receiver given|wrong number of arguments \(given 0, expected 1\+\)/) + end + + it "passes along the block passed to Proc#call" do + klass = Class.new do + def m + yield + end + + def to_proc + :m.to_proc.call(self) { :value } + end + end + klass.new.to_proc.should == :value + end + + it "produces a proc with source location nil" do + pr = :to_s.to_proc + pr.source_location.should == nil + end +end diff --git a/spec/ruby/core/symbol/to_s_spec.rb b/spec/ruby/core/symbol/to_s_spec.rb new file mode 100644 index 0000000000..cd963faa28 --- /dev/null +++ b/spec/ruby/core/symbol/to_s_spec.rb @@ -0,0 +1,6 @@ +require_relative '../../spec_helper' +require_relative 'shared/id2name' + +describe "Symbol#to_s" do + it_behaves_like :symbol_id2name, :to_s +end diff --git a/spec/ruby/core/symbol/to_sym_spec.rb b/spec/ruby/core/symbol/to_sym_spec.rb new file mode 100644 index 0000000000..e75f3d48a8 --- /dev/null +++ b/spec/ruby/core/symbol/to_sym_spec.rb @@ -0,0 +1,9 @@ +require_relative '../../spec_helper' + +describe "Symbol#to_sym" do + it "returns self" do + [:rubinius, :squash, :[], :@ruby, :@@ruby].each do |sym| + sym.to_sym.should == sym + end + end +end diff --git a/spec/ruby/core/symbol/upcase_spec.rb b/spec/ruby/core/symbol/upcase_spec.rb new file mode 100644 index 0000000000..3895d95efb --- /dev/null +++ b/spec/ruby/core/symbol/upcase_spec.rb @@ -0,0 +1,21 @@ +# -*- encoding: utf-8 -*- +require_relative '../../spec_helper' + +describe "Symbol#upcase" do + it "returns a Symbol" do + :glark.upcase.should.instance_of?(Symbol) + end + + it "converts lowercase ASCII characters to their uppercase equivalents" do + :lOwEr.upcase.should == :LOWER + end + + it "capitalizes all Unicode characters" do + "äöü".to_sym.upcase.should == :"ÄÖÜ" + "aou".to_sym.upcase.should == :"AOU" + end + + it "leaves non-alphabetic ASCII characters as they were" do + "Glark?!?".to_sym.upcase.should == :"GLARK?!?" + end +end |