From 79671ec57e59091260a0bc3d40a31d31d9c72a94 Mon Sep 17 00:00:00 2001 From: Benoit Daloze Date: Sun, 28 Apr 2019 23:20:11 +0200 Subject: Update to ruby/spec@7de852d --- spec/ruby/core/argf/gets_spec.rb | 30 +- spec/ruby/core/argf/read_spec.rb | 30 +- spec/ruby/core/dir/shared/glob.rb | 8 +- spec/ruby/core/dir/shared/path.rb | 16 +- spec/ruby/core/dir/shared/pwd.rb | 20 +- spec/ruby/core/encoding/aliases_spec.rb | 60 ++- spec/ruby/core/encoding/ascii_compatible_spec.rb | 14 +- spec/ruby/core/encoding/compatible_spec.rb | 570 ++++++++++----------- .../converter/asciicompat_encoding_spec.rb | 58 +-- .../ruby/core/encoding/converter/constants_spec.rb | 182 ++++--- spec/ruby/core/encoding/converter/convert_spec.rb | 70 ++- spec/ruby/core/encoding/converter/convpath_spec.rb | 36 +- .../converter/destination_encoding_spec.rb | 14 +- spec/ruby/core/encoding/converter/finish_spec.rb | 54 +- .../core/encoding/converter/last_error_spec.rb | 154 +++--- spec/ruby/core/encoding/converter/new_spec.rb | 194 ++++--- .../encoding/converter/primitive_convert_spec.rb | 414 ++++++++------- .../encoding/converter/primitive_errinfo_spec.rb | 110 ++-- spec/ruby/core/encoding/converter/putback_spec.rb | 74 ++- .../core/encoding/converter/replacement_spec.rb | 116 +++-- .../encoding/converter/search_convpath_spec.rb | 50 +- .../encoding/converter/source_encoding_spec.rb | 14 +- spec/ruby/core/encoding/default_external_spec.rb | 94 ++-- spec/ruby/core/encoding/default_internal_spec.rb | 120 +++-- spec/ruby/core/encoding/dummy_spec.rb | 20 +- spec/ruby/core/encoding/find_spec.rb | 118 +++-- spec/ruby/core/encoding/inspect_spec.rb | 24 +- .../destination_encoding_name_spec.rb | 26 +- .../destination_encoding_spec.rb | 26 +- .../error_bytes_spec.rb | 42 +- .../incomplete_input_spec.rb | 40 +- .../readagain_bytes_spec.rb | 42 +- .../source_encoding_name_spec.rb | 44 +- .../source_encoding_spec.rb | 52 +- spec/ruby/core/encoding/list_spec.rb | 58 +-- spec/ruby/core/encoding/locale_charmap_spec.rb | 68 ++- spec/ruby/core/encoding/name_list_spec.rb | 30 +- spec/ruby/core/encoding/name_spec.rb | 6 +- spec/ruby/core/encoding/names_spec.rb | 48 +- spec/ruby/core/encoding/replicate_spec.rb | 74 ++- spec/ruby/core/encoding/to_s_spec.rb | 6 +- .../destination_encoding_name_spec.rb | 20 +- .../destination_encoding_spec.rb | 20 +- .../undefined_conversion_error/error_char_spec.rb | 38 +- .../source_encoding_name_spec.rb | 44 +- .../source_encoding_spec.rb | 46 +- spec/ruby/core/env/element_reference_spec.rb | 52 +- spec/ruby/core/env/shared/each.rb | 48 +- spec/ruby/core/env/shift_spec.rb | 50 +- spec/ruby/core/fiber/new_spec.rb | 60 ++- spec/ruby/core/fiber/resume_spec.rb | 87 ++-- spec/ruby/core/fiber/yield_spec.rb | 76 ++- spec/ruby/core/file/basename_spec.rb | 18 +- spec/ruby/core/file/expand_path_spec.rb | 54 +- spec/ruby/core/file/extname_spec.rb | 8 +- spec/ruby/core/file/open_spec.rb | 19 +- spec/ruby/core/file/shared/path.rb | 10 +- spec/ruby/core/float/to_s_spec.rb | 30 +- spec/ruby/core/integer/to_s_spec.rb | 56 +- spec/ruby/core/io/external_encoding_spec.rb | 302 ++++++----- spec/ruby/core/io/fixtures/classes.rb | 4 +- spec/ruby/core/io/foreach_spec.rb | 2 +- spec/ruby/core/io/gets_spec.rb | 8 +- spec/ruby/core/io/initialize_spec.rb | 32 +- spec/ruby/core/io/internal_encoding_spec.rb | 228 ++++----- spec/ruby/core/io/popen_spec.rb | 28 +- spec/ruby/core/io/puts_spec.rb | 32 +- spec/ruby/core/io/read_spec.rb | 206 ++++---- spec/ruby/core/io/readlines_spec.rb | 6 +- spec/ruby/core/io/reopen_spec.rb | 17 - spec/ruby/core/io/set_encoding_spec.rb | 286 +++++------ spec/ruby/core/io/shared/write.rb | 6 +- spec/ruby/core/io/write_spec.rb | 68 ++- spec/ruby/core/kernel/chomp_spec.rb | 36 +- spec/ruby/core/kernel/chop_spec.rb | 36 +- spec/ruby/core/marshal/dump_spec.rb | 46 +- spec/ruby/core/marshal/shared/load.rb | 62 ++- spec/ruby/core/matchdata/post_match_spec.rb | 16 +- spec/ruby/core/matchdata/pre_match_spec.rb | 16 +- .../ruby/core/objectspace/define_finalizer_spec.rb | 89 +--- spec/ruby/core/process/euid_spec.rb | 25 +- spec/ruby/core/process/ppid_spec.rb | 20 +- spec/ruby/core/process/setpgid_spec.rb | 3 +- spec/ruby/core/process/setsid_spec.rb | 37 +- spec/ruby/core/process/uid_spec.rb | 55 +- spec/ruby/core/process/wait2_spec.rb | 4 +- spec/ruby/core/regexp/match_spec.rb | 30 +- spec/ruby/core/string/ascii_only_spec.rb | 126 +++-- spec/ruby/core/string/b_spec.rb | 30 +- spec/ruby/core/string/bytes_spec.rb | 26 +- spec/ruby/core/string/bytesize_spec.rb | 48 +- spec/ruby/core/string/byteslice_spec.rb | 14 +- spec/ruby/core/string/center_spec.rb | 42 +- spec/ruby/core/string/chomp_spec.rb | 88 ++-- spec/ruby/core/string/chop_spec.rb | 40 +- spec/ruby/core/string/chr_spec.rb | 78 ++- spec/ruby/core/string/clear_spec.rb | 58 +-- spec/ruby/core/string/codepoints_spec.rb | 20 +- spec/ruby/core/string/downcase_spec.rb | 6 +- spec/ruby/core/string/each_codepoint_spec.rb | 8 +- spec/ruby/core/string/element_set_spec.rb | 362 +++++++------ spec/ruby/core/string/encode_spec.rb | 232 +++++---- spec/ruby/core/string/encoding_spec.rb | 364 +++++++------ spec/ruby/core/string/force_encoding_spec.rb | 106 ++-- spec/ruby/core/string/index_spec.rb | 60 +-- spec/ruby/core/string/insert_spec.rb | 32 +- spec/ruby/core/string/ljust_spec.rb | 42 +- spec/ruby/core/string/match_spec.rb | 18 +- spec/ruby/core/string/ord_spec.rb | 38 +- spec/ruby/core/string/reverse_spec.rb | 16 +- spec/ruby/core/string/rindex_spec.rb | 28 +- spec/ruby/core/string/rjust_spec.rb | 42 +- spec/ruby/core/string/shared/chars.rb | 92 ++-- spec/ruby/core/string/shared/length.rb | 22 +- spec/ruby/core/string/slice_spec.rb | 78 ++- spec/ruby/core/string/split_spec.rb | 22 +- spec/ruby/core/string/tr_s_spec.rb | 72 ++- spec/ruby/core/string/tr_spec.rb | 44 +- spec/ruby/core/string/valid_encoding_spec.rb | 236 +++++---- spec/ruby/core/thread/shared/exit.rb | 22 +- spec/ruby/core/time/_load_spec.rb | 12 +- spec/ruby/core/time/shared/inspect.rb | 6 +- spec/ruby/default.mspec | 9 - spec/ruby/language/predefined_spec.rb | 220 ++++---- spec/ruby/language/string_spec.rb | 42 +- spec/ruby/library/fiber/alive_spec.rb | 74 ++- spec/ruby/library/fiber/current_spec.rb | 80 ++- spec/ruby/library/fiber/resume_spec.rb | 16 +- spec/ruby/library/fiber/transfer_spec.rb | 136 +++-- .../library/socket/addrinfo/ip_address_spec.rb | 19 - spec/ruby/library/socket/spec_helper.rb | 4 - spec/ruby/library/stringio/getch_spec.rb | 16 +- spec/ruby/optional/capi/io_spec.rb | 8 +- spec/ruby/shared/string/times.rb | 10 +- spec/ruby/shared/time/strftime_for_date.rb | 10 +- 135 files changed, 4183 insertions(+), 4653 deletions(-) (limited to 'spec/ruby') diff --git a/spec/ruby/core/argf/gets_spec.rb b/spec/ruby/core/argf/gets_spec.rb index 5863147ec8..cc7673b190 100644 --- a/spec/ruby/core/argf/gets_spec.rb +++ b/spec/ruby/core/argf/gets_spec.rb @@ -26,25 +26,23 @@ describe "ARGF.gets" do end end - with_feature :encoding do - before :each do - @external = Encoding.default_external - @internal = Encoding.default_internal + before :each do + @external = Encoding.default_external + @internal = Encoding.default_internal - Encoding.default_external = Encoding::UTF_8 - Encoding.default_internal = nil - end + Encoding.default_external = Encoding::UTF_8 + Encoding.default_internal = nil + end - after :each do - Encoding.default_external = @external - Encoding.default_internal = @internal - end + after :each do + Encoding.default_external = @external + Encoding.default_internal = @internal + end - it "reads the contents of the file with default encoding" do - Encoding.default_external = Encoding::US_ASCII - argf [@file1_name, @file2_name] do - @argf.gets.encoding.should == Encoding::US_ASCII - end + it "reads the contents of the file with default encoding" do + Encoding.default_external = Encoding::US_ASCII + argf [@file1_name, @file2_name] do + @argf.gets.encoding.should == Encoding::US_ASCII end end diff --git a/spec/ruby/core/argf/read_spec.rb b/spec/ruby/core/argf/read_spec.rb index b889605572..bbeef95456 100644 --- a/spec/ruby/core/argf/read_spec.rb +++ b/spec/ruby/core/argf/read_spec.rb @@ -62,26 +62,24 @@ describe "ARGF.read" do end end - with_feature :encoding do - before :each do - @external = Encoding.default_external - @internal = Encoding.default_internal + before :each do + @external = Encoding.default_external + @internal = Encoding.default_internal - Encoding.default_external = Encoding::UTF_8 - Encoding.default_internal = nil - end + Encoding.default_external = Encoding::UTF_8 + Encoding.default_internal = nil + end - after :each do - Encoding.default_external = @external - Encoding.default_internal = @internal - end + after :each do + Encoding.default_external = @external + Encoding.default_internal = @internal + end - it "reads the contents of the file with default encoding" do - Encoding.default_external = Encoding::US_ASCII - argf [@file1_name, @file2_name] do - @argf.read.encoding.should == Encoding::US_ASCII - end + it "reads the contents of the file with default encoding" do + Encoding.default_external = Encoding::US_ASCII + argf [@file1_name, @file2_name] do + @argf.read.encoding.should == Encoding::US_ASCII end end end diff --git a/spec/ruby/core/dir/shared/glob.rb b/spec/ruby/core/dir/shared/glob.rb index 19f457e22a..af587dd33b 100644 --- a/spec/ruby/core/dir/shared/glob.rb +++ b/spec/ruby/core/dir/shared/glob.rb @@ -11,11 +11,9 @@ describe :dir_glob, shared: true do DirSpecs.delete_mock_dirs end - with_feature :encoding do - it "raises an Encoding::CompatibilityError if the argument encoding is not compatible with US-ASCII" do - pattern = "file*".force_encoding Encoding::UTF_16BE - lambda { Dir.send(@method, pattern) }.should raise_error(Encoding::CompatibilityError) - end + it "raises an Encoding::CompatibilityError if the argument encoding is not compatible with US-ASCII" do + pattern = "file*".force_encoding Encoding::UTF_16BE + lambda { Dir.send(@method, pattern) }.should raise_error(Encoding::CompatibilityError) end it "calls #to_path to convert a pattern" do diff --git a/spec/ruby/core/dir/shared/path.rb b/spec/ruby/core/dir/shared/path.rb index fe2d61ebf7..494dcca775 100644 --- a/spec/ruby/core/dir/shared/path.rb +++ b/spec/ruby/core/dir/shared/path.rb @@ -18,15 +18,13 @@ describe :dir_path, shared: true do dir.send(@method).should == DirSpecs.mock_dir end - with_feature :encoding do - it "returns a String with the same encoding as the argument to .open" do - path = DirSpecs.mock_dir.force_encoding Encoding::IBM866 - dir = Dir.open path - begin - dir.send(@method).encoding.should equal(Encoding::IBM866) - ensure - dir.close - end + it "returns a String with the same encoding as the argument to .open" do + path = DirSpecs.mock_dir.force_encoding Encoding::IBM866 + dir = Dir.open path + begin + dir.send(@method).encoding.should equal(Encoding::IBM866) + ensure + dir.close end end end diff --git a/spec/ruby/core/dir/shared/pwd.rb b/spec/ruby/core/dir/shared/pwd.rb index 5f041a9d41..94fc2fa7fb 100644 --- a/spec/ruby/core/dir/shared/pwd.rb +++ b/spec/ruby/core/dir/shared/pwd.rb @@ -1,8 +1,6 @@ describe :dir_pwd, shared: true do - with_feature :encoding do - before :each do - @fs_encoding = Encoding.find('filesystem') - end + before :each do + @fs_encoding = Encoding.find('filesystem') end it "returns the current working directory" do @@ -36,14 +34,12 @@ describe :dir_pwd, shared: true do end end - with_feature :encoding do - it "returns a String with the filesystem encoding" do - enc = Dir.send(@method).encoding - if @fs_encoding == Encoding::US_ASCII - [Encoding::US_ASCII, Encoding::ASCII_8BIT].should include(enc) - else - enc.should equal(@fs_encoding) - end + it "returns a String with the filesystem encoding" do + enc = Dir.send(@method).encoding + if @fs_encoding == Encoding::US_ASCII + [Encoding::US_ASCII, Encoding::ASCII_8BIT].should include(enc) + else + enc.should equal(@fs_encoding) end end end diff --git a/spec/ruby/core/encoding/aliases_spec.rb b/spec/ruby/core/encoding/aliases_spec.rb index 22e4510993..786157981a 100644 --- a/spec/ruby/core/encoding/aliases_spec.rb +++ b/spec/ruby/core/encoding/aliases_spec.rb @@ -1,45 +1,43 @@ require_relative '../../spec_helper' -with_feature :encoding do - describe "Encoding.aliases" do - it "returns a Hash" do - Encoding.aliases.should be_an_instance_of(Hash) - end +describe "Encoding.aliases" do + it "returns a Hash" do + Encoding.aliases.should be_an_instance_of(Hash) + end - it "has Strings as keys" do - Encoding.aliases.keys.each do |key| - key.should be_an_instance_of(String) - end + it "has Strings as keys" do + Encoding.aliases.keys.each do |key| + key.should be_an_instance_of(String) end + end - it "has Strings as values" do - Encoding.aliases.values.each do |value| - value.should be_an_instance_of(String) - end + it "has Strings as values" do + Encoding.aliases.values.each do |value| + value.should be_an_instance_of(String) end + end - it "has alias names as its keys" do - Encoding.aliases.key?('BINARY').should be_true - Encoding.aliases.key?('ASCII').should be_true - end + it "has alias names as its keys" do + Encoding.aliases.key?('BINARY').should be_true + Encoding.aliases.key?('ASCII').should be_true + end - it "has the names of the aliased encoding as its values" do - Encoding.aliases['BINARY'].should == 'ASCII-8BIT' - Encoding.aliases['ASCII'].should == 'US-ASCII' - end + it "has the names of the aliased encoding as its values" do + Encoding.aliases['BINARY'].should == 'ASCII-8BIT' + Encoding.aliases['ASCII'].should == 'US-ASCII' + end - it "has an 'external' key with the external default encoding as its value" do - Encoding.aliases['external'].should == Encoding.default_external.name - end + it "has an 'external' key with the external default encoding as its value" do + Encoding.aliases['external'].should == Encoding.default_external.name + end - it "has a 'locale' key and its value equals the name of the encoding found by the locale charmap" do - Encoding.aliases['locale'].should == Encoding.find(Encoding.locale_charmap).name - end + it "has a 'locale' key and its value equals the name of the encoding found by the locale charmap" do + Encoding.aliases['locale'].should == Encoding.find(Encoding.locale_charmap).name + end - it "only contains valid aliased encodings" do - Encoding.aliases.each do |aliased, original| - Encoding.find(aliased).should == Encoding.find(original) - end + it "only contains valid aliased encodings" do + Encoding.aliases.each do |aliased, original| + Encoding.find(aliased).should == Encoding.find(original) end end end diff --git a/spec/ruby/core/encoding/ascii_compatible_spec.rb b/spec/ruby/core/encoding/ascii_compatible_spec.rb index 31ac75302e..4804300e85 100644 --- a/spec/ruby/core/encoding/ascii_compatible_spec.rb +++ b/spec/ruby/core/encoding/ascii_compatible_spec.rb @@ -1,13 +1,11 @@ require_relative '../../spec_helper' -with_feature :encoding do - describe "Encoding#ascii_compatible?" do - it "returns true if self represents an ASCII-compatible encoding" do - Encoding::UTF_8.ascii_compatible?.should be_true - end +describe "Encoding#ascii_compatible?" do + it "returns true if self represents an ASCII-compatible encoding" do + Encoding::UTF_8.ascii_compatible?.should be_true + end - it "returns false if self does not represent an ASCII-compatible encoding" do - Encoding::UTF_16LE.ascii_compatible?.should be_false - end + it "returns false if self does not represent an ASCII-compatible encoding" do + Encoding::UTF_16LE.ascii_compatible?.should be_false end end diff --git a/spec/ruby/core/encoding/compatible_spec.rb b/spec/ruby/core/encoding/compatible_spec.rb index f35120325c..8c2e4d7e09 100644 --- a/spec/ruby/core/encoding/compatible_spec.rb +++ b/spec/ruby/core/encoding/compatible_spec.rb @@ -2,380 +2,378 @@ require_relative '../../spec_helper' -with_feature :encoding do - # TODO: add IO +# TODO: add IO - describe "Encoding.compatible? String, String" do - describe "when the first's Encoding is valid US-ASCII" do - before :each do - @str = "abc".force_encoding Encoding::US_ASCII - end - - it "returns US-ASCII when the second's is US-ASCII" do - Encoding.compatible?(@str, "def".encode("us-ascii")).should == Encoding::US_ASCII - end - - it "returns US-ASCII if the second String is ASCII-8BIT and ASCII only" do - Encoding.compatible?(@str, "\x7f").should == Encoding::US_ASCII - end +describe "Encoding.compatible? String, String" do + describe "when the first's Encoding is valid US-ASCII" do + before :each do + @str = "abc".force_encoding Encoding::US_ASCII + end - it "returns ASCII-8BIT if the second String is ASCII-8BIT but not ASCII only" do - Encoding.compatible?(@str, "\xff").should == Encoding::ASCII_8BIT - end + it "returns US-ASCII when the second's is US-ASCII" do + Encoding.compatible?(@str, "def".encode("us-ascii")).should == Encoding::US_ASCII + end - it "returns US-ASCII if the second String is UTF-8 and ASCII only" do - Encoding.compatible?(@str, "\x7f".encode("utf-8")).should == Encoding::US_ASCII - end + it "returns US-ASCII if the second String is ASCII-8BIT and ASCII only" do + Encoding.compatible?(@str, "\x7f").should == Encoding::US_ASCII + end - it "returns UTF-8 if the second String is UTF-8 but not ASCII only" do - Encoding.compatible?(@str, "\u3042".encode("utf-8")).should == Encoding::UTF_8 - end + it "returns ASCII-8BIT if the second String is ASCII-8BIT but not ASCII only" do + Encoding.compatible?(@str, "\xff").should == Encoding::ASCII_8BIT end - describe "when the first's Encoding is ASCII compatible and ASCII only" do - it "returns the first's Encoding if the second is ASCII compatible and ASCII only" do - [ [Encoding, "abc".force_encoding("UTF-8"), "123".force_encoding("Shift_JIS"), Encoding::UTF_8], - [Encoding, "123".force_encoding("Shift_JIS"), "abc".force_encoding("UTF-8"), Encoding::Shift_JIS] - ].should be_computed_by(:compatible?) - end + it "returns US-ASCII if the second String is UTF-8 and ASCII only" do + Encoding.compatible?(@str, "\x7f".encode("utf-8")).should == Encoding::US_ASCII + end - it "returns the first's Encoding if the second is ASCII compatible and ASCII only" do - [ [Encoding, "abc".force_encoding("ASCII-8BIT"), "123".force_encoding("US-ASCII"), Encoding::ASCII_8BIT], - [Encoding, "123".force_encoding("US-ASCII"), "abc".force_encoding("ASCII-8BIT"), Encoding::US_ASCII] - ].should be_computed_by(:compatible?) - end + it "returns UTF-8 if the second String is UTF-8 but not ASCII only" do + Encoding.compatible?(@str, "\u3042".encode("utf-8")).should == Encoding::UTF_8 + end + end - it "returns the second's Encoding if the second is ASCII compatible but not ASCII only" do - [ [Encoding, "abc".force_encoding("UTF-8"), "\xff".force_encoding("Shift_JIS"), Encoding::Shift_JIS], - [Encoding, "123".force_encoding("Shift_JIS"), "\xff".force_encoding("UTF-8"), Encoding::UTF_8], - [Encoding, "abc".force_encoding("ASCII-8BIT"), "\xff".force_encoding("US-ASCII"), Encoding::US_ASCII], - [Encoding, "123".force_encoding("US-ASCII"), "\xff".force_encoding("ASCII-8BIT"), Encoding::ASCII_8BIT], - ].should be_computed_by(:compatible?) - end + describe "when the first's Encoding is ASCII compatible and ASCII only" do + it "returns the first's Encoding if the second is ASCII compatible and ASCII only" do + [ [Encoding, "abc".force_encoding("UTF-8"), "123".force_encoding("Shift_JIS"), Encoding::UTF_8], + [Encoding, "123".force_encoding("Shift_JIS"), "abc".force_encoding("UTF-8"), Encoding::Shift_JIS] + ].should be_computed_by(:compatible?) + end - it "returns nil if the second's Encoding is not ASCII compatible" do - a = "abc".force_encoding("UTF-8") - b = "123".force_encoding("UTF-16LE") - Encoding.compatible?(a, b).should be_nil - end + it "returns the first's Encoding if the second is ASCII compatible and ASCII only" do + [ [Encoding, "abc".force_encoding("ASCII-8BIT"), "123".force_encoding("US-ASCII"), Encoding::ASCII_8BIT], + [Encoding, "123".force_encoding("US-ASCII"), "abc".force_encoding("ASCII-8BIT"), Encoding::US_ASCII] + ].should be_computed_by(:compatible?) end - describe "when the first's Encoding is ASCII compatible but not ASCII only" do - it "returns the first's Encoding if the second's is valid US-ASCII" do - Encoding.compatible?("\xff", "def".encode("us-ascii")).should == Encoding::ASCII_8BIT - end + it "returns the second's Encoding if the second is ASCII compatible but not ASCII only" do + [ [Encoding, "abc".force_encoding("UTF-8"), "\xff".force_encoding("Shift_JIS"), Encoding::Shift_JIS], + [Encoding, "123".force_encoding("Shift_JIS"), "\xff".force_encoding("UTF-8"), Encoding::UTF_8], + [Encoding, "abc".force_encoding("ASCII-8BIT"), "\xff".force_encoding("US-ASCII"), Encoding::US_ASCII], + [Encoding, "123".force_encoding("US-ASCII"), "\xff".force_encoding("ASCII-8BIT"), Encoding::ASCII_8BIT], + ].should be_computed_by(:compatible?) + end - it "returns the first's Encoding if the second's is UTF-8 and ASCII only" do - Encoding.compatible?("\xff", "\u{7f}".encode("utf-8")).should == Encoding::ASCII_8BIT - end + it "returns nil if the second's Encoding is not ASCII compatible" do + a = "abc".force_encoding("UTF-8") + b = "123".force_encoding("UTF-16LE") + Encoding.compatible?(a, b).should be_nil + end + end - it "returns nil if the second encoding is ASCII compatible but neither String's encoding is ASCII only" do - Encoding.compatible?("\xff", "\u3042".encode("utf-8")).should be_nil - end + describe "when the first's Encoding is ASCII compatible but not ASCII only" do + it "returns the first's Encoding if the second's is valid US-ASCII" do + Encoding.compatible?("\xff", "def".encode("us-ascii")).should == Encoding::ASCII_8BIT end - describe "when the first's Encoding is not ASCII compatible" do - before :each do - @str = "abc".force_encoding Encoding::UTF_7 - end + it "returns the first's Encoding if the second's is UTF-8 and ASCII only" do + Encoding.compatible?("\xff", "\u{7f}".encode("utf-8")).should == Encoding::ASCII_8BIT + end - it "returns nil when the second String is US-ASCII" do - Encoding.compatible?(@str, "def".encode("us-ascii")).should be_nil - end + it "returns nil if the second encoding is ASCII compatible but neither String's encoding is ASCII only" do + Encoding.compatible?("\xff", "\u3042".encode("utf-8")).should be_nil + end + end - it "returns nil when the second String is ASCII-8BIT and ASCII only" do - Encoding.compatible?(@str, "\x7f").should be_nil - end + describe "when the first's Encoding is not ASCII compatible" do + before :each do + @str = "abc".force_encoding Encoding::UTF_7 + end - it "returns nil when the second String is ASCII-8BIT but not ASCII only" do - Encoding.compatible?(@str, "\xff").should be_nil - end + it "returns nil when the second String is US-ASCII" do + Encoding.compatible?(@str, "def".encode("us-ascii")).should be_nil + end - it "returns the Encoding when the second's Encoding is not ASCII compatible but the same as the first's Encoding" do - encoding = Encoding.compatible?(@str, "def".force_encoding("utf-7")) - encoding.should == Encoding::UTF_7 - end + it "returns nil when the second String is ASCII-8BIT and ASCII only" do + Encoding.compatible?(@str, "\x7f").should be_nil end - describe "when the first's Encoding is invalid" do - before :each do - @str = "\xff".force_encoding Encoding::UTF_8 - end + it "returns nil when the second String is ASCII-8BIT but not ASCII only" do + Encoding.compatible?(@str, "\xff").should be_nil + end - it "returns the first's Encoding when the second's Encoding is US-ASCII" do - Encoding.compatible?(@str, "def".encode("us-ascii")).should == Encoding::UTF_8 - end + it "returns the Encoding when the second's Encoding is not ASCII compatible but the same as the first's Encoding" do + encoding = Encoding.compatible?(@str, "def".force_encoding("utf-7")) + encoding.should == Encoding::UTF_7 + end + end - it "returns the first's Encoding when the second String is ASCII only" do - Encoding.compatible?(@str, "\x7f").should == Encoding::UTF_8 - end + describe "when the first's Encoding is invalid" do + before :each do + @str = "\xff".force_encoding Encoding::UTF_8 + end - it "returns nil when the second's Encoding is ASCII-8BIT but not ASCII only" do - Encoding.compatible?(@str, "\xff").should be_nil - end + it "returns the first's Encoding when the second's Encoding is US-ASCII" do + Encoding.compatible?(@str, "def".encode("us-ascii")).should == Encoding::UTF_8 + end - it "returns nil when the second's Encoding is invalid and ASCII only" do - Encoding.compatible?(@str, "\x7f".force_encoding("utf-16be")).should be_nil - end + it "returns the first's Encoding when the second String is ASCII only" do + Encoding.compatible?(@str, "\x7f").should == Encoding::UTF_8 + end - it "returns nil when the second's Encoding is invalid and not ASCII only" do - Encoding.compatible?(@str, "\xff".force_encoding("utf-16be")).should be_nil - end + it "returns nil when the second's Encoding is ASCII-8BIT but not ASCII only" do + Encoding.compatible?(@str, "\xff").should be_nil + end - it "returns the Encoding when the second's Encoding is invalid but the same as the first" do - Encoding.compatible?(@str, @str).should == Encoding::UTF_8 - end + it "returns nil when the second's Encoding is invalid and ASCII only" do + Encoding.compatible?(@str, "\x7f".force_encoding("utf-16be")).should be_nil end - describe "when the first String is empty and the second is not" do - describe "and the first's Encoding is ASCII compatible" do - before :each do - @str = "".force_encoding("utf-8") - end + it "returns nil when the second's Encoding is invalid and not ASCII only" do + Encoding.compatible?(@str, "\xff".force_encoding("utf-16be")).should be_nil + end - it "returns the first's encoding when the second String is ASCII only" do - Encoding.compatible?(@str, "def".encode("us-ascii")).should == Encoding::UTF_8 - end + it "returns the Encoding when the second's Encoding is invalid but the same as the first" do + Encoding.compatible?(@str, @str).should == Encoding::UTF_8 + end + end - it "returns the second's encoding when the second String is not ASCII only" do - Encoding.compatible?(@str, "def".encode("utf-32le")).should == Encoding::UTF_32LE - end + describe "when the first String is empty and the second is not" do + describe "and the first's Encoding is ASCII compatible" do + before :each do + @str = "".force_encoding("utf-8") end - describe "when the first's Encoding is not ASCII compatible" do - before :each do - @str = "".force_encoding Encoding::UTF_7 - end + it "returns the first's encoding when the second String is ASCII only" do + Encoding.compatible?(@str, "def".encode("us-ascii")).should == Encoding::UTF_8 + end - it "returns the second string's encoding" do - Encoding.compatible?(@str, "def".encode("us-ascii")).should == Encoding::US_ASCII - end + it "returns the second's encoding when the second String is not ASCII only" do + Encoding.compatible?(@str, "def".encode("utf-32le")).should == Encoding::UTF_32LE end end - describe "when the second String is empty" do + describe "when the first's Encoding is not ASCII compatible" do before :each do - @str = "abc".force_encoding("utf-7") + @str = "".force_encoding Encoding::UTF_7 end - it "returns the first Encoding" do - Encoding.compatible?(@str, "").should == Encoding::UTF_7 + it "returns the second string's encoding" do + Encoding.compatible?(@str, "def".encode("us-ascii")).should == Encoding::US_ASCII end end end - describe "Encoding.compatible? String, Regexp" do - it "returns US-ASCII if both are US-ASCII" do - str = "abc".force_encoding("us-ascii") - Encoding.compatible?(str, /abc/).should == Encoding::US_ASCII + describe "when the second String is empty" do + before :each do + @str = "abc".force_encoding("utf-7") end - it "returns the String's Encoding if it is not US-ASCII but both are ASCII only" do - [ [Encoding, "abc", Encoding::ASCII_8BIT], - [Encoding, "abc".encode("utf-8"), Encoding::UTF_8], - [Encoding, "abc".encode("euc-jp"), Encoding::EUC_JP], - [Encoding, "abc".encode("shift_jis"), Encoding::Shift_JIS], - ].should be_computed_by(:compatible?, /abc/) + it "returns the first Encoding" do + Encoding.compatible?(@str, "").should == Encoding::UTF_7 end + end +end - it "returns the String's Encoding if the String is not ASCII only" do - [ [Encoding, "\xff", Encoding::ASCII_8BIT], - [Encoding, "\u3042".encode("utf-8"), Encoding::UTF_8], - [Encoding, "\xa4\xa2".force_encoding("euc-jp"), Encoding::EUC_JP], - [Encoding, "\x82\xa0".force_encoding("shift_jis"), Encoding::Shift_JIS], - ].should be_computed_by(:compatible?, /abc/) - end +describe "Encoding.compatible? String, Regexp" do + it "returns US-ASCII if both are US-ASCII" do + str = "abc".force_encoding("us-ascii") + Encoding.compatible?(str, /abc/).should == Encoding::US_ASCII end - describe "Encoding.compatible? String, Symbol" do - it "returns US-ASCII if both are ASCII only" do - str = "abc".force_encoding("us-ascii") - Encoding.compatible?(str, :abc).should == Encoding::US_ASCII - end + it "returns the String's Encoding if it is not US-ASCII but both are ASCII only" do + [ [Encoding, "abc", Encoding::ASCII_8BIT], + [Encoding, "abc".encode("utf-8"), Encoding::UTF_8], + [Encoding, "abc".encode("euc-jp"), Encoding::EUC_JP], + [Encoding, "abc".encode("shift_jis"), Encoding::Shift_JIS], + ].should be_computed_by(:compatible?, /abc/) + end - it "returns the String's Encoding if it is not US-ASCII but both are ASCII only" do - [ [Encoding, "abc", Encoding::ASCII_8BIT], - [Encoding, "abc".encode("utf-8"), Encoding::UTF_8], - [Encoding, "abc".encode("euc-jp"), Encoding::EUC_JP], - [Encoding, "abc".encode("shift_jis"), Encoding::Shift_JIS], - ].should be_computed_by(:compatible?, :abc) - end + it "returns the String's Encoding if the String is not ASCII only" do + [ [Encoding, "\xff", Encoding::ASCII_8BIT], + [Encoding, "\u3042".encode("utf-8"), Encoding::UTF_8], + [Encoding, "\xa4\xa2".force_encoding("euc-jp"), Encoding::EUC_JP], + [Encoding, "\x82\xa0".force_encoding("shift_jis"), Encoding::Shift_JIS], + ].should be_computed_by(:compatible?, /abc/) + end +end - it "returns the String's Encoding if the String is not ASCII only" do - [ [Encoding, "\xff", Encoding::ASCII_8BIT], - [Encoding, "\u3042".encode("utf-8"), Encoding::UTF_8], - [Encoding, "\xa4\xa2".force_encoding("euc-jp"), Encoding::EUC_JP], - [Encoding, "\x82\xa0".force_encoding("shift_jis"), Encoding::Shift_JIS], - ].should be_computed_by(:compatible?, :abc) - end +describe "Encoding.compatible? String, Symbol" do + it "returns US-ASCII if both are ASCII only" do + str = "abc".force_encoding("us-ascii") + Encoding.compatible?(str, :abc).should == Encoding::US_ASCII end - describe "Encoding.compatible? String, Encoding" do - it "returns nil if the String's encoding is not ASCII compatible" do - Encoding.compatible?("abc".encode("utf-32le"), Encoding::US_ASCII).should be_nil - end + it "returns the String's Encoding if it is not US-ASCII but both are ASCII only" do + [ [Encoding, "abc", Encoding::ASCII_8BIT], + [Encoding, "abc".encode("utf-8"), Encoding::UTF_8], + [Encoding, "abc".encode("euc-jp"), Encoding::EUC_JP], + [Encoding, "abc".encode("shift_jis"), Encoding::Shift_JIS], + ].should be_computed_by(:compatible?, :abc) + end - it "returns nil if the Encoding is not ASCII compatible" do - Encoding.compatible?("abc".encode("us-ascii"), Encoding::UTF_32LE).should be_nil - end + it "returns the String's Encoding if the String is not ASCII only" do + [ [Encoding, "\xff", Encoding::ASCII_8BIT], + [Encoding, "\u3042".encode("utf-8"), Encoding::UTF_8], + [Encoding, "\xa4\xa2".force_encoding("euc-jp"), Encoding::EUC_JP], + [Encoding, "\x82\xa0".force_encoding("shift_jis"), Encoding::Shift_JIS], + ].should be_computed_by(:compatible?, :abc) + end +end - it "returns the String's encoding if the Encoding is US-ASCII" do - [ [Encoding, "\xff", Encoding::ASCII_8BIT], - [Encoding, "\u3042".encode("utf-8"), Encoding::UTF_8], - [Encoding, "\xa4\xa2".force_encoding("euc-jp"), Encoding::EUC_JP], - [Encoding, "\x82\xa0".force_encoding("shift_jis"), Encoding::Shift_JIS], - ].should be_computed_by(:compatible?, Encoding::US_ASCII) - end +describe "Encoding.compatible? String, Encoding" do + it "returns nil if the String's encoding is not ASCII compatible" do + Encoding.compatible?("abc".encode("utf-32le"), Encoding::US_ASCII).should be_nil + end - it "returns the Encoding if the String's encoding is ASCII compatible and the String is ASCII only" do - str = "abc".encode("utf-8") + it "returns nil if the Encoding is not ASCII compatible" do + Encoding.compatible?("abc".encode("us-ascii"), Encoding::UTF_32LE).should be_nil + end - Encoding.compatible?(str, Encoding::ASCII_8BIT).should == Encoding::ASCII_8BIT - Encoding.compatible?(str, Encoding::UTF_8).should == Encoding::UTF_8 - Encoding.compatible?(str, Encoding::EUC_JP).should == Encoding::EUC_JP - Encoding.compatible?(str, Encoding::Shift_JIS).should == Encoding::Shift_JIS - end + it "returns the String's encoding if the Encoding is US-ASCII" do + [ [Encoding, "\xff", Encoding::ASCII_8BIT], + [Encoding, "\u3042".encode("utf-8"), Encoding::UTF_8], + [Encoding, "\xa4\xa2".force_encoding("euc-jp"), Encoding::EUC_JP], + [Encoding, "\x82\xa0".force_encoding("shift_jis"), Encoding::Shift_JIS], + ].should be_computed_by(:compatible?, Encoding::US_ASCII) + end - it "returns nil if the String's encoding is ASCII compatible but the string is not ASCII only" do - Encoding.compatible?("\u3042".encode("utf-8"), Encoding::ASCII_8BIT).should be_nil - end + it "returns the Encoding if the String's encoding is ASCII compatible and the String is ASCII only" do + str = "abc".encode("utf-8") + + Encoding.compatible?(str, Encoding::ASCII_8BIT).should == Encoding::ASCII_8BIT + Encoding.compatible?(str, Encoding::UTF_8).should == Encoding::UTF_8 + Encoding.compatible?(str, Encoding::EUC_JP).should == Encoding::EUC_JP + Encoding.compatible?(str, Encoding::Shift_JIS).should == Encoding::Shift_JIS end - describe "Encoding.compatible? Regexp, String" do - it "returns US-ASCII if both are US-ASCII" do - str = "abc".force_encoding("us-ascii") - Encoding.compatible?(/abc/, str).should == Encoding::US_ASCII - end + it "returns nil if the String's encoding is ASCII compatible but the string is not ASCII only" do + Encoding.compatible?("\u3042".encode("utf-8"), Encoding::ASCII_8BIT).should be_nil + end +end +describe "Encoding.compatible? Regexp, String" do + it "returns US-ASCII if both are US-ASCII" do + str = "abc".force_encoding("us-ascii") + Encoding.compatible?(/abc/, str).should == Encoding::US_ASCII end - describe "Encoding.compatible? Regexp, Regexp" do - it "returns US-ASCII if both are US-ASCII" do - Encoding.compatible?(/abc/, /def/).should == Encoding::US_ASCII - end +end - it "returns the first's Encoding if it is not US-ASCII and not ASCII only" do - [ [Encoding, Regexp.new("\xff"), Encoding::ASCII_8BIT], - [Encoding, Regexp.new("\u3042".encode("utf-8")), Encoding::UTF_8], - [Encoding, Regexp.new("\xa4\xa2".force_encoding("euc-jp")), Encoding::EUC_JP], - [Encoding, Regexp.new("\x82\xa0".force_encoding("shift_jis")), Encoding::Shift_JIS], - ].should be_computed_by(:compatible?, /abc/) - end +describe "Encoding.compatible? Regexp, Regexp" do + it "returns US-ASCII if both are US-ASCII" do + Encoding.compatible?(/abc/, /def/).should == Encoding::US_ASCII end - describe "Encoding.compatible? Regexp, Symbol" do - it "returns US-ASCII if both are US-ASCII" do - Encoding.compatible?(/abc/, :def).should == Encoding::US_ASCII - end + it "returns the first's Encoding if it is not US-ASCII and not ASCII only" do + [ [Encoding, Regexp.new("\xff"), Encoding::ASCII_8BIT], + [Encoding, Regexp.new("\u3042".encode("utf-8")), Encoding::UTF_8], + [Encoding, Regexp.new("\xa4\xa2".force_encoding("euc-jp")), Encoding::EUC_JP], + [Encoding, Regexp.new("\x82\xa0".force_encoding("shift_jis")), Encoding::Shift_JIS], + ].should be_computed_by(:compatible?, /abc/) + end +end - it "returns the first's Encoding if it is not US-ASCII and not ASCII only" do - [ [Encoding, Regexp.new("\xff"), Encoding::ASCII_8BIT], - [Encoding, Regexp.new("\u3042".encode("utf-8")), Encoding::UTF_8], - [Encoding, Regexp.new("\xa4\xa2".force_encoding("euc-jp")), Encoding::EUC_JP], - [Encoding, Regexp.new("\x82\xa0".force_encoding("shift_jis")), Encoding::Shift_JIS], - ].should be_computed_by(:compatible?, /abc/) - end +describe "Encoding.compatible? Regexp, Symbol" do + it "returns US-ASCII if both are US-ASCII" do + Encoding.compatible?(/abc/, :def).should == Encoding::US_ASCII end - describe "Encoding.compatible? Symbol, String" do - it "returns US-ASCII if both are ASCII only" do - str = "abc".force_encoding("us-ascii") - Encoding.compatible?(str, :abc).should == Encoding::US_ASCII - end + it "returns the first's Encoding if it is not US-ASCII and not ASCII only" do + [ [Encoding, Regexp.new("\xff"), Encoding::ASCII_8BIT], + [Encoding, Regexp.new("\u3042".encode("utf-8")), Encoding::UTF_8], + [Encoding, Regexp.new("\xa4\xa2".force_encoding("euc-jp")), Encoding::EUC_JP], + [Encoding, Regexp.new("\x82\xa0".force_encoding("shift_jis")), Encoding::Shift_JIS], + ].should be_computed_by(:compatible?, /abc/) end +end - describe "Encoding.compatible? Symbol, Regexp" do - it "returns US-ASCII if both are US-ASCII" do - Encoding.compatible?(:abc, /def/).should == Encoding::US_ASCII - end +describe "Encoding.compatible? Symbol, String" do + it "returns US-ASCII if both are ASCII only" do + str = "abc".force_encoding("us-ascii") + Encoding.compatible?(str, :abc).should == Encoding::US_ASCII + end +end - it "returns the Regexp's Encoding if it is not US-ASCII and not ASCII only" do - a = Regexp.new("\xff") - b = Regexp.new("\u3042".encode("utf-8")) - c = Regexp.new("\xa4\xa2".force_encoding("euc-jp")) - d = Regexp.new("\x82\xa0".force_encoding("shift_jis")) +describe "Encoding.compatible? Symbol, Regexp" do + it "returns US-ASCII if both are US-ASCII" do + Encoding.compatible?(:abc, /def/).should == Encoding::US_ASCII + end - [ [Encoding, :abc, a, Encoding::ASCII_8BIT], - [Encoding, :abc, b, Encoding::UTF_8], - [Encoding, :abc, c, Encoding::EUC_JP], - [Encoding, :abc, d, Encoding::Shift_JIS], - ].should be_computed_by(:compatible?) - end + it "returns the Regexp's Encoding if it is not US-ASCII and not ASCII only" do + a = Regexp.new("\xff") + b = Regexp.new("\u3042".encode("utf-8")) + c = Regexp.new("\xa4\xa2".force_encoding("euc-jp")) + d = Regexp.new("\x82\xa0".force_encoding("shift_jis")) + + [ [Encoding, :abc, a, Encoding::ASCII_8BIT], + [Encoding, :abc, b, Encoding::UTF_8], + [Encoding, :abc, c, Encoding::EUC_JP], + [Encoding, :abc, d, Encoding::Shift_JIS], + ].should be_computed_by(:compatible?) end +end - describe "Encoding.compatible? Symbol, Symbol" do - it "returns US-ASCII if both are US-ASCII" do - Encoding.compatible?(:abc, :def).should == Encoding::US_ASCII - end +describe "Encoding.compatible? Symbol, Symbol" do + it "returns US-ASCII if both are US-ASCII" do + Encoding.compatible?(:abc, :def).should == Encoding::US_ASCII + end - it "returns the first's Encoding if it is not ASCII only" do - [ [Encoding, "\xff".to_sym, Encoding::ASCII_8BIT], - [Encoding, "\u3042".encode("utf-8").to_sym, Encoding::UTF_8], - [Encoding, "\xa4\xa2".force_encoding("euc-jp").to_sym, Encoding::EUC_JP], - [Encoding, "\x82\xa0".force_encoding("shift_jis").to_sym, Encoding::Shift_JIS], - ].should be_computed_by(:compatible?, :abc) - end + it "returns the first's Encoding if it is not ASCII only" do + [ [Encoding, "\xff".to_sym, Encoding::ASCII_8BIT], + [Encoding, "\u3042".encode("utf-8").to_sym, Encoding::UTF_8], + [Encoding, "\xa4\xa2".force_encoding("euc-jp").to_sym, Encoding::EUC_JP], + [Encoding, "\x82\xa0".force_encoding("shift_jis").to_sym, Encoding::Shift_JIS], + ].should be_computed_by(:compatible?, :abc) end +end - describe "Encoding.compatible? Encoding, Encoding" do - it "returns nil if one of the encodings is a dummy encoding" do - [ [Encoding, Encoding::UTF_7, Encoding::US_ASCII, nil], - [Encoding, Encoding::US_ASCII, Encoding::UTF_7, nil], - [Encoding, Encoding::EUC_JP, Encoding::UTF_7, nil], - [Encoding, Encoding::UTF_7, Encoding::EUC_JP, nil], - [Encoding, Encoding::UTF_7, Encoding::ASCII_8BIT, nil], - [Encoding, Encoding::ASCII_8BIT, Encoding::UTF_7, nil], - ].should be_computed_by(:compatible?) - end +describe "Encoding.compatible? Encoding, Encoding" do + it "returns nil if one of the encodings is a dummy encoding" do + [ [Encoding, Encoding::UTF_7, Encoding::US_ASCII, nil], + [Encoding, Encoding::US_ASCII, Encoding::UTF_7, nil], + [Encoding, Encoding::EUC_JP, Encoding::UTF_7, nil], + [Encoding, Encoding::UTF_7, Encoding::EUC_JP, nil], + [Encoding, Encoding::UTF_7, Encoding::ASCII_8BIT, nil], + [Encoding, Encoding::ASCII_8BIT, Encoding::UTF_7, nil], + ].should be_computed_by(:compatible?) + end - it "returns nil if one of the encodings is not US-ASCII" do - [ [Encoding, Encoding::UTF_8, Encoding::ASCII_8BIT, nil], - [Encoding, Encoding::ASCII_8BIT, Encoding::UTF_8, nil], - [Encoding, Encoding::ASCII_8BIT, Encoding::EUC_JP, nil], - [Encoding, Encoding::Shift_JIS, Encoding::EUC_JP, nil], - ].should be_computed_by(:compatible?) - end + it "returns nil if one of the encodings is not US-ASCII" do + [ [Encoding, Encoding::UTF_8, Encoding::ASCII_8BIT, nil], + [Encoding, Encoding::ASCII_8BIT, Encoding::UTF_8, nil], + [Encoding, Encoding::ASCII_8BIT, Encoding::EUC_JP, nil], + [Encoding, Encoding::Shift_JIS, Encoding::EUC_JP, nil], + ].should be_computed_by(:compatible?) + end - it "returns the first if the second is US-ASCII" do - [ [Encoding, Encoding::UTF_8, Encoding::US_ASCII, Encoding::UTF_8], - [Encoding, Encoding::EUC_JP, Encoding::US_ASCII, Encoding::EUC_JP], - [Encoding, Encoding::Shift_JIS, Encoding::US_ASCII, Encoding::Shift_JIS], - [Encoding, Encoding::ASCII_8BIT, Encoding::US_ASCII, Encoding::ASCII_8BIT], - ].should be_computed_by(:compatible?) - end + it "returns the first if the second is US-ASCII" do + [ [Encoding, Encoding::UTF_8, Encoding::US_ASCII, Encoding::UTF_8], + [Encoding, Encoding::EUC_JP, Encoding::US_ASCII, Encoding::EUC_JP], + [Encoding, Encoding::Shift_JIS, Encoding::US_ASCII, Encoding::Shift_JIS], + [Encoding, Encoding::ASCII_8BIT, Encoding::US_ASCII, Encoding::ASCII_8BIT], + ].should be_computed_by(:compatible?) + end - it "returns the Encoding if both are the same" do - [ [Encoding, Encoding::UTF_8, Encoding::UTF_8, Encoding::UTF_8], - [Encoding, Encoding::US_ASCII, Encoding::US_ASCII, Encoding::US_ASCII], - [Encoding, Encoding::ASCII_8BIT, Encoding::ASCII_8BIT, Encoding::ASCII_8BIT], - [Encoding, Encoding::UTF_7, Encoding::UTF_7, Encoding::UTF_7], - ].should be_computed_by(:compatible?) - end + it "returns the Encoding if both are the same" do + [ [Encoding, Encoding::UTF_8, Encoding::UTF_8, Encoding::UTF_8], + [Encoding, Encoding::US_ASCII, Encoding::US_ASCII, Encoding::US_ASCII], + [Encoding, Encoding::ASCII_8BIT, Encoding::ASCII_8BIT, Encoding::ASCII_8BIT], + [Encoding, Encoding::UTF_7, Encoding::UTF_7, Encoding::UTF_7], + ].should be_computed_by(:compatible?) end +end - describe "Encoding.compatible? Object, Object" do - it "returns nil for Object, String" do - Encoding.compatible?(Object.new, "abc").should be_nil - end +describe "Encoding.compatible? Object, Object" do + it "returns nil for Object, String" do + Encoding.compatible?(Object.new, "abc").should be_nil + end - it "returns nil for Object, Regexp" do - Encoding.compatible?(Object.new, /./).should be_nil - end + it "returns nil for Object, Regexp" do + Encoding.compatible?(Object.new, /./).should be_nil + end - it "returns nil for Object, Symbol" do - Encoding.compatible?(Object.new, :sym).should be_nil - end + it "returns nil for Object, Symbol" do + Encoding.compatible?(Object.new, :sym).should be_nil + end - it "returns nil for String, Object" do - Encoding.compatible?("abc", Object.new).should be_nil - end + it "returns nil for String, Object" do + Encoding.compatible?("abc", Object.new).should be_nil + end - it "returns nil for Regexp, Object" do - Encoding.compatible?(/./, Object.new).should be_nil - end + it "returns nil for Regexp, Object" do + Encoding.compatible?(/./, Object.new).should be_nil + end - it "returns nil for Symbol, Object" do - Encoding.compatible?(:sym, Object.new).should be_nil - end + it "returns nil for Symbol, Object" do + Encoding.compatible?(:sym, Object.new).should be_nil end end diff --git a/spec/ruby/core/encoding/converter/asciicompat_encoding_spec.rb b/spec/ruby/core/encoding/converter/asciicompat_encoding_spec.rb index f06a138ba6..e39d590e3a 100644 --- a/spec/ruby/core/encoding/converter/asciicompat_encoding_spec.rb +++ b/spec/ruby/core/encoding/converter/asciicompat_encoding_spec.rb @@ -1,39 +1,37 @@ require_relative '../../../spec_helper' -with_feature :encoding do - describe "Encoding::Converter.asciicompat_encoding" do - it "accepts an encoding name as a String argument" do - lambda { Encoding::Converter.asciicompat_encoding('UTF-8') }. - should_not raise_error - end +describe "Encoding::Converter.asciicompat_encoding" do + it "accepts an encoding name as a String argument" do + lambda { Encoding::Converter.asciicompat_encoding('UTF-8') }. + should_not raise_error + end - it "coerces non-String/Encoding objects with #to_str" do - str = mock('string') - str.should_receive(:to_str).at_least(1).times.and_return('string') - Encoding::Converter.asciicompat_encoding(str) - end + it "coerces non-String/Encoding objects with #to_str" do + str = mock('string') + str.should_receive(:to_str).at_least(1).times.and_return('string') + Encoding::Converter.asciicompat_encoding(str) + end - it "accepts an Encoding object as an argument" do - Encoding::Converter. - asciicompat_encoding(Encoding.find("ISO-2022-JP")). - should == Encoding::Converter.asciicompat_encoding("ISO-2022-JP") - end + it "accepts an Encoding object as an argument" do + Encoding::Converter. + asciicompat_encoding(Encoding.find("ISO-2022-JP")). + should == Encoding::Converter.asciicompat_encoding("ISO-2022-JP") + end - it "returns a corresponding ASCII compatible encoding for ASCII-incompatible encodings" do - Encoding::Converter.asciicompat_encoding('UTF-16BE').should == Encoding::UTF_8 - Encoding::Converter.asciicompat_encoding("ISO-2022-JP").should == Encoding.find("stateless-ISO-2022-JP") - end + it "returns a corresponding ASCII compatible encoding for ASCII-incompatible encodings" do + Encoding::Converter.asciicompat_encoding('UTF-16BE').should == Encoding::UTF_8 + Encoding::Converter.asciicompat_encoding("ISO-2022-JP").should == Encoding.find("stateless-ISO-2022-JP") + end - it "returns nil when the given encoding is ASCII compatible" do - Encoding::Converter.asciicompat_encoding('ASCII').should be_nil - Encoding::Converter.asciicompat_encoding('UTF-8').should be_nil - end + it "returns nil when the given encoding is ASCII compatible" do + Encoding::Converter.asciicompat_encoding('ASCII').should be_nil + Encoding::Converter.asciicompat_encoding('UTF-8').should be_nil + end - it "handles encoding names who resolve to nil encodings" do - internal = Encoding.default_internal - Encoding.default_internal = nil - Encoding::Converter.asciicompat_encoding('internal').should be_nil - Encoding.default_internal = internal - end + it "handles encoding names who resolve to nil encodings" do + internal = Encoding.default_internal + Encoding.default_internal = nil + Encoding::Converter.asciicompat_encoding('internal').should be_nil + Encoding.default_internal = internal end end diff --git a/spec/ruby/core/encoding/converter/constants_spec.rb b/spec/ruby/core/encoding/converter/constants_spec.rb index 9a03f61baf..57b6a4d4e7 100644 --- a/spec/ruby/core/encoding/converter/constants_spec.rb +++ b/spec/ruby/core/encoding/converter/constants_spec.rb @@ -1,133 +1,131 @@ require_relative '../../../spec_helper' -with_feature :encoding do - describe "Encoding::Converter::INVALID_MASK" do - it "exists" do - Encoding::Converter.should have_constant(:INVALID_MASK) - end +describe "Encoding::Converter::INVALID_MASK" do + it "exists" do + Encoding::Converter.should have_constant(:INVALID_MASK) + end - it "has a Fixnum value" do - Encoding::Converter::INVALID_MASK.should be_an_instance_of(Fixnum) - end + it "has a Fixnum value" do + Encoding::Converter::INVALID_MASK.should be_an_instance_of(Fixnum) end +end - describe "Encoding::Converter::INVALID_REPLACE" do - it "exists" do - Encoding::Converter.should have_constant(:INVALID_REPLACE) - end +describe "Encoding::Converter::INVALID_REPLACE" do + it "exists" do + Encoding::Converter.should have_constant(:INVALID_REPLACE) + end - it "has a Fixnum value" do - Encoding::Converter::INVALID_REPLACE.should be_an_instance_of(Fixnum) - end + it "has a Fixnum value" do + Encoding::Converter::INVALID_REPLACE.should be_an_instance_of(Fixnum) end +end - describe "Encoding::Converter::UNDEF_MASK" do - it "exists" do - Encoding::Converter.should have_constant(:UNDEF_MASK) - end +describe "Encoding::Converter::UNDEF_MASK" do + it "exists" do + Encoding::Converter.should have_constant(:UNDEF_MASK) + end - it "has a Fixnum value" do - Encoding::Converter::UNDEF_MASK.should be_an_instance_of(Fixnum) - end + it "has a Fixnum value" do + Encoding::Converter::UNDEF_MASK.should be_an_instance_of(Fixnum) end +end - describe "Encoding::Converter::UNDEF_REPLACE" do - it "exists" do - Encoding::Converter.should have_constant(:UNDEF_REPLACE) - end +describe "Encoding::Converter::UNDEF_REPLACE" do + it "exists" do + Encoding::Converter.should have_constant(:UNDEF_REPLACE) + end - it "has a Fixnum value" do - Encoding::Converter::UNDEF_REPLACE.should be_an_instance_of(Fixnum) - end + it "has a Fixnum value" do + Encoding::Converter::UNDEF_REPLACE.should be_an_instance_of(Fixnum) end +end - describe "Encoding::Converter::UNDEF_HEX_CHARREF" do - it "exists" do - Encoding::Converter.should have_constant(:UNDEF_HEX_CHARREF) - end +describe "Encoding::Converter::UNDEF_HEX_CHARREF" do + it "exists" do + Encoding::Converter.should have_constant(:UNDEF_HEX_CHARREF) + end - it "has a Fixnum value" do - Encoding::Converter::UNDEF_HEX_CHARREF.should be_an_instance_of(Fixnum) - end + it "has a Fixnum value" do + Encoding::Converter::UNDEF_HEX_CHARREF.should be_an_instance_of(Fixnum) end +end - describe "Encoding::Converter::PARTIAL_INPUT" do - it "exists" do - Encoding::Converter.should have_constant(:PARTIAL_INPUT) - end +describe "Encoding::Converter::PARTIAL_INPUT" do + it "exists" do + Encoding::Converter.should have_constant(:PARTIAL_INPUT) + end - it "has a Fixnum value" do - Encoding::Converter::PARTIAL_INPUT.should be_an_instance_of(Fixnum) - end + it "has a Fixnum value" do + Encoding::Converter::PARTIAL_INPUT.should be_an_instance_of(Fixnum) end +end - describe "Encoding::Converter::AFTER_OUTPUT" do - it "exists" do - Encoding::Converter.should have_constant(:AFTER_OUTPUT) - end +describe "Encoding::Converter::AFTER_OUTPUT" do + it "exists" do + Encoding::Converter.should have_constant(:AFTER_OUTPUT) + end - it "has a Fixnum value" do - Encoding::Converter::AFTER_OUTPUT.should be_an_instance_of(Fixnum) - end + it "has a Fixnum value" do + Encoding::Converter::AFTER_OUTPUT.should be_an_instance_of(Fixnum) end +end - describe "Encoding::Converter::UNIVERSAL_NEWLINE_DECORATOR" do - it "exists" do - Encoding::Converter.should have_constant(:UNIVERSAL_NEWLINE_DECORATOR) - end +describe "Encoding::Converter::UNIVERSAL_NEWLINE_DECORATOR" do + it "exists" do + Encoding::Converter.should have_constant(:UNIVERSAL_NEWLINE_DECORATOR) + end - it "has a Fixnum value" do - Encoding::Converter::UNIVERSAL_NEWLINE_DECORATOR.should be_an_instance_of(Fixnum) - end + it "has a Fixnum value" do + Encoding::Converter::UNIVERSAL_NEWLINE_DECORATOR.should be_an_instance_of(Fixnum) end +end - describe "Encoding::Converter::CRLF_NEWLINE_DECORATOR" do - it "exists" do - Encoding::Converter.should have_constant(:CRLF_NEWLINE_DECORATOR) - end +describe "Encoding::Converter::CRLF_NEWLINE_DECORATOR" do + it "exists" do + Encoding::Converter.should have_constant(:CRLF_NEWLINE_DECORATOR) + end - it "has a Fixnum value" do - Encoding::Converter::CRLF_NEWLINE_DECORATOR.should be_an_instance_of(Fixnum) - end + it "has a Fixnum value" do + Encoding::Converter::CRLF_NEWLINE_DECORATOR.should be_an_instance_of(Fixnum) end +end - describe "Encoding::Converter::CR_NEWLINE_DECORATOR" do - it "exists" do - Encoding::Converter.should have_constant(:CR_NEWLINE_DECORATOR) - end +describe "Encoding::Converter::CR_NEWLINE_DECORATOR" do + it "exists" do + Encoding::Converter.should have_constant(:CR_NEWLINE_DECORATOR) + end - it "has a Fixnum value" do - Encoding::Converter::CR_NEWLINE_DECORATOR.should be_an_instance_of(Fixnum) - end + it "has a Fixnum value" do + Encoding::Converter::CR_NEWLINE_DECORATOR.should be_an_instance_of(Fixnum) end +end - describe "Encoding::Converter::XML_TEXT_DECORATOR" do - it "exists" do - Encoding::Converter.should have_constant(:XML_TEXT_DECORATOR) - end +describe "Encoding::Converter::XML_TEXT_DECORATOR" do + it "exists" do + Encoding::Converter.should have_constant(:XML_TEXT_DECORATOR) + end - it "has a Fixnum value" do - Encoding::Converter::XML_TEXT_DECORATOR.should be_an_instance_of(Fixnum) - end + it "has a Fixnum value" do + Encoding::Converter::XML_TEXT_DECORATOR.should be_an_instance_of(Fixnum) end +end - describe "Encoding::Converter::XML_ATTR_CONTENT_DECORATOR" do - it "exists" do - Encoding::Converter.should have_constant(:XML_ATTR_CONTENT_DECORATOR) - end +describe "Encoding::Converter::XML_ATTR_CONTENT_DECORATOR" do + it "exists" do + Encoding::Converter.should have_constant(:XML_ATTR_CONTENT_DECORATOR) + end - it "has a Fixnum value" do - Encoding::Converter::XML_ATTR_CONTENT_DECORATOR.should be_an_instance_of(Fixnum) - end + it "has a Fixnum value" do + Encoding::Converter::XML_ATTR_CONTENT_DECORATOR.should be_an_instance_of(Fixnum) end +end - describe "Encoding::Converter::XML_ATTR_QUOTE_DECORATOR" do - it "exists" do - Encoding::Converter.should have_constant(:XML_ATTR_QUOTE_DECORATOR) - end +describe "Encoding::Converter::XML_ATTR_QUOTE_DECORATOR" do + it "exists" do + Encoding::Converter.should have_constant(:XML_ATTR_QUOTE_DECORATOR) + end - it "has a Fixnum value" do - Encoding::Converter::XML_ATTR_QUOTE_DECORATOR.should be_an_instance_of(Fixnum) - end + it "has a Fixnum value" do + Encoding::Converter::XML_ATTR_QUOTE_DECORATOR.should be_an_instance_of(Fixnum) end end diff --git a/spec/ruby/core/encoding/converter/convert_spec.rb b/spec/ruby/core/encoding/converter/convert_spec.rb index 525e83a17f..362e027a58 100644 --- a/spec/ruby/core/encoding/converter/convert_spec.rb +++ b/spec/ruby/core/encoding/converter/convert_spec.rb @@ -1,47 +1,45 @@ # -*- encoding: binary -*- require_relative '../../../spec_helper' -with_feature :encoding do - describe "Encoding::Converter#convert" do - it "returns a String" do - ec = Encoding::Converter.new('ascii', 'utf-8') - ec.convert('glark').should be_an_instance_of(String) - end +describe "Encoding::Converter#convert" do + it "returns a String" do + ec = Encoding::Converter.new('ascii', 'utf-8') + ec.convert('glark').should be_an_instance_of(String) + end - it "sets the encoding of the result to the target encoding" do - ec = Encoding::Converter.new('ascii', 'utf-8') - str = 'glark'.force_encoding('ascii') - ec.convert(str).encoding.should == Encoding::UTF_8 - end + it "sets the encoding of the result to the target encoding" do + ec = Encoding::Converter.new('ascii', 'utf-8') + str = 'glark'.force_encoding('ascii') + ec.convert(str).encoding.should == Encoding::UTF_8 + end - it "transcodes the given String to the target encoding" do - ec = Encoding::Converter.new("utf-8", "euc-jp") - ec.convert("\u3042".force_encoding('UTF-8')).should == \ - "\xA4\xA2".force_encoding('EUC-JP') - end + it "transcodes the given String to the target encoding" do + ec = Encoding::Converter.new("utf-8", "euc-jp") + ec.convert("\u3042".force_encoding('UTF-8')).should == \ + "\xA4\xA2".force_encoding('EUC-JP') + end - it "allows Strings of different encodings to the source encoding" do - ec = Encoding::Converter.new('ascii', 'utf-8') - str = 'glark'.force_encoding('SJIS') - ec.convert(str).encoding.should == Encoding::UTF_8 - end + it "allows Strings of different encodings to the source encoding" do + ec = Encoding::Converter.new('ascii', 'utf-8') + str = 'glark'.force_encoding('SJIS') + ec.convert(str).encoding.should == Encoding::UTF_8 + end - it "reuses the given encoding pair if called multiple times" do - ec = Encoding::Converter.new('ascii', 'SJIS') - ec.convert('a'.force_encoding('ASCII')).should == 'a'.force_encoding('SJIS') - ec.convert('b'.force_encoding('ASCII')).should == 'b'.force_encoding('SJIS') - end + it "reuses the given encoding pair if called multiple times" do + ec = Encoding::Converter.new('ascii', 'SJIS') + ec.convert('a'.force_encoding('ASCII')).should == 'a'.force_encoding('SJIS') + ec.convert('b'.force_encoding('ASCII')).should == 'b'.force_encoding('SJIS') + end - it "raises UndefinedConversionError if the String contains characters invalid for the target encoding" do - ec = Encoding::Converter.new('UTF-8', Encoding.find('macCyrillic')) - lambda { ec.convert("\u{6543}".force_encoding('UTF-8')) }.should \ - raise_error(Encoding::UndefinedConversionError) - end + it "raises UndefinedConversionError if the String contains characters invalid for the target encoding" do + ec = Encoding::Converter.new('UTF-8', Encoding.find('macCyrillic')) + lambda { ec.convert("\u{6543}".force_encoding('UTF-8')) }.should \ + raise_error(Encoding::UndefinedConversionError) + end - it "raises an ArgumentError if called on a finished stream" do - ec = Encoding::Converter.new('UTF-8', Encoding.find('macCyrillic')) - ec.finish - lambda { ec.convert("\u{65}") }.should raise_error(ArgumentError) - end + it "raises an ArgumentError if called on a finished stream" do + ec = Encoding::Converter.new('UTF-8', Encoding.find('macCyrillic')) + ec.finish + lambda { ec.convert("\u{65}") }.should raise_error(ArgumentError) end end diff --git a/spec/ruby/core/encoding/converter/convpath_spec.rb b/spec/ruby/core/encoding/converter/convpath_spec.rb index e41a6c4205..473f2db91e 100644 --- a/spec/ruby/core/encoding/converter/convpath_spec.rb +++ b/spec/ruby/core/encoding/converter/convpath_spec.rb @@ -1,26 +1,24 @@ require_relative '../../../spec_helper' -with_feature :encoding do - describe "Encoding::Converter#convpath" do - it "returns an Array with a single element if there is a direct converter" do - cp = Encoding::Converter.new('ASCII', 'UTF-8').convpath - cp.should == [[Encoding::US_ASCII, Encoding::UTF_8]] - end +describe "Encoding::Converter#convpath" do + it "returns an Array with a single element if there is a direct converter" do + cp = Encoding::Converter.new('ASCII', 'UTF-8').convpath + cp.should == [[Encoding::US_ASCII, Encoding::UTF_8]] + end - it "returns multiple encoding pairs when direct conversion is impossible" do - cp = Encoding::Converter.new('ascii','Big5').convpath - cp.should == [ - [Encoding::US_ASCII, Encoding::UTF_8], - [Encoding::UTF_8, Encoding::Big5] - ] - end + it "returns multiple encoding pairs when direct conversion is impossible" do + cp = Encoding::Converter.new('ascii','Big5').convpath + cp.should == [ + [Encoding::US_ASCII, Encoding::UTF_8], + [Encoding::UTF_8, Encoding::Big5] + ] + end - it "indicates if crlf_newline conversion would occur" do - ec = Encoding::Converter.new("ISo-8859-1", "EUC-JP", {crlf_newline: true}) - ec.convpath.last.should == "crlf_newline" + it "indicates if crlf_newline conversion would occur" do + ec = Encoding::Converter.new("ISo-8859-1", "EUC-JP", {crlf_newline: true}) + ec.convpath.last.should == "crlf_newline" - ec = Encoding::Converter.new("ASCII", "UTF-8", {crlf_newline: false}) - ec.convpath.last.should_not == "crlf_newline" - end + ec = Encoding::Converter.new("ASCII", "UTF-8", {crlf_newline: false}) + ec.convpath.last.should_not == "crlf_newline" end end diff --git a/spec/ruby/core/encoding/converter/destination_encoding_spec.rb b/spec/ruby/core/encoding/converter/destination_encoding_spec.rb index 2d0f8e0697..481a857909 100644 --- a/spec/ruby/core/encoding/converter/destination_encoding_spec.rb +++ b/spec/ruby/core/encoding/converter/destination_encoding_spec.rb @@ -1,13 +1,11 @@ require_relative '../../../spec_helper' -with_feature :encoding do - describe "Encoding::Converter#destination_encoding" do - it "returns the destination encoding as an Encoding object" do - ec = Encoding::Converter.new('ASCII','Big5') - ec.destination_encoding.should == Encoding::BIG5 +describe "Encoding::Converter#destination_encoding" do + it "returns the destination encoding as an Encoding object" do + ec = Encoding::Converter.new('ASCII','Big5') + ec.destination_encoding.should == Encoding::BIG5 - ec = Encoding::Converter.new('SJIS','EUC-JP') - ec.destination_encoding.should == Encoding::EUC_JP - end + ec = Encoding::Converter.new('SJIS','EUC-JP') + ec.destination_encoding.should == Encoding::EUC_JP end end diff --git a/spec/ruby/core/encoding/converter/finish_spec.rb b/spec/ruby/core/encoding/converter/finish_spec.rb index 917f3d2912..11ca7e8510 100644 --- a/spec/ruby/core/encoding/converter/finish_spec.rb +++ b/spec/ruby/core/encoding/converter/finish_spec.rb @@ -1,38 +1,36 @@ require_relative '../../../spec_helper' -with_feature :encoding do - describe "Encoding::Converter#finish" do - before :each do - @ec = Encoding::Converter.new("utf-8", "iso-2022-jp") - end +describe "Encoding::Converter#finish" do + before :each do + @ec = Encoding::Converter.new("utf-8", "iso-2022-jp") + end - it "returns a String" do - @ec.convert('foo') - @ec.finish.should be_an_instance_of(String) - end + it "returns a String" do + @ec.convert('foo') + @ec.finish.should be_an_instance_of(String) + end - it "returns an empty String if there is nothing more to convert" do - @ec.convert("glark") - @ec.finish.should == "" - end + it "returns an empty String if there is nothing more to convert" do + @ec.convert("glark") + @ec.finish.should == "" + end - it "returns the last part of the converted String if it hasn't already" do - @ec.convert("\u{9999}").should == "\e$B9a".force_encoding('iso-2022-jp') - @ec.finish.should == "\e(B".force_encoding('iso-2022-jp') - end + it "returns the last part of the converted String if it hasn't already" do + @ec.convert("\u{9999}").should == "\e$B9a".force_encoding('iso-2022-jp') + @ec.finish.should == "\e(B".force_encoding('iso-2022-jp') + end - it "returns a String in the destination encoding" do - @ec.convert("glark") - @ec.finish.encoding.should == Encoding::ISO2022_JP - end + it "returns a String in the destination encoding" do + @ec.convert("glark") + @ec.finish.encoding.should == Encoding::ISO2022_JP + end - it "returns an empty String if self was not given anything to convert" do - @ec.finish.should == "" - end + it "returns an empty String if self was not given anything to convert" do + @ec.finish.should == "" + end - it "returns an empty String on subsequent invocations" do - @ec.finish.should == "" - @ec.finish.should == "" - end + it "returns an empty String on subsequent invocations" do + @ec.finish.should == "" + @ec.finish.should == "" end end diff --git a/spec/ruby/core/encoding/converter/last_error_spec.rb b/spec/ruby/core/encoding/converter/last_error_spec.rb index 7275b31180..68567737b7 100644 --- a/spec/ruby/core/encoding/converter/last_error_spec.rb +++ b/spec/ruby/core/encoding/converter/last_error_spec.rb @@ -1,93 +1,91 @@ # -*- encoding: binary -*- require_relative '../../../spec_helper' -with_feature :encoding do - describe "Encoding::Converter#last_error" do - it "returns nil when the no conversion has been attempted" do - ec = Encoding::Converter.new('ascii','utf-8') - ec.last_error.should be_nil - end +describe "Encoding::Converter#last_error" do + it "returns nil when the no conversion has been attempted" do + ec = Encoding::Converter.new('ascii','utf-8') + ec.last_error.should be_nil + end - it "returns nil when the last conversion did not produce an error" do - ec = Encoding::Converter.new('ascii','utf-8') - ec.convert('a'.force_encoding('ascii')) - ec.last_error.should be_nil - end + it "returns nil when the last conversion did not produce an error" do + ec = Encoding::Converter.new('ascii','utf-8') + ec.convert('a'.force_encoding('ascii')) + ec.last_error.should be_nil + end - it "returns nil when #primitive_convert last returned :destination_buffer_full" do - ec = Encoding::Converter.new("utf-8", "iso-2022-jp") - ec.primitive_convert("\u{9999}", "", 0, 0, partial_input: false) \ - .should == :destination_buffer_full - ec.last_error.should be_nil - end + it "returns nil when #primitive_convert last returned :destination_buffer_full" do + ec = Encoding::Converter.new("utf-8", "iso-2022-jp") + ec.primitive_convert("\u{9999}", "", 0, 0, partial_input: false) \ + .should == :destination_buffer_full + ec.last_error.should be_nil + end - it "returns nil when #primitive_convert last returned :finished" do - ec = Encoding::Converter.new("utf-8", "iso-8859-1") - ec.primitive_convert("glark".force_encoding('utf-8'),"").should == :finished - ec.last_error.should be_nil - end + it "returns nil when #primitive_convert last returned :finished" do + ec = Encoding::Converter.new("utf-8", "iso-8859-1") + ec.primitive_convert("glark".force_encoding('utf-8'),"").should == :finished + ec.last_error.should be_nil + end - it "returns nil if the last conversion succeeded but the penultimate failed" do - ec = Encoding::Converter.new("utf-8", "iso-8859-1") - ec.primitive_convert("\xf1abcd","").should == :invalid_byte_sequence - ec.primitive_convert("glark".force_encoding('utf-8'),"").should == :finished - ec.last_error.should be_nil - end + it "returns nil if the last conversion succeeded but the penultimate failed" do + ec = Encoding::Converter.new("utf-8", "iso-8859-1") + ec.primitive_convert("\xf1abcd","").should == :invalid_byte_sequence + ec.primitive_convert("glark".force_encoding('utf-8'),"").should == :finished + ec.last_error.should be_nil + end - it "returns an Encoding::InvalidByteSequenceError when #primitive_convert last returned :invalid_byte_sequence" do - ec = Encoding::Converter.new("utf-8", "iso-8859-1") - ec.primitive_convert("\xf1abcd","").should == :invalid_byte_sequence - ec.last_error.should be_an_instance_of(Encoding::InvalidByteSequenceError) - end + it "returns an Encoding::InvalidByteSequenceError when #primitive_convert last returned :invalid_byte_sequence" do + ec = Encoding::Converter.new("utf-8", "iso-8859-1") + ec.primitive_convert("\xf1abcd","").should == :invalid_byte_sequence + ec.last_error.should be_an_instance_of(Encoding::InvalidByteSequenceError) + end - it "returns an Encoding::UndefinedConversionError when #primitive_convert last returned :undefined_conversion" do - ec = Encoding::Converter.new("utf-8", "iso-8859-1") - ec.primitive_convert("\u{9876}","").should == :undefined_conversion - ec.last_error.should be_an_instance_of(Encoding::UndefinedConversionError) - end + it "returns an Encoding::UndefinedConversionError when #primitive_convert last returned :undefined_conversion" do + ec = Encoding::Converter.new("utf-8", "iso-8859-1") + ec.primitive_convert("\u{9876}","").should == :undefined_conversion + ec.last_error.should be_an_instance_of(Encoding::UndefinedConversionError) + end - it "returns an Encoding::InvalidByteSequenceError when #primitive_convert last returned :incomplete_input" do - ec = Encoding::Converter.new("EUC-JP", "ISO-8859-1") - ec.primitive_convert("\xa4", "", nil, 10).should == :incomplete_input - ec.last_error.should be_an_instance_of(Encoding::InvalidByteSequenceError) - end + it "returns an Encoding::InvalidByteSequenceError when #primitive_convert last returned :incomplete_input" do + ec = Encoding::Converter.new("EUC-JP", "ISO-8859-1") + ec.primitive_convert("\xa4", "", nil, 10).should == :incomplete_input + ec.last_error.should be_an_instance_of(Encoding::InvalidByteSequenceError) + end - it "returns an Encoding::InvalidByteSequenceError when the last call to #convert produced one" do - ec = Encoding::Converter.new("utf-8", "iso-8859-1") - exception = nil - -> { - ec.convert("\xf1abcd") - }.should raise_error(Encoding::InvalidByteSequenceError) { |e| - exception = e - } - ec.last_error.should be_an_instance_of(Encoding::InvalidByteSequenceError) - ec.last_error.message.should == exception.message - end + it "returns an Encoding::InvalidByteSequenceError when the last call to #convert produced one" do + ec = Encoding::Converter.new("utf-8", "iso-8859-1") + exception = nil + -> { + ec.convert("\xf1abcd") + }.should raise_error(Encoding::InvalidByteSequenceError) { |e| + exception = e + } + ec.last_error.should be_an_instance_of(Encoding::InvalidByteSequenceError) + ec.last_error.message.should == exception.message + end - it "returns an Encoding::UndefinedConversionError when the last call to #convert produced one" do - ec = Encoding::Converter.new("utf-8", "iso-8859-1") - exception = nil - -> { - ec.convert("\u{9899}") - }.should raise_error(Encoding::UndefinedConversionError) { |e| - exception = e - } - ec.last_error.should be_an_instance_of(Encoding::UndefinedConversionError) - ec.last_error.message.should == exception.message - ec.last_error.message.should include "from UTF-8 to ISO-8859-1" - end + it "returns an Encoding::UndefinedConversionError when the last call to #convert produced one" do + ec = Encoding::Converter.new("utf-8", "iso-8859-1") + exception = nil + -> { + ec.convert("\u{9899}") + }.should raise_error(Encoding::UndefinedConversionError) { |e| + exception = e + } + ec.last_error.should be_an_instance_of(Encoding::UndefinedConversionError) + ec.last_error.message.should == exception.message + ec.last_error.message.should include "from UTF-8 to ISO-8859-1" + end - it "returns the last error of #convert with a message showing the transcoding path" do - ec = Encoding::Converter.new("iso-8859-1", "Big5") - exception = nil - -> { - ec.convert("\xE9") # é in ISO-8859-1 - }.should raise_error(Encoding::UndefinedConversionError) { |e| - exception = e - } - ec.last_error.should be_an_instance_of(Encoding::UndefinedConversionError) - ec.last_error.message.should == exception.message - ec.last_error.message.should include "from ISO-8859-1 to UTF-8 to Big5" - end + it "returns the last error of #convert with a message showing the transcoding path" do + ec = Encoding::Converter.new("iso-8859-1", "Big5") + exception = nil + -> { + ec.convert("\xE9") # é in ISO-8859-1 + }.should raise_error(Encoding::UndefinedConversionError) { |e| + exception = e + } + ec.last_error.should be_an_instance_of(Encoding::UndefinedConversionError) + ec.last_error.message.should == exception.message + ec.last_error.message.should include "from ISO-8859-1 to UTF-8 to Big5" end end diff --git a/spec/ruby/core/encoding/converter/new_spec.rb b/spec/ruby/core/encoding/converter/new_spec.rb index 08c47daefc..d62b709c52 100644 --- a/spec/ruby/core/encoding/converter/new_spec.rb +++ b/spec/ruby/core/encoding/converter/new_spec.rb @@ -1,120 +1,118 @@ # -*- encoding: ascii-8bit -*- require_relative '../../../spec_helper' -with_feature :encoding do - describe "Encoding::Converter.new" do - it "accepts a String for the source encoding" do - conv = Encoding::Converter.new("us-ascii", "utf-8") - conv.source_encoding.should == Encoding::US_ASCII - end +describe "Encoding::Converter.new" do + it "accepts a String for the source encoding" do + conv = Encoding::Converter.new("us-ascii", "utf-8") + conv.source_encoding.should == Encoding::US_ASCII + end - it "accepts a String for the destination encoding" do - conv = Encoding::Converter.new("us-ascii", "utf-8") - conv.destination_encoding.should == Encoding::UTF_8 - end + it "accepts a String for the destination encoding" do + conv = Encoding::Converter.new("us-ascii", "utf-8") + conv.destination_encoding.should == Encoding::UTF_8 + end - it "accepts an Encoding object for the source encoding" do - conv = Encoding::Converter.new(Encoding::US_ASCII, "utf-8") - conv.source_encoding.should == Encoding::US_ASCII - end + it "accepts an Encoding object for the source encoding" do + conv = Encoding::Converter.new(Encoding::US_ASCII, "utf-8") + conv.source_encoding.should == Encoding::US_ASCII + end - it "accepts an Encoding object for the destination encoding" do - conv = Encoding::Converter.new("us-ascii", Encoding::UTF_8) - conv.destination_encoding.should == Encoding::UTF_8 - end + it "accepts an Encoding object for the destination encoding" do + conv = Encoding::Converter.new("us-ascii", Encoding::UTF_8) + conv.destination_encoding.should == Encoding::UTF_8 + end - it "raises an Encoding::ConverterNotFoundError if both encodings are the same" do - lambda do - Encoding::Converter.new "utf-8", "utf-8" - end.should raise_error(Encoding::ConverterNotFoundError) - end + it "raises an Encoding::ConverterNotFoundError if both encodings are the same" do + lambda do + Encoding::Converter.new "utf-8", "utf-8" + end.should raise_error(Encoding::ConverterNotFoundError) + end - it "calls #to_str to convert the source encoding argument to an encoding name" do - enc = mock("us-ascii") - enc.should_receive(:to_str).and_return("us-ascii") - conv = Encoding::Converter.new(enc, "utf-8") - conv.source_encoding.should == Encoding::US_ASCII - end + it "calls #to_str to convert the source encoding argument to an encoding name" do + enc = mock("us-ascii") + enc.should_receive(:to_str).and_return("us-ascii") + conv = Encoding::Converter.new(enc, "utf-8") + conv.source_encoding.should == Encoding::US_ASCII + end - it "calls #to_str to convert the destination encoding argument to an encoding name" do - enc = mock("utf-8") - enc.should_receive(:to_str).and_return("utf-8") - conv = Encoding::Converter.new("us-ascii", enc) - conv.destination_encoding.should == Encoding::UTF_8 - end + it "calls #to_str to convert the destination encoding argument to an encoding name" do + enc = mock("utf-8") + enc.should_receive(:to_str).and_return("utf-8") + conv = Encoding::Converter.new("us-ascii", enc) + conv.destination_encoding.should == Encoding::UTF_8 + end - it "sets replacement from the options Hash" do - conv = Encoding::Converter.new("us-ascii", "utf-8", replace: "fubar") - conv.replacement.should == "fubar" - end + it "sets replacement from the options Hash" do + conv = Encoding::Converter.new("us-ascii", "utf-8", replace: "fubar") + conv.replacement.should == "fubar" + end - it "calls #to_hash to convert the options argument to a Hash if not a Fixnum" do - opts = mock("encoding converter options") - opts.should_receive(:to_hash).and_return({ replace: "fubar" }) - conv = Encoding::Converter.new("us-ascii", "utf-8", opts) - conv.replacement.should == "fubar" - end + it "calls #to_hash to convert the options argument to a Hash if not a Fixnum" do + opts = mock("encoding converter options") + opts.should_receive(:to_hash).and_return({ replace: "fubar" }) + conv = Encoding::Converter.new("us-ascii", "utf-8", opts) + conv.replacement.should == "fubar" + end - it "calls #to_str to convert the replacement object to a String" do - obj = mock("encoding converter replacement") - obj.should_receive(:to_str).and_return("fubar") - conv = Encoding::Converter.new("us-ascii", "utf-8", replace: obj) - conv.replacement.should == "fubar" - end + it "calls #to_str to convert the replacement object to a String" do + obj = mock("encoding converter replacement") + obj.should_receive(:to_str).and_return("fubar") + conv = Encoding::Converter.new("us-ascii", "utf-8", replace: obj) + conv.replacement.should == "fubar" + end - it "raises a TypeError if #to_str does not return a String" do - obj = mock("encoding converter replacement") - obj.should_receive(:to_str).and_return(1) + it "raises a TypeError if #to_str does not return a String" do + obj = mock("encoding converter replacement") + obj.should_receive(:to_str).and_return(1) - lambda do - Encoding::Converter.new("us-ascii", "utf-8", replace: obj) - end.should raise_error(TypeError) - end + lambda do + Encoding::Converter.new("us-ascii", "utf-8", replace: obj) + end.should raise_error(TypeError) + end - it "raises a TypeError if passed true for the replacement object" do - lambda do - Encoding::Converter.new("us-ascii", "utf-8", replace: true) - end.should raise_error(TypeError) - end + it "raises a TypeError if passed true for the replacement object" do + lambda do + Encoding::Converter.new("us-ascii", "utf-8", replace: true) + end.should raise_error(TypeError) + end - it "raises a TypeError if passed false for the replacement object" do - lambda do - Encoding::Converter.new("us-ascii", "utf-8", replace: false) - end.should raise_error(TypeError) - end + it "raises a TypeError if passed false for the replacement object" do + lambda do + Encoding::Converter.new("us-ascii", "utf-8", replace: false) + end.should raise_error(TypeError) + end - it "raises a TypeError if passed a Fixnum for the replacement object" do - lambda do - Encoding::Converter.new("us-ascii", "utf-8", replace: 1) - end.should raise_error(TypeError) - end + it "raises a TypeError if passed a Fixnum for the replacement object" do + lambda do + Encoding::Converter.new("us-ascii", "utf-8", replace: 1) + end.should raise_error(TypeError) + end - it "accepts an empty String for the replacement object" do - conv = Encoding::Converter.new("us-ascii", "utf-8", replace: "") - conv.replacement.should == "" - end + it "accepts an empty String for the replacement object" do + conv = Encoding::Converter.new("us-ascii", "utf-8", replace: "") + conv.replacement.should == "" + end + + describe "when passed nil for the replacement object" do + describe "when the destination encoding is not UTF-8" do + it "sets the replacement String to '?'" do + conv = Encoding::Converter.new("us-ascii", "ascii-8bit", replace: nil) + conv.replacement.should == "?" + end + + it "sets the replacement String encoding to US-ASCII" do + conv = Encoding::Converter.new("us-ascii", "ascii-8bit", replace: nil) + conv.replacement.encoding.should == Encoding::US_ASCII + end + + it "sets the replacement String to '\\uFFFD'" do + conv = Encoding::Converter.new("us-ascii", "utf-8", replace: nil) + conv.replacement.should == "\u{fffd}".force_encoding("utf-8") + end - describe "when passed nil for the replacement object" do - describe "when the destination encoding is not UTF-8" do - it "sets the replacement String to '?'" do - conv = Encoding::Converter.new("us-ascii", "ascii-8bit", replace: nil) - conv.replacement.should == "?" - end - - it "sets the replacement String encoding to US-ASCII" do - conv = Encoding::Converter.new("us-ascii", "ascii-8bit", replace: nil) - conv.replacement.encoding.should == Encoding::US_ASCII - end - - it "sets the replacement String to '\\uFFFD'" do - conv = Encoding::Converter.new("us-ascii", "utf-8", replace: nil) - conv.replacement.should == "\u{fffd}".force_encoding("utf-8") - end - - it "sets the replacement String encoding to UTF-8" do - conv = Encoding::Converter.new("us-ascii", "utf-8", replace: nil) - conv.replacement.encoding.should == Encoding::UTF_8 - end + it "sets the replacement String encoding to UTF-8" do + conv = Encoding::Converter.new("us-ascii", "utf-8", replace: nil) + conv.replacement.encoding.should == Encoding::UTF_8 end end end diff --git a/spec/ruby/core/encoding/converter/primitive_convert_spec.rb b/spec/ruby/core/encoding/converter/primitive_convert_spec.rb index 182e321e5c..710cc262bb 100644 --- a/spec/ruby/core/encoding/converter/primitive_convert_spec.rb +++ b/spec/ruby/core/encoding/converter/primitive_convert_spec.rb @@ -1,213 +1,211 @@ # -*- encoding: binary -*- require_relative '../../../spec_helper' -with_feature :encoding do - describe "Encoding::Converter#primitive_convert" do - before :each do - @ec = Encoding::Converter.new("utf-8", "iso-8859-1") - end - - it "accepts a nil source buffer" do - lambda { @ec.primitive_convert(nil,"") }.should_not raise_error - end - - it "accepts a String as the source buffer" do - lambda { @ec.primitive_convert("","") }.should_not raise_error - end - - it "accepts nil for the destination byte offset" do - lambda { @ec.primitive_convert("","", nil) }.should_not raise_error - end - - it "accepts an integer for the destination byte offset" do - lambda { @ec.primitive_convert("","a", 1) }.should_not raise_error - end - - it "calls #to_int to convert the destination byte offset" do - offset = mock("encoding primitive_convert destination byte offset") - offset.should_receive(:to_int).and_return(2) - @ec.primitive_convert("abc", result = " ", offset).should == :finished - result.should == " abc" - end - - it "raises an ArgumentError if the destination byte offset is greater than the bytesize of the destination buffer" do - lambda { @ec.primitive_convert("","am", 0) }.should_not raise_error - lambda { @ec.primitive_convert("","am", 1) }.should_not raise_error - lambda { @ec.primitive_convert("","am", 2) }.should_not raise_error - lambda { @ec.primitive_convert("","am", 3) }.should raise_error(ArgumentError) - end - - it "uses the destination byte offset to determine where to write the result in the destination buffer" do - dest = "aa" - @ec.primitive_convert("b",dest, nil, 0) - dest.should == "aa" - - @ec.primitive_convert("b",dest, nil, 1) - dest.should == "aab" - - @ec.primitive_convert("b",dest, nil, 2) - dest.should == "aabbb" - end - - it "accepts nil for the destination bytesize" do - lambda { @ec.primitive_convert("","", nil, nil) }.should_not raise_error - end - - it "accepts an integer for the destination bytesize" do - lambda { @ec.primitive_convert("","", nil, 0) }.should_not raise_error - end - - it "allows a destination bytesize value greater than the bytesize of the source buffer" do - lambda { @ec.primitive_convert("am","", nil, 3) }.should_not raise_error - end - - it "allows a destination bytesize value less than the bytesize of the source buffer" do - lambda { @ec.primitive_convert("am","", nil, 1) }.should_not raise_error - end - - it "calls #to_int to convert the destination byte size" do - size = mock("encoding primitive_convert destination byte size") - size.should_receive(:to_int).and_return(2) - @ec.primitive_convert("abc", result = " ", 0, size).should == :destination_buffer_full - result.should == "ab" - end - - it "uses destination bytesize as the maximum bytesize of the destination buffer" do - dest = "" - @ec.primitive_convert("glark", dest, nil, 1) - dest.bytesize.should == 1 - end - - it "allows a destination buffer of unlimited size if destination bytesize is nil" do - source = "glark".force_encoding('utf-8') - dest = "" - @ec.primitive_convert("glark", dest, nil, nil) - dest.bytesize.should == source.bytesize - end - - it "accepts an options hash" do - @ec.primitive_convert("","",nil,nil, {after_output: true}).should == :finished - end - - it "sets the destination buffer's encoding to the destination encoding if the conversion succeeded" do - dest = "".force_encoding('utf-8') - dest.encoding.should == Encoding::UTF_8 - @ec.primitive_convert("\u{98}",dest).should == :finished - dest.encoding.should == Encoding::ISO_8859_1 - end - - it "sets the destination buffer's encoding to the destination encoding if the conversion failed" do - dest = "".force_encoding('utf-8') - dest.encoding.should == Encoding::UTF_8 - @ec.primitive_convert("\u{9878}",dest).should == :undefined_conversion - dest.encoding.should == Encoding::ISO_8859_1 - end - - it "removes the undefined part from the source buffer when returning :undefined_conversion" do - dest = "".force_encoding('utf-8') - s = "\u{9878}abcd" - @ec.primitive_convert(s, dest).should == :undefined_conversion - - s.should == "abcd" - end - - it "returns :incomplete_input when source buffer ends unexpectedly and :partial_input isn't specified" do - ec = Encoding::Converter.new("EUC-JP", "ISO-8859-1") - ec.primitive_convert("\xa4", "", nil, nil, partial_input: false).should == :incomplete_input - end - - it "clears the source buffer when returning :incomplete_input" do - ec = Encoding::Converter.new("EUC-JP", "ISO-8859-1") - s = "\xa4" - ec.primitive_convert(s, "").should == :incomplete_input - - s.should == "" - end - - it "returns :source_buffer_empty when source buffer ends unexpectedly and :partial_input is true" do - ec = Encoding::Converter.new("EUC-JP", "ISO-8859-1") - ec.primitive_convert("\xa4", "", nil, nil, partial_input: true).should == :source_buffer_empty - end - - it "clears the source buffer when returning :source_buffer_empty" do - ec = Encoding::Converter.new("EUC-JP", "ISO-8859-1") - s = "\xa4" - ec.primitive_convert(s, "", nil, nil, partial_input: true).should == :source_buffer_empty - - s.should == "" - end - - it "returns :undefined_conversion when a character in the source buffer is not representable in the output encoding" do - @ec.primitive_convert("\u{9876}","").should == :undefined_conversion - end - - it "returns :invalid_byte_sequence when an invalid byte sequence was found in the source buffer" do - @ec.primitive_convert("\xf1abcd","").should == :invalid_byte_sequence - end - - it "removes consumed and erroneous bytes from the source buffer when returning :invalid_byte_sequence" do - ec = Encoding::Converter.new(Encoding::UTF_8, Encoding::UTF_8_MAC) - s = "\xC3\xA1\x80\x80\xC3\xA1".force_encoding("utf-8") - dest = "".force_encoding("utf-8") - ec.primitive_convert(s, dest) - - s.should == "\x80\xC3\xA1".force_encoding("utf-8") - end - - it "returns :finished when the conversion succeeded" do - @ec.primitive_convert("glark".force_encoding('utf-8'),"").should == :finished - end - - it "clears the source buffer when returning :finished" do - s = "glark".force_encoding('utf-8') - @ec.primitive_convert(s, "").should == :finished - - s.should == "" - end - - it "returns :destination_buffer_full when the destination buffer is too small" do - ec = Encoding::Converter.new("utf-8", "iso-2022-jp") - source = "\u{9999}" - destination_bytesize = source.bytesize - 1 - ec.primitive_convert(source, "", 0, destination_bytesize) \ - .should == :destination_buffer_full - source.should == "" - end - - it "clears the source buffer when returning :destination_buffer_full" do - ec = Encoding::Converter.new("utf-8", "iso-2022-jp") - s = "\u{9999}" - destination_bytesize = s.bytesize - 1 - ec.primitive_convert(s, "", 0, destination_bytesize).should == :destination_buffer_full - - s.should == "" - end - - it "keeps removing invalid bytes from the source buffer" do - ec = Encoding::Converter.new(Encoding::UTF_8, Encoding::UTF_8_MAC) - s = "\x80\x80\x80" - dest = "".force_encoding(Encoding::UTF_8_MAC) - - ec.primitive_convert(s, dest) - s.should == "\x80\x80" - ec.primitive_convert(s, dest) - s.should == "\x80" - ec.primitive_convert(s, dest) - s.should == "" - end - - it "reuses read-again bytes after the first error" do - s = "\xf1abcd" - dest = "" - - @ec.primitive_convert(s, dest).should == :invalid_byte_sequence - s.should == "bcd" - @ec.primitive_errinfo[4].should == "a" - - @ec.primitive_convert(s, dest).should == :finished - s.should == "" - - dest.should == "abcd" - end +describe "Encoding::Converter#primitive_convert" do + before :each do + @ec = Encoding::Converter.new("utf-8", "iso-8859-1") + end + + it "accepts a nil source buffer" do + lambda { @ec.primitive_convert(nil,"") }.should_not raise_error + end + + it "accepts a String as the source buffer" do + lambda { @ec.primitive_convert("","") }.should_not raise_error + end + + it "accepts nil for the destination byte offset" do + lambda { @ec.primitive_convert("","", nil) }.should_not raise_error + end + + it "accepts an integer for the destination byte offset" do + lambda { @ec.primitive_convert("","a", 1) }.should_not raise_error + end + + it "calls #to_int to convert the destination byte offset" do + offset = mock("encoding primitive_convert destination byte offset") + offset.should_receive(:to_int).and_return(2) + @ec.primitive_convert("abc", result = " ", offset).should == :finished + result.should == " abc" + end + + it "raises an ArgumentError if the destination byte offset is greater than the bytesize of the destination buffer" do + lambda { @ec.primitive_convert("","am", 0) }.should_not raise_error + lambda { @ec.primitive_convert("","am", 1) }.should_not raise_error + lambda { @ec.primitive_convert("","am", 2) }.should_not raise_error + lambda { @ec.primitive_convert("","am", 3) }.should raise_error(ArgumentError) + end + + it "uses the destination byte offset to determine where to write the result in the destination buffer" do + dest = "aa" + @ec.primitive_convert("b",dest, nil, 0) + dest.should == "aa" + + @ec.primitive_convert("b",dest, nil, 1) + dest.should == "aab" + + @ec.primitive_convert("b",dest, nil, 2) + dest.should == "aabbb" + end + + it "accepts nil for the destination bytesize" do + lambda { @ec.primitive_convert("","", nil, nil) }.should_not raise_error + end + + it "accepts an integer for the destination bytesize" do + lambda { @ec.primitive_convert("","", nil, 0) }.should_not raise_error + end + + it "allows a destination bytesize value greater than the bytesize of the source buffer" do + lambda { @ec.primitive_convert("am","", nil, 3) }.should_not raise_error + end + + it "allows a destination bytesize value less than the bytesize of the source buffer" do + lambda { @ec.primitive_convert("am","", nil, 1) }.should_not raise_error + end + + it "calls #to_int to convert the destination byte size" do + size = mock("encoding primitive_convert destination byte size") + size.should_receive(:to_int).and_return(2) + @ec.primitive_convert("abc", result = " ", 0, size).should == :destination_buffer_full + result.should == "ab" + end + + it "uses destination bytesize as the maximum bytesize of the destination buffer" do + dest = "" + @ec.primitive_convert("glark", dest, nil, 1) + dest.bytesize.should == 1 + end + + it "allows a destination buffer of unlimited size if destination bytesize is nil" do + source = "glark".force_encoding('utf-8') + dest = "" + @ec.primitive_convert("glark", dest, nil, nil) + dest.bytesize.should == source.bytesize + end + + it "accepts an options hash" do + @ec.primitive_convert("","",nil,nil, {after_output: true}).should == :finished + end + + it "sets the destination buffer's encoding to the destination encoding if the conversion succeeded" do + dest = "".force_encoding('utf-8') + dest.encoding.should == Encoding::UTF_8 + @ec.primitive_convert("\u{98}",dest).should == :finished + dest.encoding.should == Encoding::ISO_8859_1 + end + + it "sets the destination buffer's encoding to the destination encoding if the conversion failed" do + dest = "".force_encoding('utf-8') + dest.encoding.should == Encoding::UTF_8 + @ec.primitive_convert("\u{9878}",dest).should == :undefined_conversion + dest.encoding.should == Encoding::ISO_8859_1 + end + + it "removes the undefined part from the source buffer when returning :undefined_conversion" do + dest = "".force_encoding('utf-8') + s = "\u{9878}abcd" + @ec.primitive_convert(s, dest).should == :undefined_conversion + + s.should == "abcd" + end + + it "returns :incomplete_input when source buffer ends unexpectedly and :partial_input isn't specified" do + ec = Encoding::Converter.new("EUC-JP", "ISO-8859-1") + ec.primitive_convert("\xa4", "", nil, nil, partial_input: false).should == :incomplete_input + end + + it "clears the source buffer when returning :incomplete_input" do + ec = Encoding::Converter.new("EUC-JP", "ISO-8859-1") + s = "\xa4" + ec.primitive_convert(s, "").should == :incomplete_input + + s.should == "" + end + + it "returns :source_buffer_empty when source buffer ends unexpectedly and :partial_input is true" do + ec = Encoding::Converter.new("EUC-JP", "ISO-8859-1") + ec.primitive_convert("\xa4", "", nil, nil, partial_input: true).should == :source_buffer_empty + end + + it "clears the source buffer when returning :source_buffer_empty" do + ec = Encoding::Converter.new("EUC-JP", "ISO-8859-1") + s = "\xa4" + ec.primitive_convert(s, "", nil, nil, partial_input: true).should == :source_buffer_empty + + s.should == "" + end + + it "returns :undefined_conversion when a character in the source buffer is not representable in the output encoding" do + @ec.primitive_convert("\u{9876}","").should == :undefined_conversion + end + + it "returns :invalid_byte_sequence when an invalid byte sequence was found in the source buffer" do + @ec.primitive_convert("\xf1abcd","").should == :invalid_byte_sequence + end + + it "removes consumed and erroneous bytes from the source buffer when returning :invalid_byte_sequence" do + ec = Encoding::Converter.new(Encoding::UTF_8, Encoding::UTF_8_MAC) + s = "\xC3\xA1\x80\x80\xC3\xA1".force_encoding("utf-8") + dest = "".force_encoding("utf-8") + ec.primitive_convert(s, dest) + + s.should == "\x80\xC3\xA1".force_encoding("utf-8") + end + + it "returns :finished when the conversion succeeded" do + @ec.primitive_convert("glark".force_encoding('utf-8'),"").should == :finished + end + + it "clears the source buffer when returning :finished" do + s = "glark".force_encoding('utf-8') + @ec.primitive_convert(s, "").should == :finished + + s.should == "" + end + + it "returns :destination_buffer_full when the destination buffer is too small" do + ec = Encoding::Converter.new("utf-8", "iso-2022-jp") + source = "\u{9999}" + destination_bytesize = source.bytesize - 1 + ec.primitive_convert(source, "", 0, destination_bytesize) \ + .should == :destination_buffer_full + source.should == "" + end + + it "clears the source buffer when returning :destination_buffer_full" do + ec = Encoding::Converter.new("utf-8", "iso-2022-jp") + s = "\u{9999}" + destination_bytesize = s.bytesize - 1 + ec.primitive_convert(s, "", 0, destination_bytesize).should == :destination_buffer_full + + s.should == "" + end + + it "keeps removing invalid bytes from the source buffer" do + ec = Encoding::Converter.new(Encoding::UTF_8, Encoding::UTF_8_MAC) + s = "\x80\x80\x80" + dest = "".force_encoding(Encoding::UTF_8_MAC) + + ec.primitive_convert(s, dest) + s.should == "\x80\x80" + ec.primitive_convert(s, dest) + s.should == "\x80" + ec.primitive_convert(s, dest) + s.should == "" + end + + it "reuses read-again bytes after the first error" do + s = "\xf1abcd" + dest = "" + + @ec.primitive_convert(s, dest).should == :invalid_byte_sequence + s.should == "bcd" + @ec.primitive_errinfo[4].should == "a" + + @ec.primitive_convert(s, dest).should == :finished + s.should == "" + + dest.should == "abcd" end end diff --git a/spec/ruby/core/encoding/converter/primitive_errinfo_spec.rb b/spec/ruby/core/encoding/converter/primitive_errinfo_spec.rb index 835e5517e4..e0a5378155 100644 --- a/spec/ruby/core/encoding/converter/primitive_errinfo_spec.rb +++ b/spec/ruby/core/encoding/converter/primitive_errinfo_spec.rb @@ -1,70 +1,68 @@ # -*- encoding: binary -*- require_relative '../../../spec_helper' -with_feature :encoding do - describe "Encoding::Converter#primitive_errinfo" do - it "returns [:source_buffer_empty,nil,nil,nil,nil] when no conversion has been attempted" do - ec = Encoding::Converter.new('ascii','utf-8') - ec.primitive_errinfo.should == [:source_buffer_empty, nil, nil, nil, nil] - end +describe "Encoding::Converter#primitive_errinfo" do + it "returns [:source_buffer_empty,nil,nil,nil,nil] when no conversion has been attempted" do + ec = Encoding::Converter.new('ascii','utf-8') + ec.primitive_errinfo.should == [:source_buffer_empty, nil, nil, nil, nil] + end - it "returns [:finished,nil,nil,nil,nil] when #primitive_convert last returned :finished" do - ec = Encoding::Converter.new('ascii','utf-8') - ec.primitive_convert("a","").should == :finished - ec.primitive_errinfo.should == [:finished, nil, nil, nil, nil] - end + it "returns [:finished,nil,nil,nil,nil] when #primitive_convert last returned :finished" do + ec = Encoding::Converter.new('ascii','utf-8') + ec.primitive_convert("a","").should == :finished + ec.primitive_errinfo.should == [:finished, nil, nil, nil, nil] + end - it "returns [:source_buffer_empty,nil,nil,nil, nil] when #convert last succeeded" do - ec = Encoding::Converter.new('ascii','utf-8') - ec.convert("a".force_encoding('ascii')).should == "a".force_encoding('utf-8') - ec.primitive_errinfo.should == [:source_buffer_empty, nil, nil, nil, nil] - end + it "returns [:source_buffer_empty,nil,nil,nil, nil] when #convert last succeeded" do + ec = Encoding::Converter.new('ascii','utf-8') + ec.convert("a".force_encoding('ascii')).should == "a".force_encoding('utf-8') + ec.primitive_errinfo.should == [:source_buffer_empty, nil, nil, nil, nil] + end - it "returns [:destination_buffer_full,nil,nil,nil,nil] when #primitive_convert last returned :destination_buffer_full" do - ec = Encoding::Converter.new("utf-8", "iso-2022-jp") - ec.primitive_convert("\u{9999}", "", 0, 0, partial_input: false).should == :destination_buffer_full - ec.primitive_errinfo.should == [:destination_buffer_full, nil, nil, nil, nil] - end + it "returns [:destination_buffer_full,nil,nil,nil,nil] when #primitive_convert last returned :destination_buffer_full" do + ec = Encoding::Converter.new("utf-8", "iso-2022-jp") + ec.primitive_convert("\u{9999}", "", 0, 0, partial_input: false).should == :destination_buffer_full + ec.primitive_errinfo.should == [:destination_buffer_full, nil, nil, nil, nil] + end - it "returns the status of the last primitive conversion, even if it was successful and the previous one wasn't" do - ec = Encoding::Converter.new("utf-8", "iso-8859-1") - ec.primitive_convert("\xf1abcd","").should == :invalid_byte_sequence - ec.primitive_convert("glark".force_encoding('utf-8'),"").should == :finished - ec.primitive_errinfo.should == [:finished, nil, nil, nil, nil] - end + it "returns the status of the last primitive conversion, even if it was successful and the previous one wasn't" do + ec = Encoding::Converter.new("utf-8", "iso-8859-1") + ec.primitive_convert("\xf1abcd","").should == :invalid_byte_sequence + ec.primitive_convert("glark".force_encoding('utf-8'),"").should == :finished + ec.primitive_errinfo.should == [:finished, nil, nil, nil, nil] + end - it "returns the state, source encoding, target encoding, and the erroneous bytes when #primitive_convert last returned :undefined_conversion" do - ec = Encoding::Converter.new("utf-8", "iso-8859-1") - ec.primitive_convert("\u{9876}","").should == :undefined_conversion - ec.primitive_errinfo.should == - [:undefined_conversion, "UTF-8", "ISO-8859-1", "\xE9\xA1\xB6", ""] - end + it "returns the state, source encoding, target encoding, and the erroneous bytes when #primitive_convert last returned :undefined_conversion" do + ec = Encoding::Converter.new("utf-8", "iso-8859-1") + ec.primitive_convert("\u{9876}","").should == :undefined_conversion + ec.primitive_errinfo.should == + [:undefined_conversion, "UTF-8", "ISO-8859-1", "\xE9\xA1\xB6", ""] + end - it "returns the state, source encoding, target encoding, and erroneous bytes when #primitive_convert last returned :incomplete_input" do - ec = Encoding::Converter.new("EUC-JP", "ISO-8859-1") - ec.primitive_convert("\xa4", "", nil, 10).should == :incomplete_input - ec.primitive_errinfo.should == [:incomplete_input, "EUC-JP", "UTF-8", "\xA4", ""] - end + it "returns the state, source encoding, target encoding, and erroneous bytes when #primitive_convert last returned :incomplete_input" do + ec = Encoding::Converter.new("EUC-JP", "ISO-8859-1") + ec.primitive_convert("\xa4", "", nil, 10).should == :incomplete_input + ec.primitive_errinfo.should == [:incomplete_input, "EUC-JP", "UTF-8", "\xA4", ""] + end - it "returns the state, source encoding, target encoding, erroneous bytes, and the read-again bytes when #primitive_convert last returned :invalid_byte_sequence" do - ec = Encoding::Converter.new("utf-8", "iso-8859-1") - ec.primitive_convert("\xf1abcd","").should == :invalid_byte_sequence - ec.primitive_errinfo.should == - [:invalid_byte_sequence, "UTF-8", "ISO-8859-1", "\xF1", "a"] - end + it "returns the state, source encoding, target encoding, erroneous bytes, and the read-again bytes when #primitive_convert last returned :invalid_byte_sequence" do + ec = Encoding::Converter.new("utf-8", "iso-8859-1") + ec.primitive_convert("\xf1abcd","").should == :invalid_byte_sequence + ec.primitive_errinfo.should == + [:invalid_byte_sequence, "UTF-8", "ISO-8859-1", "\xF1", "a"] + end - it "returns the state, source encoding, target encoding, erroneous bytes, and the read-again bytes when #convert last raised InvalidByteSequenceError" do - ec = Encoding::Converter.new("utf-8", "iso-8859-1") - lambda { ec.convert("\xf1abcd") }.should raise_error(Encoding::InvalidByteSequenceError) - ec.primitive_errinfo.should == - [:invalid_byte_sequence, "UTF-8", "ISO-8859-1", "\xF1", "a"] - end + it "returns the state, source encoding, target encoding, erroneous bytes, and the read-again bytes when #convert last raised InvalidByteSequenceError" do + ec = Encoding::Converter.new("utf-8", "iso-8859-1") + lambda { ec.convert("\xf1abcd") }.should raise_error(Encoding::InvalidByteSequenceError) + ec.primitive_errinfo.should == + [:invalid_byte_sequence, "UTF-8", "ISO-8859-1", "\xF1", "a"] + end - it "returns the state, source encoding, target encoding, erroneous bytes, and the read-again bytes when #finish last raised InvalidByteSequenceError" do - ec = Encoding::Converter.new("EUC-JP", "ISO-8859-1") - ec.convert("\xa4") - lambda { ec.finish }.should raise_error(Encoding::InvalidByteSequenceError) - ec.primitive_errinfo.should == [:incomplete_input, "EUC-JP", "UTF-8", "\xA4", ""] - end + it "returns the state, source encoding, target encoding, erroneous bytes, and the read-again bytes when #finish last raised InvalidByteSequenceError" do + ec = Encoding::Converter.new("EUC-JP", "ISO-8859-1") + ec.convert("\xa4") + lambda { ec.finish }.should raise_error(Encoding::InvalidByteSequenceError) + ec.primitive_errinfo.should == [:incomplete_input, "EUC-JP", "UTF-8", "\xA4", ""] end end diff --git a/spec/ruby/core/encoding/converter/putback_spec.rb b/spec/ruby/core/encoding/converter/putback_spec.rb index 119ac7b20e..87495eaf3f 100644 --- a/spec/ruby/core/encoding/converter/putback_spec.rb +++ b/spec/ruby/core/encoding/converter/putback_spec.rb @@ -1,49 +1,47 @@ # -*- encoding: binary -*- require_relative '../../../spec_helper' -with_feature :encoding do - describe "Encoding::Converter#putback" do - before :each do - @ec = Encoding::Converter.new("EUC-JP", "ISO-8859-1") - @ret = @ec.primitive_convert(@src="abc\xa1def", @dst="", nil, 10) - end +describe "Encoding::Converter#putback" do + before :each do + @ec = Encoding::Converter.new("EUC-JP", "ISO-8859-1") + @ret = @ec.primitive_convert(@src="abc\xa1def", @dst="", nil, 10) + end - it "returns a String" do - @ec.putback.should be_an_instance_of(String) - end + it "returns a String" do + @ec.putback.should be_an_instance_of(String) + end - it "returns a String in the source encoding" do - @ec.putback.encoding.should == Encoding::EUC_JP - end + it "returns a String in the source encoding" do + @ec.putback.encoding.should == Encoding::EUC_JP + end - it "returns the bytes buffered due to an :invalid_byte_sequence error" do - @ret.should == :invalid_byte_sequence - @ec.putback.should == 'd' - @ec.primitive_errinfo.last.should == 'd' - end + it "returns the bytes buffered due to an :invalid_byte_sequence error" do + @ret.should == :invalid_byte_sequence + @ec.putback.should == 'd' + @ec.primitive_errinfo.last.should == 'd' + end - it "allows conversion to be resumed after an :invalid_byte_sequence" do - @src = @ec.putback + @src - @ret = @ec.primitive_convert(@src, @dst, nil, 10) - @ret.should == :finished - @dst.should == "abcdef" - @src.should == "" - end + it "allows conversion to be resumed after an :invalid_byte_sequence" do + @src = @ec.putback + @src + @ret = @ec.primitive_convert(@src, @dst, nil, 10) + @ret.should == :finished + @dst.should == "abcdef" + @src.should == "" + end - it "returns an empty String when there are no more bytes to put back" do - @ec.putback - @ec.putback.should == "" - end + it "returns an empty String when there are no more bytes to put back" do + @ec.putback + @ec.putback.should == "" + end - it "accepts an integer argument corresponding to the number of bytes to be put back" do - ec = Encoding::Converter.new("utf-16le", "iso-8859-1") - src = "\x00\xd8\x61\x00" - dst = "" - ec.primitive_convert(src, dst).should == :invalid_byte_sequence - ec.primitive_errinfo.should == [:invalid_byte_sequence, "UTF-16LE", "UTF-8", "\x00\xD8", "a\x00"] - ec.putback(1).should == "\x00".force_encoding("utf-16le") - ec.putback.should == "a".force_encoding("utf-16le") - ec.putback.should == "" - end + it "accepts an integer argument corresponding to the number of bytes to be put back" do + ec = Encoding::Converter.new("utf-16le", "iso-8859-1") + src = "\x00\xd8\x61\x00" + dst = "" + ec.primitive_convert(src, dst).should == :invalid_byte_sequence + ec.primitive_errinfo.should == [:invalid_byte_sequence, "UTF-16LE", "UTF-8", "\x00\xD8", "a\x00"] + ec.putback(1).should == "\x00".force_encoding("utf-16le") + ec.putback.should == "a".force_encoding("utf-16le") + ec.putback.should == "" end end diff --git a/spec/ruby/core/encoding/converter/replacement_spec.rb b/spec/ruby/core/encoding/converter/replacement_spec.rb index 506bf5c4af..a23be74e9b 100644 --- a/spec/ruby/core/encoding/converter/replacement_spec.rb +++ b/spec/ruby/core/encoding/converter/replacement_spec.rb @@ -1,74 +1,72 @@ require_relative '../../../spec_helper' -with_feature :encoding do - describe "Encoding::Converter#replacement" do - it "returns '?' in US-ASCII when the destination encoding is not UTF-8" do - ec = Encoding::Converter.new("utf-8", "us-ascii") - ec.replacement.should == "?" - ec.replacement.encoding.should == Encoding::US_ASCII +describe "Encoding::Converter#replacement" do + it "returns '?' in US-ASCII when the destination encoding is not UTF-8" do + ec = Encoding::Converter.new("utf-8", "us-ascii") + ec.replacement.should == "?" + ec.replacement.encoding.should == Encoding::US_ASCII - ec = Encoding::Converter.new("utf-8", "sjis") - ec.replacement.should == "?" - ec.replacement.encoding.should == Encoding::US_ASCII - end + ec = Encoding::Converter.new("utf-8", "sjis") + ec.replacement.should == "?" + ec.replacement.encoding.should == Encoding::US_ASCII + end - it "returns \\uFFFD when the destination encoding is UTF-8" do - ec = Encoding::Converter.new("us-ascii", "utf-8") - ec.replacement.should == "\u{fffd}".force_encoding('utf-8') - ec.replacement.encoding.should == Encoding::UTF_8 - end + it "returns \\uFFFD when the destination encoding is UTF-8" do + ec = Encoding::Converter.new("us-ascii", "utf-8") + ec.replacement.should == "\u{fffd}".force_encoding('utf-8') + ec.replacement.encoding.should == Encoding::UTF_8 end +end - describe "Encoding::Converter#replacement=" do - it "accepts a String argument" do - ec = Encoding::Converter.new("utf-8", "us-ascii") - ec.replacement = "!" - ec.replacement.should == "!" - end +describe "Encoding::Converter#replacement=" do + it "accepts a String argument" do + ec = Encoding::Converter.new("utf-8", "us-ascii") + ec.replacement = "!" + ec.replacement.should == "!" + end - it "accepts a String argument of arbitrary length" do - ec = Encoding::Converter.new("utf-8", "us-ascii") - ec.replacement = "?!?" * 9999 - ec.replacement.should == "?!?" * 9999 - end + it "accepts a String argument of arbitrary length" do + ec = Encoding::Converter.new("utf-8", "us-ascii") + ec.replacement = "?!?" * 9999 + ec.replacement.should == "?!?" * 9999 + end - it "raises a TypeError if assigned a non-String argument" do - ec = Encoding::Converter.new("utf-8", "us-ascii") - lambda { ec.replacement = nil }.should raise_error(TypeError) - end + it "raises a TypeError if assigned a non-String argument" do + ec = Encoding::Converter.new("utf-8", "us-ascii") + lambda { ec.replacement = nil }.should raise_error(TypeError) + end - it "sets #replacement" do - ec = Encoding::Converter.new("us-ascii", "utf-8") - ec.replacement.should == "\u{fffd}".force_encoding('utf-8') - ec.replacement = '?'.encode('utf-8') - ec.replacement.should == '?'.force_encoding('utf-8') - end + it "sets #replacement" do + ec = Encoding::Converter.new("us-ascii", "utf-8") + ec.replacement.should == "\u{fffd}".force_encoding('utf-8') + ec.replacement = '?'.encode('utf-8') + ec.replacement.should == '?'.force_encoding('utf-8') + end - it "raises an UndefinedConversionError is the argument cannot be converted into the destination encoding" do - ec = Encoding::Converter.new("sjis", "ascii") - utf8_q = "\u{986}".force_encoding('utf-8') - ec.primitive_convert(utf8_q.dup, "").should == :undefined_conversion - lambda { ec.replacement = utf8_q }.should \ - raise_error(Encoding::UndefinedConversionError) - end + it "raises an UndefinedConversionError is the argument cannot be converted into the destination encoding" do + ec = Encoding::Converter.new("sjis", "ascii") + utf8_q = "\u{986}".force_encoding('utf-8') + ec.primitive_convert(utf8_q.dup, "").should == :undefined_conversion + lambda { ec.replacement = utf8_q }.should \ + raise_error(Encoding::UndefinedConversionError) + end - it "does not change the replacement character if the argument cannot be converted into the destination encoding" do - ec = Encoding::Converter.new("sjis", "ascii") - utf8_q = "\u{986}".force_encoding('utf-8') - ec.primitive_convert(utf8_q.dup, "").should == :undefined_conversion - lambda { ec.replacement = utf8_q }.should \ - raise_error(Encoding::UndefinedConversionError) - ec.replacement.should == "?".force_encoding('us-ascii') - end + it "does not change the replacement character if the argument cannot be converted into the destination encoding" do + ec = Encoding::Converter.new("sjis", "ascii") + utf8_q = "\u{986}".force_encoding('utf-8') + ec.primitive_convert(utf8_q.dup, "").should == :undefined_conversion + lambda { ec.replacement = utf8_q }.should \ + raise_error(Encoding::UndefinedConversionError) + ec.replacement.should == "?".force_encoding('us-ascii') + end - it "uses the replacement character" do - ec = Encoding::Converter.new("utf-8", "us-ascii", :invalid => :replace, :undef => :replace) - ec.replacement = "!" - dest = "" - status = ec.primitive_convert "中文123", dest + it "uses the replacement character" do + ec = Encoding::Converter.new("utf-8", "us-ascii", :invalid => :replace, :undef => :replace) + ec.replacement = "!" + dest = "" + status = ec.primitive_convert "中文123", dest - status.should == :finished - dest.should == "!!123" - end + status.should == :finished + dest.should == "!!123" end end diff --git a/spec/ruby/core/encoding/converter/search_convpath_spec.rb b/spec/ruby/core/encoding/converter/search_convpath_spec.rb index 09db480642..03cb435528 100644 --- a/spec/ruby/core/encoding/converter/search_convpath_spec.rb +++ b/spec/ruby/core/encoding/converter/search_convpath_spec.rb @@ -1,34 +1,32 @@ require_relative '../../../spec_helper' -with_feature :encoding do - describe "Encoding::Converter.search_convpath" do - it "returns an Array with a single element if there is a direct converter" do - cp = Encoding::Converter.search_convpath('ASCII', 'UTF-8') - cp.should == [[Encoding::US_ASCII, Encoding::UTF_8]] - end +describe "Encoding::Converter.search_convpath" do + it "returns an Array with a single element if there is a direct converter" do + cp = Encoding::Converter.search_convpath('ASCII', 'UTF-8') + cp.should == [[Encoding::US_ASCII, Encoding::UTF_8]] + end - it "returns multiple encoding pairs when direct conversion is impossible" do - cp = Encoding::Converter.search_convpath('ascii','Big5') - cp.should == [ - [Encoding::US_ASCII, Encoding::UTF_8], - [Encoding::UTF_8, Encoding::Big5] - ] - end + it "returns multiple encoding pairs when direct conversion is impossible" do + cp = Encoding::Converter.search_convpath('ascii','Big5') + cp.should == [ + [Encoding::US_ASCII, Encoding::UTF_8], + [Encoding::UTF_8, Encoding::Big5] + ] + end - it "indicates if crlf_newline conversion would occur" do - cp = Encoding::Converter.search_convpath( - "ISO-8859-1", "EUC-JP", {crlf_newline: true}) - cp.last.should == "crlf_newline" + it "indicates if crlf_newline conversion would occur" do + cp = Encoding::Converter.search_convpath( + "ISO-8859-1", "EUC-JP", {crlf_newline: true}) + cp.last.should == "crlf_newline" - cp = Encoding::Converter.search_convpath( - "ASCII", "UTF-8", {crlf_newline: false}) - cp.last.should_not == "crlf_newline" - end + cp = Encoding::Converter.search_convpath( + "ASCII", "UTF-8", {crlf_newline: false}) + cp.last.should_not == "crlf_newline" + end - it "raises an Encoding::ConverterNotFoundError if no conversion path exists" do - lambda do - Encoding::Converter.search_convpath(Encoding::ASCII_8BIT, Encoding::Emacs_Mule) - end.should raise_error(Encoding::ConverterNotFoundError) - end + it "raises an Encoding::ConverterNotFoundError if no conversion path exists" do + lambda do + Encoding::Converter.search_convpath(Encoding::ASCII_8BIT, Encoding::Emacs_Mule) + end.should raise_error(Encoding::ConverterNotFoundError) end end diff --git a/spec/ruby/core/encoding/converter/source_encoding_spec.rb b/spec/ruby/core/encoding/converter/source_encoding_spec.rb index 5abb009dda..6196f717bd 100644 --- a/spec/ruby/core/encoding/converter/source_encoding_spec.rb +++ b/spec/ruby/core/encoding/converter/source_encoding_spec.rb @@ -1,13 +1,11 @@ require_relative '../../../spec_helper' -with_feature :encoding do - describe "Encoding::Converter#source_encoding" do - it "returns the source encoding as an Encoding object" do - ec = Encoding::Converter.new('ASCII','Big5') - ec.source_encoding.should == Encoding::US_ASCII +describe "Encoding::Converter#source_encoding" do + it "returns the source encoding as an Encoding object" do + ec = Encoding::Converter.new('ASCII','Big5') + ec.source_encoding.should == Encoding::US_ASCII - ec = Encoding::Converter.new('Shift_JIS','EUC-JP') - ec.source_encoding.should == Encoding::SHIFT_JIS - end + ec = Encoding::Converter.new('Shift_JIS','EUC-JP') + ec.source_encoding.should == Encoding::SHIFT_JIS end end diff --git a/spec/ruby/core/encoding/default_external_spec.rb b/spec/ruby/core/encoding/default_external_spec.rb index 3de52043e2..8973490901 100644 --- a/spec/ruby/core/encoding/default_external_spec.rb +++ b/spec/ruby/core/encoding/default_external_spec.rb @@ -1,65 +1,63 @@ require_relative '../../spec_helper' -with_feature :encoding do - describe "Encoding.default_external" do - before :each do - @original_encoding = Encoding.default_external - end +describe "Encoding.default_external" do + before :each do + @original_encoding = Encoding.default_external + end - after :each do - Encoding.default_external = @original_encoding - end + after :each do + Encoding.default_external = @original_encoding + end - it "returns an Encoding object" do - Encoding.default_external.should be_an_instance_of(Encoding) - end + it "returns an Encoding object" do + Encoding.default_external.should be_an_instance_of(Encoding) + end - it "returns the default external encoding" do - Encoding.default_external = Encoding::SHIFT_JIS - Encoding.default_external.should == Encoding::SHIFT_JIS - end + it "returns the default external encoding" do + Encoding.default_external = Encoding::SHIFT_JIS + Encoding.default_external.should == Encoding::SHIFT_JIS end +end - describe "Encoding.default_external=" do - before :each do - @original_encoding = Encoding.default_external - end +describe "Encoding.default_external=" do + before :each do + @original_encoding = Encoding.default_external + end - after :each do - Encoding.default_external = @original_encoding - end + after :each do + Encoding.default_external = @original_encoding + end - it "sets the default external encoding" do - Encoding.default_external = Encoding::SHIFT_JIS - Encoding.default_external.should == Encoding::SHIFT_JIS - Encoding.find('external').should == Encoding::SHIFT_JIS - end + it "sets the default external encoding" do + Encoding.default_external = Encoding::SHIFT_JIS + Encoding.default_external.should == Encoding::SHIFT_JIS + Encoding.find('external').should == Encoding::SHIFT_JIS + end - platform_is_not :windows do - it "also sets the filesystem encoding" do - Encoding.default_external = Encoding::SHIFT_JIS - Encoding.find('filesystem').should == Encoding::SHIFT_JIS - end + platform_is_not :windows do + it "also sets the filesystem encoding" do + Encoding.default_external = Encoding::SHIFT_JIS + Encoding.find('filesystem').should == Encoding::SHIFT_JIS end + end - it "can accept a name of an encoding as a String" do - Encoding.default_external = 'Shift_JIS' - Encoding.default_external.should == Encoding::SHIFT_JIS - end + it "can accept a name of an encoding as a String" do + Encoding.default_external = 'Shift_JIS' + Encoding.default_external.should == Encoding::SHIFT_JIS + end - it "calls #to_s on arguments that are neither Strings nor Encodings" do - string = mock('string') - string.should_receive(:to_str).at_least(1).and_return('US-ASCII') - Encoding.default_external = string - Encoding.default_external.should == Encoding::ASCII - end + it "calls #to_s on arguments that are neither Strings nor Encodings" do + string = mock('string') + string.should_receive(:to_str).at_least(1).and_return('US-ASCII') + Encoding.default_external = string + Encoding.default_external.should == Encoding::ASCII + end - it "raises a TypeError unless the argument is an Encoding or convertible to a String" do - lambda { Encoding.default_external = [] }.should raise_error(TypeError) - end + it "raises a TypeError unless the argument is an Encoding or convertible to a String" do + lambda { Encoding.default_external = [] }.should raise_error(TypeError) + end - it "raises an ArgumentError if the argument is nil" do - lambda { Encoding.default_external = nil }.should raise_error(ArgumentError) - end + it "raises an ArgumentError if the argument is nil" do + lambda { Encoding.default_external = nil }.should raise_error(ArgumentError) end end diff --git a/spec/ruby/core/encoding/default_internal_spec.rb b/spec/ruby/core/encoding/default_internal_spec.rb index 5ff475454b..d8bbb2d11d 100644 --- a/spec/ruby/core/encoding/default_internal_spec.rb +++ b/spec/ruby/core/encoding/default_internal_spec.rb @@ -1,76 +1,74 @@ require_relative '../../spec_helper' -with_feature :encoding do - describe "Encoding.default_internal" do - before :each do - @original_encoding = Encoding.default_internal - end - - after :each do - Encoding.default_internal = @original_encoding - end - - it "is nil by default" do - Encoding.default_internal.should be_nil - end - - it "returns an Encoding object if a default internal encoding is set" do - Encoding.default_internal = Encoding::ASCII - Encoding.default_internal.should be_an_instance_of(Encoding) - end - - it "returns nil if no default internal encoding is set" do - Encoding.default_internal = nil - Encoding.default_internal.should be_nil - end - - it "returns the default internal encoding" do - Encoding.default_internal = Encoding::ASCII_8BIT - Encoding.default_internal.should == Encoding::ASCII_8BIT - end +describe "Encoding.default_internal" do + before :each do + @original_encoding = Encoding.default_internal end - describe "Encoding.default_internal=" do - before :each do - @original_encoding = Encoding.default_internal - end + after :each do + Encoding.default_internal = @original_encoding + end + + it "is nil by default" do + Encoding.default_internal.should be_nil + end + + it "returns an Encoding object if a default internal encoding is set" do + Encoding.default_internal = Encoding::ASCII + Encoding.default_internal.should be_an_instance_of(Encoding) + end + + it "returns nil if no default internal encoding is set" do + Encoding.default_internal = nil + Encoding.default_internal.should be_nil + end + + it "returns the default internal encoding" do + Encoding.default_internal = Encoding::ASCII_8BIT + Encoding.default_internal.should == Encoding::ASCII_8BIT + end +end - after :each do - Encoding.default_internal = @original_encoding - end +describe "Encoding.default_internal=" do + before :each do + @original_encoding = Encoding.default_internal + end - it "sets the default internal encoding" do - Encoding.default_internal = Encoding::SHIFT_JIS - Encoding.default_internal.should == Encoding::SHIFT_JIS - end + after :each do + Encoding.default_internal = @original_encoding + end - it "can accept a name of an encoding as a String" do - Encoding.default_internal = 'Shift_JIS' - Encoding.default_internal.should == Encoding::SHIFT_JIS - end + it "sets the default internal encoding" do + Encoding.default_internal = Encoding::SHIFT_JIS + Encoding.default_internal.should == Encoding::SHIFT_JIS + end - it "calls #to_str to convert an object to a String" do - obj = mock('string') - obj.should_receive(:to_str).at_least(1).times.and_return('ascii') + it "can accept a name of an encoding as a String" do + Encoding.default_internal = 'Shift_JIS' + Encoding.default_internal.should == Encoding::SHIFT_JIS + end - Encoding.default_internal = obj - Encoding.default_internal.should == Encoding::ASCII - end + it "calls #to_str to convert an object to a String" do + obj = mock('string') + obj.should_receive(:to_str).at_least(1).times.and_return('ascii') - it "raises a TypeError if #to_str does not return a String" do - obj = mock('string') - obj.should_receive(:to_str).at_least(1).times.and_return(1) + Encoding.default_internal = obj + Encoding.default_internal.should == Encoding::ASCII + end + + it "raises a TypeError if #to_str does not return a String" do + obj = mock('string') + obj.should_receive(:to_str).at_least(1).times.and_return(1) - lambda { Encoding.default_internal = obj }.should raise_error(TypeError) - end + lambda { Encoding.default_internal = obj }.should raise_error(TypeError) + end - it "raises a TypeError when passed an object not providing #to_str" do - lambda { Encoding.default_internal = mock("encoding") }.should raise_error(TypeError) - end + it "raises a TypeError when passed an object not providing #to_str" do + lambda { Encoding.default_internal = mock("encoding") }.should raise_error(TypeError) + end - it "accepts an argument of nil to unset the default internal encoding" do - Encoding.default_internal = nil - Encoding.default_internal.should be_nil - end + it "accepts an argument of nil to unset the default internal encoding" do + Encoding.default_internal = nil + Encoding.default_internal.should be_nil end end diff --git a/spec/ruby/core/encoding/dummy_spec.rb b/spec/ruby/core/encoding/dummy_spec.rb index ef634829d1..75ffcd5a4e 100644 --- a/spec/ruby/core/encoding/dummy_spec.rb +++ b/spec/ruby/core/encoding/dummy_spec.rb @@ -1,16 +1,14 @@ require_relative '../../spec_helper' -with_feature :encoding do - describe "Encoding#dummy?" do - it "returns false for proper encodings" do - Encoding::UTF_8.dummy?.should be_false - Encoding::ASCII.dummy?.should be_false - end +describe "Encoding#dummy?" do + it "returns false for proper encodings" do + Encoding::UTF_8.dummy?.should be_false + Encoding::ASCII.dummy?.should be_false + end - it "returns true for dummy encodings" do - Encoding::ISO_2022_JP.dummy?.should be_true - Encoding::CP50221.dummy?.should be_true - Encoding::UTF_7.dummy?.should be_true - end + it "returns true for dummy encodings" do + Encoding::ISO_2022_JP.dummy?.should be_true + Encoding::CP50221.dummy?.should be_true + Encoding::UTF_7.dummy?.should be_true end end diff --git a/spec/ruby/core/encoding/find_spec.rb b/spec/ruby/core/encoding/find_spec.rb index 3b00de27d4..5635a51c69 100644 --- a/spec/ruby/core/encoding/find_spec.rb +++ b/spec/ruby/core/encoding/find_spec.rb @@ -1,84 +1,82 @@ require_relative '../../spec_helper' -with_feature :encoding do - describe "Encoding.find" do - before :all do - @encodings = Encoding.aliases.to_a.flatten.uniq - end +describe "Encoding.find" do + before :all do + @encodings = Encoding.aliases.to_a.flatten.uniq + end - it "returns the corresponding Encoding object if given a valid encoding name" do - @encodings.each do |enc| - Encoding.find(enc).should be_an_instance_of(Encoding) - end + it "returns the corresponding Encoding object if given a valid encoding name" do + @encodings.each do |enc| + Encoding.find(enc).should be_an_instance_of(Encoding) end + end - it "returns the corresponding Encoding object if given a valid alias name" do - Encoding.aliases.keys.each do |enc_alias| - Encoding.find(enc_alias).should be_an_instance_of(Encoding) - end + it "returns the corresponding Encoding object if given a valid alias name" do + Encoding.aliases.keys.each do |enc_alias| + Encoding.find(enc_alias).should be_an_instance_of(Encoding) end + end - it "raises a TypeError if passed a Symbol" do - lambda { Encoding.find(:"utf-8") }.should raise_error(TypeError) - end + it "raises a TypeError if passed a Symbol" do + lambda { Encoding.find(:"utf-8") }.should raise_error(TypeError) + end - it "returns the passed Encoding object" do - Encoding.find(Encoding::UTF_8).should == Encoding::UTF_8 - end + it "returns the passed Encoding object" do + Encoding.find(Encoding::UTF_8).should == Encoding::UTF_8 + end - it "accepts encoding names as Strings" do - Encoding.list.each do |enc| - Encoding.find(enc.name).should == enc - end + it "accepts encoding names as Strings" do + Encoding.list.each do |enc| + Encoding.find(enc.name).should == enc end + end - it "accepts any object as encoding name, if it responds to #to_str" do - obj = Class.new do - attr_writer :encoding_name - def to_str; @encoding_name; end - end.new + it "accepts any object as encoding name, if it responds to #to_str" do + obj = Class.new do + attr_writer :encoding_name + def to_str; @encoding_name; end + end.new - Encoding.list.each do |enc| - obj.encoding_name = enc.name - Encoding.find(obj).should == enc - end + Encoding.list.each do |enc| + obj.encoding_name = enc.name + Encoding.find(obj).should == enc end + end - it "is case insensitive" do - @encodings.each do |enc| - Encoding.find(enc.upcase).should == Encoding.find(enc) - end + it "is case insensitive" do + @encodings.each do |enc| + Encoding.find(enc.upcase).should == Encoding.find(enc) end + end - it "raises an ArgumentError if the given encoding does not exist" do - lambda { Encoding.find('dh2dh278d') }.should raise_error(ArgumentError) - end + it "raises an ArgumentError if the given encoding does not exist" do + lambda { Encoding.find('dh2dh278d') }.should raise_error(ArgumentError) + end - # Not sure how to do a better test, since locale depends on weird platform-specific stuff - it "supports the 'locale' encoding alias" do - enc = Encoding.find('locale') - enc.should_not == nil - end + # Not sure how to do a better test, since locale depends on weird platform-specific stuff + it "supports the 'locale' encoding alias" do + enc = Encoding.find('locale') + enc.should_not == nil + end - it "returns default external encoding for the 'external' encoding alias" do - enc = Encoding.find('external') - enc.should == Encoding.default_external - end + it "returns default external encoding for the 'external' encoding alias" do + enc = Encoding.find('external') + enc.should == Encoding.default_external + end - it "returns default internal encoding for the 'internal' encoding alias" do - enc = Encoding.find('internal') - enc.should == Encoding.default_internal - end + it "returns default internal encoding for the 'internal' encoding alias" do + enc = Encoding.find('internal') + enc.should == Encoding.default_internal + end - platform_is_not :windows do - it "uses default external encoding for the 'filesystem' encoding alias" do - enc = Encoding.find('filesystem') - enc.should == Encoding.default_external - end + platform_is_not :windows do + it "uses default external encoding for the 'filesystem' encoding alias" do + enc = Encoding.find('filesystem') + enc.should == Encoding.default_external end + end - platform_is :windows do - it "needs to be reviewed for spec completeness" - end + platform_is :windows do + it "needs to be reviewed for spec completeness" end end diff --git a/spec/ruby/core/encoding/inspect_spec.rb b/spec/ruby/core/encoding/inspect_spec.rb index 9da9275eae..9a930b2a77 100644 --- a/spec/ruby/core/encoding/inspect_spec.rb +++ b/spec/ruby/core/encoding/inspect_spec.rb @@ -1,21 +1,19 @@ require_relative '../../spec_helper' -with_feature :encoding do - describe "Encoding#inspect" do - it "returns a String" do - Encoding::UTF_8.inspect.should be_an_instance_of(String) - end +describe "Encoding#inspect" do + it "returns a String" do + Encoding::UTF_8.inspect.should be_an_instance_of(String) + end - it "returns # for a non-dummy encoding named 'name'" do - Encoding.list.to_a.reject {|e| e.dummy? }.each do |enc| - enc.inspect.should =~ /#/ - end + it "returns # for a non-dummy encoding named 'name'" do + Encoding.list.to_a.reject {|e| e.dummy? }.each do |enc| + enc.inspect.should =~ /#/ end + end - it "returns # for a dummy encoding named 'name'" do - Encoding.list.to_a.select {|e| e.dummy? }.each do |enc| - enc.inspect.should =~ /#/ - end + it "returns # for a dummy encoding named 'name'" do + Encoding.list.to_a.select {|e| e.dummy? }.each do |enc| + enc.inspect.should =~ /#/ end end end diff --git a/spec/ruby/core/encoding/invalid_byte_sequence_error/destination_encoding_name_spec.rb b/spec/ruby/core/encoding/invalid_byte_sequence_error/destination_encoding_name_spec.rb index 51c802f7e1..f5fa6f55e3 100644 --- a/spec/ruby/core/encoding/invalid_byte_sequence_error/destination_encoding_name_spec.rb +++ b/spec/ruby/core/encoding/invalid_byte_sequence_error/destination_encoding_name_spec.rb @@ -1,20 +1,18 @@ require_relative '../fixtures/classes' -with_feature :encoding do - describe "Encoding::InvalidByteSequenceError#destination_encoding_name" do - before :each do - @exception, = EncodingSpecs::InvalidByteSequenceError.exception - @exception2, = EncodingSpecs::InvalidByteSequenceErrorIndirect.exception - end +describe "Encoding::InvalidByteSequenceError#destination_encoding_name" do + before :each do + @exception, = EncodingSpecs::InvalidByteSequenceError.exception + @exception2, = EncodingSpecs::InvalidByteSequenceErrorIndirect.exception + end - it "returns a String" do - @exception.destination_encoding_name.should be_an_instance_of(String) - @exception2.destination_encoding_name.should be_an_instance_of(String) - end + it "returns a String" do + @exception.destination_encoding_name.should be_an_instance_of(String) + @exception2.destination_encoding_name.should be_an_instance_of(String) + end - it "is equal to the destination encoding name of the object that raised it" do - @exception.destination_encoding_name.should == "ISO-8859-1" - @exception2.destination_encoding_name.should == "UTF-8" - end + it "is equal to the destination encoding name of the object that raised it" do + @exception.destination_encoding_name.should == "ISO-8859-1" + @exception2.destination_encoding_name.should == "UTF-8" end end diff --git a/spec/ruby/core/encoding/invalid_byte_sequence_error/destination_encoding_spec.rb b/spec/ruby/core/encoding/invalid_byte_sequence_error/destination_encoding_spec.rb index d9e63a6779..43be3ddd71 100644 --- a/spec/ruby/core/encoding/invalid_byte_sequence_error/destination_encoding_spec.rb +++ b/spec/ruby/core/encoding/invalid_byte_sequence_error/destination_encoding_spec.rb @@ -1,20 +1,18 @@ require_relative '../fixtures/classes' -with_feature :encoding do - describe "Encoding::InvalidByteSequenceError#destination_encoding" do - before :each do - @exception, = EncodingSpecs::InvalidByteSequenceError.exception - @exception2, = EncodingSpecs::InvalidByteSequenceErrorIndirect.exception - end +describe "Encoding::InvalidByteSequenceError#destination_encoding" do + before :each do + @exception, = EncodingSpecs::InvalidByteSequenceError.exception + @exception2, = EncodingSpecs::InvalidByteSequenceErrorIndirect.exception + end - it "returns an Encoding object" do - @exception.destination_encoding.should be_an_instance_of(Encoding) - @exception2.destination_encoding.should be_an_instance_of(Encoding) - end + it "returns an Encoding object" do + @exception.destination_encoding.should be_an_instance_of(Encoding) + @exception2.destination_encoding.should be_an_instance_of(Encoding) + end - it "is equal to the destination encoding of the object that raised it" do - @exception.destination_encoding.should == Encoding::ISO_8859_1 - @exception2.destination_encoding.should == Encoding::UTF_8 - end + it "is equal to the destination encoding of the object that raised it" do + @exception.destination_encoding.should == Encoding::ISO_8859_1 + @exception2.destination_encoding.should == Encoding::UTF_8 end end diff --git a/spec/ruby/core/encoding/invalid_byte_sequence_error/error_bytes_spec.rb b/spec/ruby/core/encoding/invalid_byte_sequence_error/error_bytes_spec.rb index 79b381a370..4b24e1611b 100644 --- a/spec/ruby/core/encoding/invalid_byte_sequence_error/error_bytes_spec.rb +++ b/spec/ruby/core/encoding/invalid_byte_sequence_error/error_bytes_spec.rb @@ -1,32 +1,30 @@ # -*- encoding: binary -*- require_relative '../fixtures/classes' -with_feature :encoding do - describe "Encoding::InvalidByteSequenceError#error_bytes" do - before :each do - @exception, @errinfo = EncodingSpecs::InvalidByteSequenceError.exception - @exception2, @errinfo2 = EncodingSpecs::InvalidByteSequenceErrorIndirect.exception - end +describe "Encoding::InvalidByteSequenceError#error_bytes" do + before :each do + @exception, @errinfo = EncodingSpecs::InvalidByteSequenceError.exception + @exception2, @errinfo2 = EncodingSpecs::InvalidByteSequenceErrorIndirect.exception + end - it "returns a String" do - @exception.error_bytes.should be_an_instance_of(String) - @exception2.error_bytes.should be_an_instance_of(String) - end + it "returns a String" do + @exception.error_bytes.should be_an_instance_of(String) + @exception2.error_bytes.should be_an_instance_of(String) + end - it "returns the bytes that caused the exception" do - @exception.error_bytes.size.should == 1 - @exception.error_bytes.should == "\xF1" - @exception.error_bytes.should == @errinfo[-2] + it "returns the bytes that caused the exception" do + @exception.error_bytes.size.should == 1 + @exception.error_bytes.should == "\xF1" + @exception.error_bytes.should == @errinfo[-2] - @exception2.error_bytes.size.should == 1 - @exception2.error_bytes.should == "\xA1" - @exception2.error_bytes.should == @errinfo2[-2] - end + @exception2.error_bytes.size.should == 1 + @exception2.error_bytes.should == "\xA1" + @exception2.error_bytes.should == @errinfo2[-2] + end - it "uses ASCII-8BIT as the encoding" do - @exception.error_bytes.encoding.should == Encoding::ASCII_8BIT + it "uses ASCII-8BIT as the encoding" do + @exception.error_bytes.encoding.should == Encoding::ASCII_8BIT - @exception2.error_bytes.encoding.should == Encoding::ASCII_8BIT - end + @exception2.error_bytes.encoding.should == Encoding::ASCII_8BIT end end diff --git a/spec/ruby/core/encoding/invalid_byte_sequence_error/incomplete_input_spec.rb b/spec/ruby/core/encoding/invalid_byte_sequence_error/incomplete_input_spec.rb index f89c0d8c03..e3ef3e4557 100644 --- a/spec/ruby/core/encoding/invalid_byte_sequence_error/incomplete_input_spec.rb +++ b/spec/ruby/core/encoding/invalid_byte_sequence_error/incomplete_input_spec.rb @@ -1,31 +1,29 @@ # -*- encoding: binary -*- require_relative '../../../spec_helper' -with_feature :encoding do - describe "Encoding::InvalidByteSequenceError#incomplete_input?" do +describe "Encoding::InvalidByteSequenceError#incomplete_input?" do - it "returns nil by default" do - Encoding::InvalidByteSequenceError.new.incomplete_input?.should be_nil - end + it "returns nil by default" do + Encoding::InvalidByteSequenceError.new.incomplete_input?.should be_nil + end - it "returns true if #primitive_convert returned :incomplete_input for the same data" do - ec = Encoding::Converter.new("EUC-JP", "ISO-8859-1") - ec.primitive_convert("\xA1",'').should == :incomplete_input - begin - ec.convert("\xA1") - rescue Encoding::InvalidByteSequenceError => e - e.incomplete_input?.should be_true - end + it "returns true if #primitive_convert returned :incomplete_input for the same data" do + ec = Encoding::Converter.new("EUC-JP", "ISO-8859-1") + ec.primitive_convert("\xA1",'').should == :incomplete_input + begin + ec.convert("\xA1") + rescue Encoding::InvalidByteSequenceError => e + e.incomplete_input?.should be_true end + end - it "returns false if #primitive_convert returned :invalid_byte_sequence for the same data" do - ec = Encoding::Converter.new("ascii", "utf-8") - ec.primitive_convert("\xfffffffff",'').should == :invalid_byte_sequence - begin - ec.convert("\xfffffffff") - rescue Encoding::InvalidByteSequenceError => e - e.incomplete_input?.should be_false - end + it "returns false if #primitive_convert returned :invalid_byte_sequence for the same data" do + ec = Encoding::Converter.new("ascii", "utf-8") + ec.primitive_convert("\xfffffffff",'').should == :invalid_byte_sequence + begin + ec.convert("\xfffffffff") + rescue Encoding::InvalidByteSequenceError => e + e.incomplete_input?.should be_false end end end diff --git a/spec/ruby/core/encoding/invalid_byte_sequence_error/readagain_bytes_spec.rb b/spec/ruby/core/encoding/invalid_byte_sequence_error/readagain_bytes_spec.rb index 4270a0647a..6f0ff524f5 100644 --- a/spec/ruby/core/encoding/invalid_byte_sequence_error/readagain_bytes_spec.rb +++ b/spec/ruby/core/encoding/invalid_byte_sequence_error/readagain_bytes_spec.rb @@ -1,32 +1,30 @@ # -*- encoding: binary -*- require_relative '../fixtures/classes' -with_feature :encoding do - describe "Encoding::InvalidByteSequenceError#readagain_bytes" do - before :each do - @exception, @errinfo = EncodingSpecs::InvalidByteSequenceError.exception - @exception2, @errinfo2 = EncodingSpecs::InvalidByteSequenceErrorIndirect.exception - end +describe "Encoding::InvalidByteSequenceError#readagain_bytes" do + before :each do + @exception, @errinfo = EncodingSpecs::InvalidByteSequenceError.exception + @exception2, @errinfo2 = EncodingSpecs::InvalidByteSequenceErrorIndirect.exception + end - it "returns a String" do - @exception.readagain_bytes.should be_an_instance_of(String) - @exception2.readagain_bytes.should be_an_instance_of(String) - end + it "returns a String" do + @exception.readagain_bytes.should be_an_instance_of(String) + @exception2.readagain_bytes.should be_an_instance_of(String) + end - it "returns the bytes to be read again" do - @exception.readagain_bytes.size.should == 1 - @exception.readagain_bytes.should == "a".force_encoding('binary') - @exception.readagain_bytes.should == @errinfo[-1] + it "returns the bytes to be read again" do + @exception.readagain_bytes.size.should == 1 + @exception.readagain_bytes.should == "a".force_encoding('binary') + @exception.readagain_bytes.should == @errinfo[-1] - @exception2.readagain_bytes.size.should == 1 - @exception2.readagain_bytes.should == "\xFF".force_encoding('binary') - @exception2.readagain_bytes.should == @errinfo2[-1] - end + @exception2.readagain_bytes.size.should == 1 + @exception2.readagain_bytes.should == "\xFF".force_encoding('binary') + @exception2.readagain_bytes.should == @errinfo2[-1] + end - it "uses ASCII-8BIT as the encoding" do - @exception.readagain_bytes.encoding.should == Encoding::ASCII_8BIT + it "uses ASCII-8BIT as the encoding" do + @exception.readagain_bytes.encoding.should == Encoding::ASCII_8BIT - @exception2.readagain_bytes.encoding.should == Encoding::ASCII_8BIT - end + @exception2.readagain_bytes.encoding.should == Encoding::ASCII_8BIT end end diff --git a/spec/ruby/core/encoding/invalid_byte_sequence_error/source_encoding_name_spec.rb b/spec/ruby/core/encoding/invalid_byte_sequence_error/source_encoding_name_spec.rb index bd31c03eee..bd3a51cbc5 100644 --- a/spec/ruby/core/encoding/invalid_byte_sequence_error/source_encoding_name_spec.rb +++ b/spec/ruby/core/encoding/invalid_byte_sequence_error/source_encoding_name_spec.rb @@ -1,30 +1,28 @@ require_relative '../fixtures/classes' -with_feature :encoding do - describe "Encoding::UndefinedConversionError#source_encoding_name" do - before :each do - @exception, = EncodingSpecs::UndefinedConversionError.exception - @exception2, = EncodingSpecs::UndefinedConversionErrorIndirect.exception - end +describe "Encoding::UndefinedConversionError#source_encoding_name" do + before :each do + @exception, = EncodingSpecs::UndefinedConversionError.exception + @exception2, = EncodingSpecs::UndefinedConversionErrorIndirect.exception + end - it "returns a String" do - @exception.source_encoding_name.should be_an_instance_of(String) - end + it "returns a String" do + @exception.source_encoding_name.should be_an_instance_of(String) + end - it "is equal to the source encoding name of the object that raised it" do - @exception.source_encoding_name.should == "UTF-8" - end + it "is equal to the source encoding name of the object that raised it" do + @exception.source_encoding_name.should == "UTF-8" + end - # The source encoding specified in the Encoding::Converter constructor may - # differ from the source encoding returned here. What seems to happen is - # that when transcoding along a path with multiple pairs of encodings, the - # last one encountered when the error occurred is returned. So in this - # case, the conversion path is ISO-8859-1 -> UTF-8 -> EUC-JP. The - # conversion from ISO-8859-1 -> UTF-8 succeeded, but the conversion from - # UTF-8 to EUC-JP failed. IOW, it failed when the source encoding was - # UTF-8, so UTF-8 is regarded as the source encoding. - it "is equal to the source encoding at the stage of the conversion path where the error occurred" do - @exception2.source_encoding_name.should == 'UTF-8' - end + # The source encoding specified in the Encoding::Converter constructor may + # differ from the source encoding returned here. What seems to happen is + # that when transcoding along a path with multiple pairs of encodings, the + # last one encountered when the error occurred is returned. So in this + # case, the conversion path is ISO-8859-1 -> UTF-8 -> EUC-JP. The + # conversion from ISO-8859-1 -> UTF-8 succeeded, but the conversion from + # UTF-8 to EUC-JP failed. IOW, it failed when the source encoding was + # UTF-8, so UTF-8 is regarded as the source encoding. + it "is equal to the source encoding at the stage of the conversion path where the error occurred" do + @exception2.source_encoding_name.should == 'UTF-8' end end diff --git a/spec/ruby/core/encoding/invalid_byte_sequence_error/source_encoding_spec.rb b/spec/ruby/core/encoding/invalid_byte_sequence_error/source_encoding_spec.rb index 3f36d504d5..f43d6d5830 100644 --- a/spec/ruby/core/encoding/invalid_byte_sequence_error/source_encoding_spec.rb +++ b/spec/ruby/core/encoding/invalid_byte_sequence_error/source_encoding_spec.rb @@ -1,35 +1,33 @@ require_relative '../fixtures/classes' -with_feature :encoding do - describe "Encoding::InvalidByteSequenceError#source_encoding" do - before :each do - @exception, = EncodingSpecs::InvalidByteSequenceError.exception - @exception2, = EncodingSpecs::InvalidByteSequenceErrorIndirect.exception - end +describe "Encoding::InvalidByteSequenceError#source_encoding" do + before :each do + @exception, = EncodingSpecs::InvalidByteSequenceError.exception + @exception2, = EncodingSpecs::InvalidByteSequenceErrorIndirect.exception + end - it "returns an Encoding object" do - @exception.source_encoding.should be_an_instance_of(Encoding) - @exception2.source_encoding.should be_an_instance_of(Encoding) - end + it "returns an Encoding object" do + @exception.source_encoding.should be_an_instance_of(Encoding) + @exception2.source_encoding.should be_an_instance_of(Encoding) + end - it "is equal to the source encoding of the object that raised it" do - @exception.source_encoding.should == Encoding::UTF_8 - end + it "is equal to the source encoding of the object that raised it" do + @exception.source_encoding.should == Encoding::UTF_8 + end - # The source encoding specified in the Encoding::Converter constructor may - # differ from the source encoding returned here. What seems to happen is - # that when transcoding along a path with multiple pairs of encodings, the - # last one encountered when the error occurred is returned. So in this - # case, the conversion path is EUC-JP -> UTF-8 -> ISO-8859-1. The - # conversions failed with the first pair of encodings (i.e. transcoding - # from EUC-JP to UTF-8, so UTF-8 is regarded as the source encoding; if - # the error had occurred when converting from UTF-8 to ISO-8859-1, UTF-8 - # would have been the source encoding. + # The source encoding specified in the Encoding::Converter constructor may + # differ from the source encoding returned here. What seems to happen is + # that when transcoding along a path with multiple pairs of encodings, the + # last one encountered when the error occurred is returned. So in this + # case, the conversion path is EUC-JP -> UTF-8 -> ISO-8859-1. The + # conversions failed with the first pair of encodings (i.e. transcoding + # from EUC-JP to UTF-8, so UTF-8 is regarded as the source encoding; if + # the error had occurred when converting from UTF-8 to ISO-8859-1, UTF-8 + # would have been the source encoding. - # FIXME: Derive example where the failure occurs at the UTF-8 -> - # ISO-8859-1 case so as to better illustrate the issue - it "is equal to the source encoding at the stage of the conversion path where the error occurred" do - @exception2.source_encoding.should == Encoding::EUC_JP - end + # FIXME: Derive example where the failure occurs at the UTF-8 -> + # ISO-8859-1 case so as to better illustrate the issue + it "is equal to the source encoding at the stage of the conversion path where the error occurred" do + @exception2.source_encoding.should == Encoding::EUC_JP end end diff --git a/spec/ruby/core/encoding/list_spec.rb b/spec/ruby/core/encoding/list_spec.rb index b1e08c7a2e..2a2078974e 100644 --- a/spec/ruby/core/encoding/list_spec.rb +++ b/spec/ruby/core/encoding/list_spec.rb @@ -1,43 +1,41 @@ require_relative '../../spec_helper' -with_feature :encoding do - describe "Encoding.list" do - it "returns an Array" do - Encoding.list.should be_an_instance_of(Array) - end - - it "returns an Array of Encoding objects" do - Encoding.list.each do |enc| - enc.should be_an_instance_of(Encoding) - end - end +describe "Encoding.list" do + it "returns an Array" do + Encoding.list.should be_an_instance_of(Array) + end - it "returns each encoding only once" do - orig = Encoding.list.map {|e| e.name} - orig.should == orig.uniq + it "returns an Array of Encoding objects" do + Encoding.list.each do |enc| + enc.should be_an_instance_of(Encoding) end + end - it "includes the default external encoding" do - Encoding.list.include?(Encoding.default_external).should be_true - end + it "returns each encoding only once" do + orig = Encoding.list.map {|e| e.name} + orig.should == orig.uniq + end - it "does not include any alias names" do - Encoding.aliases.keys.each do |enc_alias| - Encoding.list.include?(enc_alias).should be_false - end - end + it "includes the default external encoding" do + Encoding.list.include?(Encoding.default_external).should be_true + end - it "includes all aliased encodings" do - Encoding.aliases.values.each do |enc_alias| - Encoding.list.include?(Encoding.find(enc_alias)).should be_true - end + it "does not include any alias names" do + Encoding.aliases.keys.each do |enc_alias| + Encoding.list.include?(enc_alias).should be_false end + end - it "includes dummy encodings" do - Encoding.list.select {|e| e.dummy?}.should_not == [] + it "includes all aliased encodings" do + Encoding.aliases.values.each do |enc_alias| + Encoding.list.include?(Encoding.find(enc_alias)).should be_true end + end - # TODO: Find example that illustrates this - it "updates the list when #find is used to load a new encoding" + it "includes dummy encodings" do + Encoding.list.select {|e| e.dummy?}.should_not == [] end + + # TODO: Find example that illustrates this + it "updates the list when #find is used to load a new encoding" end diff --git a/spec/ruby/core/encoding/locale_charmap_spec.rb b/spec/ruby/core/encoding/locale_charmap_spec.rb index 54dad396fd..5963a8beb5 100644 --- a/spec/ruby/core/encoding/locale_charmap_spec.rb +++ b/spec/ruby/core/encoding/locale_charmap_spec.rb @@ -1,47 +1,45 @@ require_relative '../../spec_helper' -with_feature :encoding do - describe "Encoding.locale_charmap" do - it "returns a String" do - Encoding.locale_charmap.should be_an_instance_of(String) - end +describe "Encoding.locale_charmap" do + it "returns a String" do + Encoding.locale_charmap.should be_an_instance_of(String) + end - # FIXME: Get this working on Windows - platform_is :linux do - it "returns a value based on the LC_ALL environment variable" do - old_lc_all = ENV['LC_ALL'] - ENV['LC_ALL'] = 'C' - ruby_exe("print Encoding.locale_charmap").should == 'ANSI_X3.4-1968' - ENV['LC_ALL'] = old_lc_all - end + # FIXME: Get this working on Windows + platform_is :linux do + it "returns a value based on the LC_ALL environment variable" do + old_lc_all = ENV['LC_ALL'] + ENV['LC_ALL'] = 'C' + ruby_exe("print Encoding.locale_charmap").should == 'ANSI_X3.4-1968' + ENV['LC_ALL'] = old_lc_all end + end - platform_is :freebsd, :openbsd, :darwin do - it "returns a value based on the LC_ALL environment variable" do - old_lc_all = ENV['LC_ALL'] - ENV['LC_ALL'] = 'C' - ruby_exe("print Encoding.locale_charmap").should == 'US-ASCII' - ENV['LC_ALL'] = old_lc_all - end + platform_is :freebsd, :openbsd, :darwin do + it "returns a value based on the LC_ALL environment variable" do + old_lc_all = ENV['LC_ALL'] + ENV['LC_ALL'] = 'C' + ruby_exe("print Encoding.locale_charmap").should == 'US-ASCII' + ENV['LC_ALL'] = old_lc_all end + end - platform_is :netbsd do - it "returns a value based on the LC_ALL environment variable" do - old_lc_all = ENV['LC_ALL'] - ENV['LC_ALL'] = 'C' - ruby_exe("print Encoding.locale_charmap").should == '646' - ENV['LC_ALL'] = old_lc_all - end + platform_is :netbsd do + it "returns a value based on the LC_ALL environment variable" do + old_lc_all = ENV['LC_ALL'] + ENV['LC_ALL'] = 'C' + ruby_exe("print Encoding.locale_charmap").should == '646' + ENV['LC_ALL'] = old_lc_all end + end - platform_is :bsd, :darwin, :linux do - it "is unaffected by assigning to ENV['LC_ALL'] in the same process" do - old_charmap = Encoding.locale_charmap - old_lc_all = ENV['LC_ALL'] - ENV['LC_ALL'] = 'C' - Encoding.locale_charmap.should == old_charmap - ENV['LC_ALL'] = old_lc_all - end + platform_is :bsd, :darwin, :linux do + it "is unaffected by assigning to ENV['LC_ALL'] in the same process" do + old_charmap = Encoding.locale_charmap + old_lc_all = ENV['LC_ALL'] + ENV['LC_ALL'] = 'C' + Encoding.locale_charmap.should == old_charmap + ENV['LC_ALL'] = old_lc_all end end end diff --git a/spec/ruby/core/encoding/name_list_spec.rb b/spec/ruby/core/encoding/name_list_spec.rb index 6e02347bfd..836381c4d8 100644 --- a/spec/ruby/core/encoding/name_list_spec.rb +++ b/spec/ruby/core/encoding/name_list_spec.rb @@ -1,25 +1,23 @@ require_relative '../../spec_helper' -with_feature :encoding do - describe "Encoding.name_list" do - it "returns an Array" do - Encoding.name_list.should be_an_instance_of(Array) - end +describe "Encoding.name_list" do + it "returns an Array" do + Encoding.name_list.should be_an_instance_of(Array) + end - it "returns encoding names as Strings" do - Encoding.name_list.each {|e| e.should be_an_instance_of(String) } - end + it "returns encoding names as Strings" do + Encoding.name_list.each {|e| e.should be_an_instance_of(String) } + end - it "includes all aliases" do - Encoding.aliases.keys.each do |enc_alias| - Encoding.name_list.include?(enc_alias).should be_true - end + it "includes all aliases" do + Encoding.aliases.keys.each do |enc_alias| + Encoding.name_list.include?(enc_alias).should be_true end + end - it "includes all non-dummy encodings" do - Encoding.list.each do |enc| - Encoding.name_list.include?(enc.name).should be_true - end + it "includes all non-dummy encodings" do + Encoding.list.each do |enc| + Encoding.name_list.include?(enc.name).should be_true end end end diff --git a/spec/ruby/core/encoding/name_spec.rb b/spec/ruby/core/encoding/name_spec.rb index 1632137f95..5eadb1d2f5 100644 --- a/spec/ruby/core/encoding/name_spec.rb +++ b/spec/ruby/core/encoding/name_spec.rb @@ -1,7 +1,5 @@ require_relative 'shared/name' -with_feature :encoding do - describe "Encoding#name" do - it_behaves_like :encoding_name, :name - end +describe "Encoding#name" do + it_behaves_like :encoding_name, :name end diff --git a/spec/ruby/core/encoding/names_spec.rb b/spec/ruby/core/encoding/names_spec.rb index c0f84c9b2b..9ded043bbb 100644 --- a/spec/ruby/core/encoding/names_spec.rb +++ b/spec/ruby/core/encoding/names_spec.rb @@ -1,37 +1,35 @@ require_relative '../../spec_helper' -with_feature :encoding do - describe "Encoding#names" do - it "returns an Array" do - Encoding.name_list.each do |name| - e = Encoding.find(name) or next - e.names.should be_an_instance_of(Array) - end +describe "Encoding#names" do + it "returns an Array" do + Encoding.name_list.each do |name| + e = Encoding.find(name) or next + e.names.should be_an_instance_of(Array) end + end - it "returns names as Strings" do - Encoding.name_list.each do |name| - e = Encoding.find(name) or next - e.names.each do |this_name| - this_name.should be_an_instance_of(String) - end + it "returns names as Strings" do + Encoding.name_list.each do |name| + e = Encoding.find(name) or next + e.names.each do |this_name| + this_name.should be_an_instance_of(String) end end + end - it "returns #name as the first value" do - Encoding.name_list.each do |name| - e = Encoding.find(name) or next - e.names.first.should == e.name - end + it "returns #name as the first value" do + Encoding.name_list.each do |name| + e = Encoding.find(name) or next + e.names.first.should == e.name end + end - it "includes any aliases the encoding has" do - Encoding.name_list.each do |name| - e = Encoding.find(name) or next - aliases = Encoding.aliases.select{|a,n| n == name}.keys - names = e.names - aliases.each {|a| names.include?(a).should be_true} - end + it "includes any aliases the encoding has" do + Encoding.name_list.each do |name| + e = Encoding.find(name) or next + aliases = Encoding.aliases.select{|a,n| n == name}.keys + names = e.names + aliases.each {|a| names.include?(a).should be_true} end end end diff --git a/spec/ruby/core/encoding/replicate_spec.rb b/spec/ruby/core/encoding/replicate_spec.rb index 2e1d75f1d0..717e9cea72 100644 --- a/spec/ruby/core/encoding/replicate_spec.rb +++ b/spec/ruby/core/encoding/replicate_spec.rb @@ -1,48 +1,46 @@ # -*- encoding: binary -*- require_relative '../../spec_helper' -with_feature :encoding do - describe "Encoding#replicate" do - before :all do - @i = 0 - end +describe "Encoding#replicate" do + before :all do + @i = 0 + end - before :each do - @i += 1 - @prefix = "RS#{@i}" - end + before :each do + @i += 1 + @prefix = "RS#{@i}" + end - it "returns a replica of ASCII" do - name = @prefix + '-ASCII' - e = Encoding::ASCII.replicate(name) - e.name.should == name - "a".force_encoding(e).valid_encoding?.should be_true - "\x80".force_encoding(e).valid_encoding?.should be_false - end + it "returns a replica of ASCII" do + name = @prefix + '-ASCII' + e = Encoding::ASCII.replicate(name) + e.name.should == name + "a".force_encoding(e).valid_encoding?.should be_true + "\x80".force_encoding(e).valid_encoding?.should be_false + end - it "returns a replica of UTF-8" do - name = @prefix + 'UTF-8' - e = Encoding::UTF_8.replicate(name) - e.name.should == name - "a".force_encoding(e).valid_encoding?.should be_true - "\u3042".force_encoding(e).valid_encoding?.should be_true - "\x80".force_encoding(e).valid_encoding?.should be_false - end + it "returns a replica of UTF-8" do + name = @prefix + 'UTF-8' + e = Encoding::UTF_8.replicate(name) + e.name.should == name + "a".force_encoding(e).valid_encoding?.should be_true + "\u3042".force_encoding(e).valid_encoding?.should be_true + "\x80".force_encoding(e).valid_encoding?.should be_false + end - it "returns a replica of UTF-16BE" do - name = @prefix + 'UTF-16-BE' - e = Encoding::UTF_16BE.replicate(name) - e.name.should == name - "a".force_encoding(e).valid_encoding?.should be_false - "\x30\x42".force_encoding(e).valid_encoding?.should be_true - "\x80".force_encoding(e).valid_encoding?.should be_false - end + it "returns a replica of UTF-16BE" do + name = @prefix + 'UTF-16-BE' + e = Encoding::UTF_16BE.replicate(name) + e.name.should == name + "a".force_encoding(e).valid_encoding?.should be_false + "\x30\x42".force_encoding(e).valid_encoding?.should be_true + "\x80".force_encoding(e).valid_encoding?.should be_false + end - it "returns a replica of ISO-2022-JP" do - name = @prefix + 'ISO-2022-JP' - e = Encoding::ISO_2022_JP.replicate(name) - e.name.should == name - e.dummy?.should be_true - end + it "returns a replica of ISO-2022-JP" do + name = @prefix + 'ISO-2022-JP' + e = Encoding::ISO_2022_JP.replicate(name) + e.name.should == name + e.dummy?.should be_true end end diff --git a/spec/ruby/core/encoding/to_s_spec.rb b/spec/ruby/core/encoding/to_s_spec.rb index e554bc3fee..82d282386b 100644 --- a/spec/ruby/core/encoding/to_s_spec.rb +++ b/spec/ruby/core/encoding/to_s_spec.rb @@ -1,7 +1,5 @@ require_relative 'shared/name' -with_feature :encoding do - describe "Encoding#to_s" do - it_behaves_like :encoding_name, :to_s - end +describe "Encoding#to_s" do + it_behaves_like :encoding_name, :to_s end diff --git a/spec/ruby/core/encoding/undefined_conversion_error/destination_encoding_name_spec.rb b/spec/ruby/core/encoding/undefined_conversion_error/destination_encoding_name_spec.rb index a40f295fcf..106fc7ecac 100644 --- a/spec/ruby/core/encoding/undefined_conversion_error/destination_encoding_name_spec.rb +++ b/spec/ruby/core/encoding/undefined_conversion_error/destination_encoding_name_spec.rb @@ -1,17 +1,15 @@ require_relative '../fixtures/classes' -with_feature :encoding do - describe "Encoding::UndefinedConversionError#destination_encoding_name" do - before :each do - @exception = EncodingSpecs::UndefinedConversionError.exception - end +describe "Encoding::UndefinedConversionError#destination_encoding_name" do + before :each do + @exception = EncodingSpecs::UndefinedConversionError.exception + end - it "returns a String" do - @exception.destination_encoding_name.should be_an_instance_of(String) - end + it "returns a String" do + @exception.destination_encoding_name.should be_an_instance_of(String) + end - it "is equal to the destination encoding name of the object that raised it" do - @exception.destination_encoding_name.should == "US-ASCII" - end + it "is equal to the destination encoding name of the object that raised it" do + @exception.destination_encoding_name.should == "US-ASCII" end end diff --git a/spec/ruby/core/encoding/undefined_conversion_error/destination_encoding_spec.rb b/spec/ruby/core/encoding/undefined_conversion_error/destination_encoding_spec.rb index 579b0a37f8..c6e24732fd 100644 --- a/spec/ruby/core/encoding/undefined_conversion_error/destination_encoding_spec.rb +++ b/spec/ruby/core/encoding/undefined_conversion_error/destination_encoding_spec.rb @@ -1,17 +1,15 @@ require_relative '../fixtures/classes' -with_feature :encoding do - describe "Encoding::UndefinedConversionError#destination_encoding" do - before :each do - @exception = EncodingSpecs::UndefinedConversionError.exception - end +describe "Encoding::UndefinedConversionError#destination_encoding" do + before :each do + @exception = EncodingSpecs::UndefinedConversionError.exception + end - it "returns an Encoding object" do - @exception.destination_encoding.should be_an_instance_of(Encoding) - end + it "returns an Encoding object" do + @exception.destination_encoding.should be_an_instance_of(Encoding) + end - it "is equal to the destination encoding of the object that raised it" do - @exception.destination_encoding.should == Encoding::US_ASCII - end + it "is equal to the destination encoding of the object that raised it" do + @exception.destination_encoding.should == Encoding::US_ASCII end end diff --git a/spec/ruby/core/encoding/undefined_conversion_error/error_char_spec.rb b/spec/ruby/core/encoding/undefined_conversion_error/error_char_spec.rb index 740cd17e30..780d81c1ee 100644 --- a/spec/ruby/core/encoding/undefined_conversion_error/error_char_spec.rb +++ b/spec/ruby/core/encoding/undefined_conversion_error/error_char_spec.rb @@ -1,29 +1,27 @@ require_relative '../fixtures/classes' -with_feature :encoding do - describe "Encoding::UndefinedConversionError#error_char" do - before :each do - @exception = EncodingSpecs::UndefinedConversionError.exception - @exception2 = EncodingSpecs::UndefinedConversionErrorIndirect.exception - end +describe "Encoding::UndefinedConversionError#error_char" do + before :each do + @exception = EncodingSpecs::UndefinedConversionError.exception + @exception2 = EncodingSpecs::UndefinedConversionErrorIndirect.exception + end - it "returns a String" do - @exception.error_char.should be_an_instance_of(String) - @exception2.error_char.should be_an_instance_of(String) - end + it "returns a String" do + @exception.error_char.should be_an_instance_of(String) + @exception2.error_char.should be_an_instance_of(String) + end - it "returns the one-character String that caused the exception" do - @exception.error_char.size.should == 1 - @exception.error_char.should == "\u{8765}" + it "returns the one-character String that caused the exception" do + @exception.error_char.size.should == 1 + @exception.error_char.should == "\u{8765}" - @exception2.error_char.size.should == 1 - @exception2.error_char.should == "\u{A0}" - end + @exception2.error_char.size.should == 1 + @exception2.error_char.should == "\u{A0}" + end - it "uses the source encoding" do - @exception.error_char.encoding.should == @exception.source_encoding + it "uses the source encoding" do + @exception.error_char.encoding.should == @exception.source_encoding - @exception2.error_char.encoding.should == @exception2.source_encoding - end + @exception2.error_char.encoding.should == @exception2.source_encoding end end diff --git a/spec/ruby/core/encoding/undefined_conversion_error/source_encoding_name_spec.rb b/spec/ruby/core/encoding/undefined_conversion_error/source_encoding_name_spec.rb index 79a59ff1e9..3b697cb82f 100644 --- a/spec/ruby/core/encoding/undefined_conversion_error/source_encoding_name_spec.rb +++ b/spec/ruby/core/encoding/undefined_conversion_error/source_encoding_name_spec.rb @@ -1,30 +1,28 @@ require_relative '../fixtures/classes' -with_feature :encoding do - describe "Encoding::UndefinedConversionError#source_encoding_name" do - before :each do - @exception = EncodingSpecs::UndefinedConversionError.exception - @exception2 = EncodingSpecs::UndefinedConversionErrorIndirect.exception - end +describe "Encoding::UndefinedConversionError#source_encoding_name" do + before :each do + @exception = EncodingSpecs::UndefinedConversionError.exception + @exception2 = EncodingSpecs::UndefinedConversionErrorIndirect.exception + end - it "returns a String" do - @exception.source_encoding_name.should be_an_instance_of(String) - end + it "returns a String" do + @exception.source_encoding_name.should be_an_instance_of(String) + end - it "is equal to the source encoding name of the object that raised it" do - @exception.source_encoding_name.should == "UTF-8" - end + it "is equal to the source encoding name of the object that raised it" do + @exception.source_encoding_name.should == "UTF-8" + end - # The source encoding specified in the Encoding::Converter constructor may - # differ from the source encoding returned here. What seems to happen is - # that when transcoding along a path with multiple pairs of encodings, the - # last one encountered when the error occurred is returned. So in this - # case, the conversion path is ISO-8859-1 -> UTF-8 -> EUC-JP. The - # conversion from ISO-8859-1 -> UTF-8 succeeded, but the conversion from - # UTF-8 to EUC-JP failed. IOW, it failed when the source encoding was - # UTF-8, so UTF-8 is regarded as the source encoding. - it "is equal to the source encoding at the stage of the conversion path where the error occurred" do - @exception2.source_encoding_name.should == 'UTF-8' - end + # The source encoding specified in the Encoding::Converter constructor may + # differ from the source encoding returned here. What seems to happen is + # that when transcoding along a path with multiple pairs of encodings, the + # last one encountered when the error occurred is returned. So in this + # case, the conversion path is ISO-8859-1 -> UTF-8 -> EUC-JP. The + # conversion from ISO-8859-1 -> UTF-8 succeeded, but the conversion from + # UTF-8 to EUC-JP failed. IOW, it failed when the source encoding was + # UTF-8, so UTF-8 is regarded as the source encoding. + it "is equal to the source encoding at the stage of the conversion path where the error occurred" do + @exception2.source_encoding_name.should == 'UTF-8' end end diff --git a/spec/ruby/core/encoding/undefined_conversion_error/source_encoding_spec.rb b/spec/ruby/core/encoding/undefined_conversion_error/source_encoding_spec.rb index 29be837e13..9101d51e11 100644 --- a/spec/ruby/core/encoding/undefined_conversion_error/source_encoding_spec.rb +++ b/spec/ruby/core/encoding/undefined_conversion_error/source_encoding_spec.rb @@ -1,31 +1,29 @@ require_relative '../fixtures/classes' -with_feature :encoding do - describe "Encoding::UndefinedConversionError#source_encoding" do - before :each do - @exception = EncodingSpecs::UndefinedConversionError.exception - @exception2 = EncodingSpecs::UndefinedConversionErrorIndirect.exception - end +describe "Encoding::UndefinedConversionError#source_encoding" do + before :each do + @exception = EncodingSpecs::UndefinedConversionError.exception + @exception2 = EncodingSpecs::UndefinedConversionErrorIndirect.exception + end - it "returns an Encoding object" do - @exception.source_encoding.should be_an_instance_of(Encoding) - @exception2.source_encoding.should be_an_instance_of(Encoding) - end + it "returns an Encoding object" do + @exception.source_encoding.should be_an_instance_of(Encoding) + @exception2.source_encoding.should be_an_instance_of(Encoding) + end - it "is equal to the source encoding of the object that raised it" do - @exception.source_encoding.should == Encoding::UTF_8 - end + it "is equal to the source encoding of the object that raised it" do + @exception.source_encoding.should == Encoding::UTF_8 + end - # The source encoding specified in the Encoding::Converter constructor may - # differ from the source encoding returned here. What seems to happen is - # that when transcoding along a path with multiple pairs of encodings, the - # last one encountered when the error occurred is returned. So in this - # case, the conversion path is ISO-8859-1 -> UTF-8 -> EUC-JP. The - # conversion from ISO-8859-1 -> UTF-8 succeeded, but the conversion from - # UTF-8 to EUC-JP failed. IOW, it failed when the source encoding was - # UTF-8, so UTF-8 is regarded as the source encoding. - it "is equal to the source encoding at the stage of the conversion path where the error occurred" do - @exception2.source_encoding.should == Encoding::UTF_8 - end + # The source encoding specified in the Encoding::Converter constructor may + # differ from the source encoding returned here. What seems to happen is + # that when transcoding along a path with multiple pairs of encodings, the + # last one encountered when the error occurred is returned. So in this + # case, the conversion path is ISO-8859-1 -> UTF-8 -> EUC-JP. The + # conversion from ISO-8859-1 -> UTF-8 succeeded, but the conversion from + # UTF-8 to EUC-JP failed. IOW, it failed when the source encoding was + # UTF-8, so UTF-8 is regarded as the source encoding. + it "is equal to the source encoding at the stage of the conversion path where the error occurred" do + @exception2.source_encoding.should == Encoding::UTF_8 end end diff --git a/spec/ruby/core/env/element_reference_spec.rb b/spec/ruby/core/env/element_reference_spec.rb index f9b9fe5f49..0a10cd27b8 100644 --- a/spec/ruby/core/env/element_reference_spec.rb +++ b/spec/ruby/core/env/element_reference_spec.rb @@ -27,40 +27,38 @@ describe "ENV.[]" do end end -with_feature :encoding do - describe "ENV.[]" do - before :each do - @variable = "env_element_reference_encoding_specs" +describe "ENV.[]" do + before :each do + @variable = "env_element_reference_encoding_specs" - @external = Encoding.default_external - @internal = Encoding.default_internal + @external = Encoding.default_external + @internal = Encoding.default_internal - Encoding.default_external = Encoding::ASCII_8BIT - end + Encoding.default_external = Encoding::ASCII_8BIT + end - after :each do - Encoding.default_external = @external - Encoding.default_internal = @internal + after :each do + Encoding.default_external = @external + Encoding.default_internal = @internal - ENV.delete @variable - end + ENV.delete @variable + end - it "uses the locale encoding if Encoding.default_internal is nil" do - Encoding.default_internal = nil + it "uses the locale encoding if Encoding.default_internal is nil" do + Encoding.default_internal = nil - locale = Encoding.find('locale') - locale = Encoding::ASCII_8BIT if locale == Encoding::US_ASCII - ENV[@variable] = "\xC3\xB8" - ENV[@variable].encoding.should == locale - end + locale = Encoding.find('locale') + locale = Encoding::ASCII_8BIT if locale == Encoding::US_ASCII + ENV[@variable] = "\xC3\xB8" + ENV[@variable].encoding.should == locale + end - it "transcodes from the locale encoding to Encoding.default_internal if set" do - # We cannot reliably know the locale encoding, so we merely check that - # the result string has the expected encoding. - ENV[@variable] = "" - Encoding.default_internal = Encoding::IBM437 + it "transcodes from the locale encoding to Encoding.default_internal if set" do + # We cannot reliably know the locale encoding, so we merely check that + # the result string has the expected encoding. + ENV[@variable] = "" + Encoding.default_internal = Encoding::IBM437 - ENV[@variable].encoding.should equal(Encoding::IBM437) - end + ENV[@variable].encoding.should equal(Encoding::IBM437) end end diff --git a/spec/ruby/core/env/shared/each.rb b/spec/ruby/core/env/shared/each.rb index d6cbc93f9a..4039dd1f83 100644 --- a/spec/ruby/core/env/shared/each.rb +++ b/spec/ruby/core/env/shared/each.rb @@ -25,39 +25,37 @@ describe :env_each, shared: true do end it_should_behave_like :enumeratorized_with_origin_size - with_feature :encoding do - describe "with encoding" do - before :each do - @external = Encoding.default_external - @internal = Encoding.default_internal + describe "with encoding" do + before :each do + @external = Encoding.default_external + @internal = Encoding.default_internal - Encoding.default_external = Encoding::ASCII_8BIT + Encoding.default_external = Encoding::ASCII_8BIT - @locale_encoding = Encoding.find "locale" - end + @locale_encoding = Encoding.find "locale" + end - after :each do - Encoding.default_external = @external - Encoding.default_internal = @internal - end + after :each do + Encoding.default_external = @external + Encoding.default_internal = @internal + end - it "uses the locale encoding when Encoding.default_internal is nil" do - Encoding.default_internal = nil + it "uses the locale encoding when Encoding.default_internal is nil" do + Encoding.default_internal = nil - ENV.send(@method) do |key, value| - key.encoding.should equal(@locale_encoding) - value.encoding.should equal(@locale_encoding) - end + ENV.send(@method) do |key, value| + key.encoding.should equal(@locale_encoding) + value.encoding.should equal(@locale_encoding) end + end - it "transcodes from the locale encoding to Encoding.default_internal if set" do - Encoding.default_internal = internal = Encoding::IBM437 + it "transcodes from the locale encoding to Encoding.default_internal if set" do + Encoding.default_internal = internal = Encoding::IBM437 - ENV.send(@method) do |key, value| - key.encoding.should equal(internal) - if value.ascii_only? - value.encoding.should equal(internal) - end + ENV.send(@method) do |key, value| + key.encoding.should equal(internal) + if value.ascii_only? + value.encoding.should equal(internal) end end end diff --git a/spec/ruby/core/env/shift_spec.rb b/spec/ruby/core/env/shift_spec.rb index c5ecc3641e..8a74f4ecac 100644 --- a/spec/ruby/core/env/shift_spec.rb +++ b/spec/ruby/core/env/shift_spec.rb @@ -24,36 +24,34 @@ describe "ENV.shift" do end end -with_feature :encoding do - describe "ENV.shift" do - before :each do - @orig = ENV.to_hash - @external = Encoding.default_external - @internal = Encoding.default_internal - - Encoding.default_external = Encoding::ASCII_8BIT - end +describe "ENV.shift" do + before :each do + @orig = ENV.to_hash + @external = Encoding.default_external + @internal = Encoding.default_internal - after :each do - Encoding.default_external = @external - Encoding.default_internal = @internal - ENV.replace @orig - end + Encoding.default_external = Encoding::ASCII_8BIT + end - it "uses the locale encoding if Encoding.default_internal is nil" do - Encoding.default_internal = nil + after :each do + Encoding.default_external = @external + Encoding.default_internal = @internal + ENV.replace @orig + end - pair = ENV.shift - pair.first.encoding.should equal(Encoding.find("locale")) - pair.last.encoding.should equal(Encoding.find("locale")) - end + it "uses the locale encoding if Encoding.default_internal is nil" do + Encoding.default_internal = nil - it "transcodes from the locale encoding to Encoding.default_internal if set" do - Encoding.default_internal = Encoding::IBM437 + pair = ENV.shift + pair.first.encoding.should equal(Encoding.find("locale")) + pair.last.encoding.should equal(Encoding.find("locale")) + end - pair = ENV.shift - pair.first.encoding.should equal(Encoding::IBM437) - pair.last.encoding.should equal(Encoding::IBM437) - end + it "transcodes from the locale encoding to Encoding.default_internal if set" do + Encoding.default_internal = Encoding::IBM437 + + pair = ENV.shift + pair.first.encoding.should equal(Encoding::IBM437) + pair.last.encoding.should equal(Encoding::IBM437) end end diff --git a/spec/ruby/core/fiber/new_spec.rb b/spec/ruby/core/fiber/new_spec.rb index 734db0682e..c2175cb612 100644 --- a/spec/ruby/core/fiber/new_spec.rb +++ b/spec/ruby/core/fiber/new_spec.rb @@ -1,41 +1,39 @@ require_relative '../../spec_helper' -with_feature :fiber do - describe "Fiber.new" do - it "creates a fiber from the given block" do - fiber = Fiber.new {} - fiber.resume - fiber.should be_an_instance_of(Fiber) - end +describe "Fiber.new" do + it "creates a fiber from the given block" do + fiber = Fiber.new {} + fiber.resume + fiber.should be_an_instance_of(Fiber) + end - it "creates a fiber from a subclass" do - class MyFiber < Fiber - end - fiber = MyFiber.new {} - fiber.resume - fiber.should be_an_instance_of(MyFiber) + it "creates a fiber from a subclass" do + class MyFiber < Fiber end + fiber = MyFiber.new {} + fiber.resume + fiber.should be_an_instance_of(MyFiber) + end - it "raises an ArgumentError if called without a block" do - lambda { Fiber.new }.should raise_error(ArgumentError) - end + it "raises an ArgumentError if called without a block" do + lambda { Fiber.new }.should raise_error(ArgumentError) + end - it "does not invoke the block" do - invoked = false - fiber = Fiber.new { invoked = true } - invoked.should be_false - fiber.resume - end + it "does not invoke the block" do + invoked = false + fiber = Fiber.new { invoked = true } + invoked.should be_false + fiber.resume + end - it "closes over lexical environments" do - o = Object.new - def o.f - a = 1 - f = Fiber.new { a = 2 } - f.resume - a - end - o.f.should == 2 + it "closes over lexical environments" do + o = Object.new + def o.f + a = 1 + f = Fiber.new { a = 2 } + f.resume + a end + o.f.should == 2 end end diff --git a/spec/ruby/core/fiber/resume_spec.rb b/spec/ruby/core/fiber/resume_spec.rb index d05e62c455..97495c5059 100644 --- a/spec/ruby/core/fiber/resume_spec.rb +++ b/spec/ruby/core/fiber/resume_spec.rb @@ -1,59 +1,48 @@ require_relative '../../spec_helper' require_relative '../../shared/fiber/resume' -with_feature :fiber do - describe "Fiber#resume" do - it_behaves_like :fiber_resume, :resume +describe "Fiber#resume" do + it_behaves_like :fiber_resume, :resume +end + +describe "Fiber#resume" do + it "raises a FiberError if the Fiber tries to resume itself" do + fiber = Fiber.new { fiber.resume } + -> { fiber.resume }.should raise_error(FiberError, /double resume/) + end + + it "returns control to the calling Fiber if called from one" do + fiber1 = Fiber.new { :fiber1 } + fiber2 = Fiber.new { fiber1.resume; :fiber2 } + fiber2.resume.should == :fiber2 end - describe "Fiber#resume" do - it "raises a FiberError if the Fiber tries to resume itself" do - fiber = Fiber.new { fiber.resume } - -> { fiber.resume }.should raise_error(FiberError, /double resume/) - end - - it "returns control to the calling Fiber if called from one" do - fiber1 = Fiber.new { :fiber1 } - fiber2 = Fiber.new { fiber1.resume; :fiber2 } - fiber2.resume.should == :fiber2 - end - - with_feature :fork do - # Redmine #595 - it "executes the ensure clause" do - rd, wr = IO.pipe - - pid = Kernel::fork do - rd.close - f = Fiber.new do - begin - Fiber.yield - ensure - wr.write "executed" - end - end - - # The apparent issue is that when Fiber.yield executes, control - # "leaves" the "ensure block" and so the ensure clause should run. But - # control really does NOT leave the ensure block when Fiber.yield - # executes. It merely pauses there. To require ensure to run when a - # Fiber is suspended then makes ensure-in-a-Fiber-context different - # than ensure-in-a-Thread-context and this would be very confusing. - f.resume - - # When we execute the second #resume call, the ensure block DOES exit, - # the ensure clause runs. - f.resume - - exit 0 + # Redmine #595 + it "executes the ensure clause" do + code = <<-RUBY + f = Fiber.new do + begin + Fiber.yield + ensure + puts "ensure executed" end + end - wr.close - Process.waitpid pid + # The apparent issue is that when Fiber.yield executes, control + # "leaves" the "ensure block" and so the ensure clause should run. But + # control really does NOT leave the ensure block when Fiber.yield + # executes. It merely pauses there. To require ensure to run when a + # Fiber is suspended then makes ensure-in-a-Fiber-context different + # than ensure-in-a-Thread-context and this would be very confusing. + f.resume - rd.read.should == "executed" - rd.close - end - end + # When we execute the second #resume call, the ensure block DOES exit, + # the ensure clause runs. + f.resume + + exit 0 + RUBY + + ruby_exe(code).should == "ensure executed\n" end end diff --git a/spec/ruby/core/fiber/yield_spec.rb b/spec/ruby/core/fiber/yield_spec.rb index d002b29cf6..4e241d5921 100644 --- a/spec/ruby/core/fiber/yield_spec.rb +++ b/spec/ruby/core/fiber/yield_spec.rb @@ -1,51 +1,49 @@ require_relative '../../spec_helper' -with_feature :fiber do - describe "Fiber.yield" do - it "passes control to the Fiber's caller" do - step = 0 - fiber = Fiber.new { step = 1; Fiber.yield; step = 2; Fiber.yield; step = 3 } - fiber.resume - step.should == 1 - fiber.resume - step.should == 2 - end - - it "returns its arguments to the caller" do - fiber = Fiber.new { true; Fiber.yield :glark; true } - fiber.resume.should == :glark - fiber.resume - end +describe "Fiber.yield" do + it "passes control to the Fiber's caller" do + step = 0 + fiber = Fiber.new { step = 1; Fiber.yield; step = 2; Fiber.yield; step = 3 } + fiber.resume + step.should == 1 + fiber.resume + step.should == 2 + end - it "returns nil to the caller if given no arguments" do - fiber = Fiber.new { true; Fiber.yield; true } - fiber.resume.should be_nil - fiber.resume - end + it "returns its arguments to the caller" do + fiber = Fiber.new { true; Fiber.yield :glark; true } + fiber.resume.should == :glark + fiber.resume + end - it "returns to the Fiber the value of the #resume call that invoked it" do - fiber = Fiber.new { Fiber.yield.should == :caller } - fiber.resume - fiber.resume :caller - end + it "returns nil to the caller if given no arguments" do + fiber = Fiber.new { true; Fiber.yield; true } + fiber.resume.should be_nil + fiber.resume + end - it "does not propagate or reraise a rescued exception" do - fiber = Fiber.new do - begin - raise "an error in a Fiber" - rescue - Fiber.yield :first - end + it "returns to the Fiber the value of the #resume call that invoked it" do + fiber = Fiber.new { Fiber.yield.should == :caller } + fiber.resume + fiber.resume :caller + end - :second + it "does not propagate or reraise a rescued exception" do + fiber = Fiber.new do + begin + raise "an error in a Fiber" + rescue + Fiber.yield :first end - fiber.resume.should == :first - fiber.resume.should == :second + :second end - it "raises a FiberError if called from the root Fiber" do - lambda{ Fiber.yield }.should raise_error(FiberError) - end + fiber.resume.should == :first + fiber.resume.should == :second + end + + it "raises a FiberError if called from the root Fiber" do + lambda{ Fiber.yield }.should raise_error(FiberError) end end diff --git a/spec/ruby/core/file/basename_spec.rb b/spec/ruby/core/file/basename_spec.rb index 671955302a..50365b1125 100644 --- a/spec/ruby/core/file/basename_spec.rb +++ b/spec/ruby/core/file/basename_spec.rb @@ -153,18 +153,16 @@ describe "File.basename" do end end - with_feature :encoding do - it "returns the extension for a multibyte filename" do - File.basename('/path/Офис.m4a').should == "Офис.m4a" - end - - it "returns the basename with the same encoding as the original" do - basename = File.basename('C:/Users/Scuby Pagrubý'.encode(Encoding::Windows_1250)) - basename.should == 'Scuby Pagrubý'.encode(Encoding::Windows_1250) - basename.encoding.should == Encoding::Windows_1250 - end + it "returns the extension for a multibyte filename" do + File.basename('/path/Офис.m4a').should == "Офис.m4a" + end + it "returns the basename with the same encoding as the original" do + basename = File.basename('C:/Users/Scuby Pagrubý'.encode(Encoding::Windows_1250)) + basename.should == 'Scuby Pagrubý'.encode(Encoding::Windows_1250) + basename.encoding.should == Encoding::Windows_1250 end + end diff --git a/spec/ruby/core/file/expand_path_spec.rb b/spec/ruby/core/file/expand_path_spec.rb index 5bb60d2c23..90aa44e2c4 100644 --- a/spec/ruby/core/file/expand_path_spec.rb +++ b/spec/ruby/core/file/expand_path_spec.rb @@ -19,14 +19,12 @@ describe "File.expand_path" do end end - with_feature :encoding do - before :each do - @external = Encoding.default_external - end + before :each do + @external = Encoding.default_external + end - after :each do - Encoding.default_external = @external - end + after :each do + Encoding.default_external = @external end it "converts a pathname to an absolute pathname" do @@ -136,34 +134,32 @@ describe "File.expand_path" do end end - with_feature :encoding do - it "returns a String in the same encoding as the argument" do - Encoding.default_external = Encoding::SHIFT_JIS + it "returns a String in the same encoding as the argument" do + Encoding.default_external = Encoding::SHIFT_JIS - path = "./a".force_encoding Encoding::CP1251 - File.expand_path(path).encoding.should equal(Encoding::CP1251) + path = "./a".force_encoding Encoding::CP1251 + File.expand_path(path).encoding.should equal(Encoding::CP1251) - weird_path = [222, 173, 190, 175].pack('C*') - File.expand_path(weird_path).encoding.should equal(Encoding::ASCII_8BIT) - end + weird_path = [222, 173, 190, 175].pack('C*') + File.expand_path(weird_path).encoding.should equal(Encoding::ASCII_8BIT) + end - platform_is_not :windows do - it "expands a path when the default external encoding is ASCII-8BIT" do - Encoding.default_external = Encoding::ASCII_8BIT - path_8bit = [222, 173, 190, 175].pack('C*') - File.expand_path( path_8bit, @rootdir).should == "#{@rootdir}" + path_8bit - end + platform_is_not :windows do + it "expands a path when the default external encoding is ASCII-8BIT" do + Encoding.default_external = Encoding::ASCII_8BIT + path_8bit = [222, 173, 190, 175].pack('C*') + File.expand_path( path_8bit, @rootdir).should == "#{@rootdir}" + path_8bit end + end - it "expands a path with multi-byte characters" do - File.expand_path("Ångström").should == "#{@base}/Ångström" - end + it "expands a path with multi-byte characters" do + File.expand_path("Ångström").should == "#{@base}/Ångström" + end - platform_is_not :windows do - it "raises an Encoding::CompatibilityError if the external encoding is not compatible" do - Encoding.default_external = Encoding::UTF_16BE - lambda { File.expand_path("./a") }.should raise_error(Encoding::CompatibilityError) - end + platform_is_not :windows do + it "raises an Encoding::CompatibilityError if the external encoding is not compatible" do + Encoding.default_external = Encoding::UTF_16BE + lambda { File.expand_path("./a") }.should raise_error(Encoding::CompatibilityError) end end diff --git a/spec/ruby/core/file/extname_spec.rb b/spec/ruby/core/file/extname_spec.rb index 1513b30e90..7632b6adc0 100644 --- a/spec/ruby/core/file/extname_spec.rb +++ b/spec/ruby/core/file/extname_spec.rb @@ -44,11 +44,9 @@ describe "File.extname" do lambda { File.extname("foo.bar", "foo.baz") }.should raise_error(ArgumentError) end - with_feature :encoding do - - it "returns the extension for a multibyte filename" do - File.extname('Имя.m4a').should == ".m4a" - end + it "returns the extension for a multibyte filename" do + File.extname('Имя.m4a').should == ".m4a" end + end diff --git a/spec/ruby/core/file/open_spec.rb b/spec/ruby/core/file/open_spec.rb index 9e98d3d88a..14be5aa32a 100644 --- a/spec/ruby/core/file/open_spec.rb +++ b/spec/ruby/core/file/open_spec.rb @@ -165,23 +165,6 @@ describe "File.open" do File.exist?(@file).should == true end - without_feature :mjit do # [ruby-core:90895] MJIT worker may leave fd open in a forked child. TODO: consider acquiring GVL from MJIT worker. - it "opens a file with a file descriptor d and a block" do - @fh = File.open(@file) - @fh.should be_kind_of(File) - - lambda { - File.open(@fh.fileno) do |fh| - @fd = fh.fileno - @fh.close - end - }.should raise_error(Errno::EBADF) - lambda { File.open(@fd) }.should raise_error(Errno::EBADF) - - File.exist?(@file).should == true - end - end - it "opens a file that no exists when use File::WRONLY mode" do lambda { File.open(@nonexistent, File::WRONLY) }.should raise_error(Errno::ENOENT) end @@ -673,7 +656,7 @@ describe "File.open when passed a file descriptor" do before do @content = "File#open when passed a file descriptor" @name = tmp("file_open_with_fd.txt") - @fd = new_fd @name, fmode("w:utf-8") + @fd = new_fd @name, "w:utf-8" @file = nil end diff --git a/spec/ruby/core/file/shared/path.rb b/spec/ruby/core/file/shared/path.rb index 503e485f1e..9df3416c89 100644 --- a/spec/ruby/core/file/shared/path.rb +++ b/spec/ruby/core/file/shared/path.rb @@ -44,12 +44,10 @@ describe :file_path, shared: true do end end - with_feature :encoding do - it "preserves the encoding of the path" do - path = @path.force_encoding("euc-jp") - @file = File.new path - @file.send(@method).encoding.should == Encoding.find("euc-jp") - end + it "preserves the encoding of the path" do + path = @path.force_encoding("euc-jp") + @file = File.new path + @file.send(@method).encoding.should == Encoding.find("euc-jp") end ruby_version_is "2.5" do diff --git a/spec/ruby/core/float/to_s_spec.rb b/spec/ruby/core/float/to_s_spec.rb index db375bfc0e..ad04bc4fb6 100644 --- a/spec/ruby/core/float/to_s_spec.rb +++ b/spec/ruby/core/float/to_s_spec.rb @@ -289,24 +289,22 @@ describe "Float#to_s" do end end -with_feature :encoding do - describe "Float#to_s" do - before :each do - @internal = Encoding.default_internal - end +describe "Float#to_s" do + before :each do + @internal = Encoding.default_internal + end - after :each do - Encoding.default_internal = @internal - end + after :each do + Encoding.default_internal = @internal + end - it "returns a String in US-ASCII encoding when Encoding.default_internal is nil" do - Encoding.default_internal = nil - 1.23.to_s.encoding.should equal(Encoding::US_ASCII) - end + it "returns a String in US-ASCII encoding when Encoding.default_internal is nil" do + Encoding.default_internal = nil + 1.23.to_s.encoding.should equal(Encoding::US_ASCII) + end - it "returns a String in US-ASCII encoding when Encoding.default_internal is not nil" do - Encoding.default_internal = Encoding::IBM437 - 5.47.to_s.encoding.should equal(Encoding::US_ASCII) - end + it "returns a String in US-ASCII encoding when Encoding.default_internal is not nil" do + Encoding.default_internal = Encoding::IBM437 + 5.47.to_s.encoding.should equal(Encoding::US_ASCII) end end diff --git a/spec/ruby/core/integer/to_s_spec.rb b/spec/ruby/core/integer/to_s_spec.rb index c980be535a..687dc9d18f 100644 --- a/spec/ruby/core/integer/to_s_spec.rb +++ b/spec/ruby/core/integer/to_s_spec.rb @@ -29,24 +29,22 @@ describe "Integer#to_s" do end end - with_feature :encoding do - before :each do - @internal = Encoding.default_internal - end + before :each do + @internal = Encoding.default_internal + end - after :each do - Encoding.default_internal = @internal - end + after :each do + Encoding.default_internal = @internal + end - it "returns a String in US-ASCII encoding when Encoding.default_internal is nil" do - Encoding.default_internal = nil - 1.to_s.encoding.should equal(Encoding::US_ASCII) - end + it "returns a String in US-ASCII encoding when Encoding.default_internal is nil" do + Encoding.default_internal = nil + 1.to_s.encoding.should equal(Encoding::US_ASCII) + end - it "returns a String in US-ASCII encoding when Encoding.default_internal is not nil" do - Encoding.default_internal = Encoding::IBM437 - 1.to_s.encoding.should equal(Encoding::US_ASCII) - end + it "returns a String in US-ASCII encoding when Encoding.default_internal is not nil" do + Encoding.default_internal = Encoding::IBM437 + 1.to_s.encoding.should equal(Encoding::US_ASCII) end end @@ -76,24 +74,22 @@ describe "Integer#to_s" do end end - with_feature :encoding do - before :each do - @internal = Encoding.default_internal - end + before :each do + @internal = Encoding.default_internal + end - after :each do - Encoding.default_internal = @internal - end + after :each do + Encoding.default_internal = @internal + end - it "returns a String in US-ASCII encoding when Encoding.default_internal is nil" do - Encoding.default_internal = nil - bignum_value.to_s.encoding.should equal(Encoding::US_ASCII) - end + it "returns a String in US-ASCII encoding when Encoding.default_internal is nil" do + Encoding.default_internal = nil + bignum_value.to_s.encoding.should equal(Encoding::US_ASCII) + end - it "returns a String in US-ASCII encoding when Encoding.default_internal is not nil" do - Encoding.default_internal = Encoding::IBM437 - bignum_value.to_s.encoding.should equal(Encoding::US_ASCII) - end + it "returns a String in US-ASCII encoding when Encoding.default_internal is not nil" do + Encoding.default_internal = Encoding::IBM437 + bignum_value.to_s.encoding.should equal(Encoding::US_ASCII) end end end diff --git a/spec/ruby/core/io/external_encoding_spec.rb b/spec/ruby/core/io/external_encoding_spec.rb index e625484670..3581019207 100644 --- a/spec/ruby/core/io/external_encoding_spec.rb +++ b/spec/ruby/core/io/external_encoding_spec.rb @@ -1,218 +1,216 @@ require_relative '../../spec_helper' -with_feature :encoding do - describe :io_external_encoding_write, shared: true do +describe :io_external_encoding_write, shared: true do + describe "when Encoding.default_internal is nil" do + before :each do + Encoding.default_internal = nil + end + + it "returns nil" do + @io = new_io @name, @object + Encoding.default_external = Encoding::IBM437 + @io.external_encoding.should be_nil + end + + it "returns the external encoding specified when the instance was created" do + @io = new_io @name, "#{@object}:ibm866" + Encoding.default_external = Encoding::IBM437 + @io.external_encoding.should equal(Encoding::IBM866) + end + + it "returns the encoding set by #set_encoding" do + @io = new_io @name, "#{@object}:ibm866" + @io.set_encoding Encoding::EUC_JP, nil + @io.external_encoding.should equal(Encoding::EUC_JP) + end + end + + describe "when Encoding.default_external != Encoding.default_internal" do + before :each do + Encoding.default_external = Encoding::IBM437 + Encoding.default_internal = Encoding::IBM866 + end + + it "returns the value of Encoding.default_external when the instance was created" do + @io = new_io @name, @object + Encoding.default_external = Encoding::UTF_8 + @io.external_encoding.should equal(Encoding::IBM437) + end + + it "returns the external encoding specified when the instance was created" do + @io = new_io @name, "#{@object}:ibm866" + Encoding.default_external = Encoding::IBM437 + @io.external_encoding.should equal(Encoding::IBM866) + end + + it "returns the encoding set by #set_encoding" do + @io = new_io @name, "#{@object}:ibm866" + @io.set_encoding Encoding::EUC_JP, nil + @io.external_encoding.should equal(Encoding::EUC_JP) + end + end + + describe "when Encoding.default_external == Encoding.default_internal" do + before :each do + Encoding.default_external = Encoding::IBM866 + Encoding.default_internal = Encoding::IBM866 + end + + it "returns the value of Encoding.default_external when the instance was created" do + @io = new_io @name, @object + Encoding.default_external = Encoding::UTF_8 + @io.external_encoding.should equal(Encoding::IBM866) + end + + it "returns the external encoding specified when the instance was created" do + @io = new_io @name, "#{@object}:ibm866" + Encoding.default_external = Encoding::IBM437 + @io.external_encoding.should equal(Encoding::IBM866) + end + + it "returns the encoding set by #set_encoding" do + @io = new_io @name, "#{@object}:ibm866" + @io.set_encoding Encoding::EUC_JP, nil + @io.external_encoding.should equal(Encoding::EUC_JP) + end + end +end + +describe "IO#external_encoding" do + before :each do + @external = Encoding.default_external + @internal = Encoding.default_internal + + @name = tmp("io_external_encoding") + touch(@name) + end + + after :each do + Encoding.default_external = @external + Encoding.default_internal = @internal + + @io.close if @io + rm_r @name + end + + describe "with 'r' mode" do describe "when Encoding.default_internal is nil" do before :each do Encoding.default_internal = nil + Encoding.default_external = Encoding::IBM866 end - it "returns nil" do - @io = new_io @name, @object + it "returns Encoding.default_external if the external encoding is not set" do + @io = new_io @name, "r" + @io.external_encoding.should equal(Encoding::IBM866) + end + + it "returns Encoding.default_external when that encoding is changed after the instance is created" do + @io = new_io @name, "r" Encoding.default_external = Encoding::IBM437 - @io.external_encoding.should be_nil + @io.external_encoding.should equal(Encoding::IBM437) end it "returns the external encoding specified when the instance was created" do - @io = new_io @name, "#{@object}:ibm866" + @io = new_io @name, "r:utf-8" Encoding.default_external = Encoding::IBM437 - @io.external_encoding.should equal(Encoding::IBM866) + @io.external_encoding.should equal(Encoding::UTF_8) end it "returns the encoding set by #set_encoding" do - @io = new_io @name, "#{@object}:ibm866" + @io = new_io @name, "r:utf-8" @io.set_encoding Encoding::EUC_JP, nil @io.external_encoding.should equal(Encoding::EUC_JP) end end - describe "when Encoding.default_external != Encoding.default_internal" do + describe "when Encoding.default_external == Encoding.default_internal" do before :each do - Encoding.default_external = Encoding::IBM437 + Encoding.default_external = Encoding::IBM866 Encoding.default_internal = Encoding::IBM866 end it "returns the value of Encoding.default_external when the instance was created" do - @io = new_io @name, @object - Encoding.default_external = Encoding::UTF_8 - @io.external_encoding.should equal(Encoding::IBM437) + @io = new_io @name, "r" + Encoding.default_external = Encoding::IBM437 + @io.external_encoding.should equal(Encoding::IBM866) end it "returns the external encoding specified when the instance was created" do - @io = new_io @name, "#{@object}:ibm866" + @io = new_io @name, "r:utf-8" Encoding.default_external = Encoding::IBM437 - @io.external_encoding.should equal(Encoding::IBM866) + @io.external_encoding.should equal(Encoding::UTF_8) end it "returns the encoding set by #set_encoding" do - @io = new_io @name, "#{@object}:ibm866" + @io = new_io @name, "r:utf-8" @io.set_encoding Encoding::EUC_JP, nil @io.external_encoding.should equal(Encoding::EUC_JP) end end - describe "when Encoding.default_external == Encoding.default_internal" do + describe "when Encoding.default_external != Encoding.default_internal" do before :each do - Encoding.default_external = Encoding::IBM866 + Encoding.default_external = Encoding::IBM437 Encoding.default_internal = Encoding::IBM866 end - it "returns the value of Encoding.default_external when the instance was created" do - @io = new_io @name, @object - Encoding.default_external = Encoding::UTF_8 - @io.external_encoding.should equal(Encoding::IBM866) - end it "returns the external encoding specified when the instance was created" do - @io = new_io @name, "#{@object}:ibm866" + @io = new_io @name, "r:utf-8" Encoding.default_external = Encoding::IBM437 - @io.external_encoding.should equal(Encoding::IBM866) + @io.external_encoding.should equal(Encoding::UTF_8) end it "returns the encoding set by #set_encoding" do - @io = new_io @name, "#{@object}:ibm866" + @io = new_io @name, "r:utf-8" @io.set_encoding Encoding::EUC_JP, nil @io.external_encoding.should equal(Encoding::EUC_JP) end end end - describe "IO#external_encoding" do - before :each do - @external = Encoding.default_external - @internal = Encoding.default_internal - - @name = tmp("io_external_encoding") - touch(@name) - end - - after :each do - Encoding.default_external = @external - Encoding.default_internal = @internal - - @io.close if @io - rm_r @name - end - - describe "with 'r' mode" do - describe "when Encoding.default_internal is nil" do - before :each do - Encoding.default_internal = nil - Encoding.default_external = Encoding::IBM866 - end - - it "returns Encoding.default_external if the external encoding is not set" do - @io = new_io @name, "r" - @io.external_encoding.should equal(Encoding::IBM866) - end - - it "returns Encoding.default_external when that encoding is changed after the instance is created" do - @io = new_io @name, "r" - Encoding.default_external = Encoding::IBM437 - @io.external_encoding.should equal(Encoding::IBM437) - end - - it "returns the external encoding specified when the instance was created" do - @io = new_io @name, "r:utf-8" - Encoding.default_external = Encoding::IBM437 - @io.external_encoding.should equal(Encoding::UTF_8) - end - - it "returns the encoding set by #set_encoding" do - @io = new_io @name, "r:utf-8" - @io.set_encoding Encoding::EUC_JP, nil - @io.external_encoding.should equal(Encoding::EUC_JP) - end - end - - describe "when Encoding.default_external == Encoding.default_internal" do - before :each do - Encoding.default_external = Encoding::IBM866 - Encoding.default_internal = Encoding::IBM866 - end - - it "returns the value of Encoding.default_external when the instance was created" do - @io = new_io @name, "r" - Encoding.default_external = Encoding::IBM437 - @io.external_encoding.should equal(Encoding::IBM866) - end - - it "returns the external encoding specified when the instance was created" do - @io = new_io @name, "r:utf-8" - Encoding.default_external = Encoding::IBM437 - @io.external_encoding.should equal(Encoding::UTF_8) - end - - it "returns the encoding set by #set_encoding" do - @io = new_io @name, "r:utf-8" - @io.set_encoding Encoding::EUC_JP, nil - @io.external_encoding.should equal(Encoding::EUC_JP) - end - end - - describe "when Encoding.default_external != Encoding.default_internal" do - before :each do - Encoding.default_external = Encoding::IBM437 - Encoding.default_internal = Encoding::IBM866 - end - - - it "returns the external encoding specified when the instance was created" do - @io = new_io @name, "r:utf-8" - Encoding.default_external = Encoding::IBM437 - @io.external_encoding.should equal(Encoding::UTF_8) - end - - it "returns the encoding set by #set_encoding" do - @io = new_io @name, "r:utf-8" - @io.set_encoding Encoding::EUC_JP, nil - @io.external_encoding.should equal(Encoding::EUC_JP) - end - end + describe "with 'rb' mode" do + it "returns Encoding::ASCII_8BIT" do + @io = new_io @name, "rb" + @io.external_encoding.should equal(Encoding::ASCII_8BIT) end - describe "with 'rb' mode" do - it "returns Encoding::ASCII_8BIT" do - @io = new_io @name, "rb" - @io.external_encoding.should equal(Encoding::ASCII_8BIT) - end - - it "returns the external encoding specified by the mode argument" do - @io = new_io @name, "rb:ibm437" - @io.external_encoding.should equal(Encoding::IBM437) - end - end - - describe "with 'r+' mode" do - it_behaves_like :io_external_encoding_write, nil, "r+" + it "returns the external encoding specified by the mode argument" do + @io = new_io @name, "rb:ibm437" + @io.external_encoding.should equal(Encoding::IBM437) end + end - describe "with 'w' mode" do - it_behaves_like :io_external_encoding_write, nil, "w" - end + describe "with 'r+' mode" do + it_behaves_like :io_external_encoding_write, nil, "r+" + end - describe "with 'wb' mode" do - it "returns Encoding::ASCII_8BIT" do - @io = new_io @name, "wb" - @io.external_encoding.should equal(Encoding::ASCII_8BIT) - end + describe "with 'w' mode" do + it_behaves_like :io_external_encoding_write, nil, "w" + end - it "returns the external encoding specified by the mode argument" do - @io = new_io @name, "wb:ibm437" - @io.external_encoding.should equal(Encoding::IBM437) - end + describe "with 'wb' mode" do + it "returns Encoding::ASCII_8BIT" do + @io = new_io @name, "wb" + @io.external_encoding.should equal(Encoding::ASCII_8BIT) end - describe "with 'w+' mode" do - it_behaves_like :io_external_encoding_write, nil, "w+" + it "returns the external encoding specified by the mode argument" do + @io = new_io @name, "wb:ibm437" + @io.external_encoding.should equal(Encoding::IBM437) end + end - describe "with 'a' mode" do - it_behaves_like :io_external_encoding_write, nil, "a" - end + describe "with 'w+' mode" do + it_behaves_like :io_external_encoding_write, nil, "w+" + end - describe "with 'a+' mode" do - it_behaves_like :io_external_encoding_write, nil, "a+" - end + describe "with 'a' mode" do + it_behaves_like :io_external_encoding_write, nil, "a" + end + + describe "with 'a+' mode" do + it_behaves_like :io_external_encoding_write, nil, "a+" end end diff --git a/spec/ruby/core/io/fixtures/classes.rb b/spec/ruby/core/io/fixtures/classes.rb index a771e3d929..460dd62387 100644 --- a/spec/ruby/core/io/fixtures/classes.rb +++ b/spec/ruby/core/io/fixtures/classes.rb @@ -118,10 +118,10 @@ module IOSpecs # Creates an IO instance for an existing fixture file. The # file should obviously not be deleted. - def self.io_fixture(name, options_or_mode="r:utf-8") + def self.io_fixture(name, mode = "r:utf-8") path = fixture __FILE__, name name = path if File.exist? path - new_io name, options_or_mode + new_io(name, mode) end # Returns a closed instance of IO that was opened to reference diff --git a/spec/ruby/core/io/foreach_spec.rb b/spec/ruby/core/io/foreach_spec.rb index c5c1178787..c2276cf544 100644 --- a/spec/ruby/core/io/foreach_spec.rb +++ b/spec/ruby/core/io/foreach_spec.rb @@ -24,7 +24,7 @@ describe "IO.foreach" do ScratchPad.recorded.should == ["hello\n", "line2\n"] end - with_feature :fork do + platform_is_not :windows do it "gets data from a fork when passed -" do parent_pid = $$ diff --git a/spec/ruby/core/io/gets_spec.rb b/spec/ruby/core/io/gets_spec.rb index 525c7547cd..ac763f2a13 100644 --- a/spec/ruby/core/io/gets_spec.rb +++ b/spec/ruby/core/io/gets_spec.rb @@ -156,11 +156,11 @@ describe "IO#gets" do end it "raises an IOError if the stream is opened for append only" do - lambda { File.open(@name, fmode("a:utf-8")) { |f| f.gets } }.should raise_error(IOError) + lambda { File.open(@name, "a:utf-8") { |f| f.gets } }.should raise_error(IOError) end it "raises an IOError if the stream is opened for writing only" do - lambda { File.open(@name, fmode("w:utf-8")) { |f| f.gets } }.should raise_error(IOError) + lambda { File.open(@name, "w:utf-8") { |f| f.gets } }.should raise_error(IOError) end end @@ -168,7 +168,7 @@ describe "IO#gets" do before :each do @name = tmp("io_gets") touch(@name) { |f| f.write "one\n\ntwo\n\nthree\nfour\n" } - @io = new_io @name, fmode("r:utf-8") + @io = new_io @name, "r:utf-8" end after :each do @@ -232,7 +232,7 @@ describe "IO#gets" do # create data "朝日" + "\xE3\x81" * 100 to avoid utf-8 conflicts data = "朝日" + ([227,129].pack('C*') * 100).force_encoding('utf-8') touch(@name) { |f| f.write data } - @io = new_io @name, fmode("r:utf-8") + @io = new_io @name, "r:utf-8" end after :each do diff --git a/spec/ruby/core/io/initialize_spec.rb b/spec/ruby/core/io/initialize_spec.rb index 5bf194f15c..4858e0360c 100644 --- a/spec/ruby/core/io/initialize_spec.rb +++ b/spec/ruby/core/io/initialize_spec.rb @@ -13,26 +13,18 @@ describe "IO#initialize" do rm_r @name end - # File descriptor numbers are not predictable in multi-threaded code; - # MJIT will be opening/closing files the background - without_feature :mjit do - it "reassociates the IO instance with the new descriptor when passed a Fixnum" do - fd = new_fd @name, "r:utf-8" - @io.send :initialize, fd, 'r' - @io.fileno.should == fd - # initialize has closed the old descriptor - lambda { IO.for_fd(@fd).close }.should raise_error(Errno::EBADF) - end - - it "calls #to_int to coerce the object passed as an fd" do - obj = mock('fileno') - fd = new_fd @name, "r:utf-8" - obj.should_receive(:to_int).and_return(fd) - @io.send :initialize, obj, 'r' - @io.fileno.should == fd - # initialize has closed the old descriptor - lambda { IO.for_fd(@fd).close }.should raise_error(Errno::EBADF) - end + it "reassociates the IO instance with the new descriptor when passed a Fixnum" do + fd = new_fd @name, "r:utf-8" + @io.send :initialize, fd, 'r' + @io.fileno.should == fd + end + + it "calls #to_int to coerce the object passed as an fd" do + obj = mock('fileno') + fd = new_fd @name, "r:utf-8" + obj.should_receive(:to_int).and_return(fd) + @io.send :initialize, obj, 'r' + @io.fileno.should == fd end it "raises a TypeError when passed an IO" do diff --git a/spec/ruby/core/io/internal_encoding_spec.rb b/spec/ruby/core/io/internal_encoding_spec.rb index a4f13fa100..772cdeeaaf 100644 --- a/spec/ruby/core/io/internal_encoding_spec.rb +++ b/spec/ruby/core/io/internal_encoding_spec.rb @@ -1,140 +1,138 @@ require_relative '../../spec_helper' -with_feature :encoding do - describe :io_internal_encoding, shared: true do - describe "when Encoding.default_internal is not set" do - before :each do - Encoding.default_internal = nil - end - - it "returns nil if the internal encoding is not set" do - @io = new_io @name, @object - @io.internal_encoding.should be_nil - end - - it "returns nil if Encoding.default_internal is changed after the instance is created" do - @io = new_io @name, @object - Encoding.default_internal = Encoding::IBM437 - @io.internal_encoding.should be_nil - end - - it "returns the value set when the instance was created" do - @io = new_io @name, "#{@object}:utf-8:euc-jp" - Encoding.default_internal = Encoding::IBM437 - @io.internal_encoding.should equal(Encoding::EUC_JP) - end - - it "returns the value set by #set_encoding" do - @io = new_io @name, @object - @io.set_encoding(Encoding::US_ASCII, Encoding::IBM437) - @io.internal_encoding.should equal(Encoding::IBM437) - end - end - - describe "when Encoding.default_internal == Encoding.default_external" do - before :each do - Encoding.default_external = Encoding::IBM866 - Encoding.default_internal = Encoding::IBM866 - end - - it "returns nil" do - @io = new_io @name, @object - @io.internal_encoding.should be_nil - end - - it "returns nil regardless of Encoding.default_internal changes" do - @io = new_io @name, @object - Encoding.default_internal = Encoding::IBM437 - @io.internal_encoding.should be_nil - end - end - - describe "when Encoding.default_internal != Encoding.default_external" do - before :each do - Encoding.default_external = Encoding::IBM437 - Encoding.default_internal = Encoding::IBM866 - end - - it "returns the value of Encoding.default_internal when the instance was created if the internal encoding is not set" do - @io = new_io @name, @object - @io.internal_encoding.should equal(Encoding::IBM866) - end - - it "does not change when Encoding.default_internal is changed" do - @io = new_io @name, @object - Encoding.default_internal = Encoding::IBM437 - @io.internal_encoding.should equal(Encoding::IBM866) - end - - it "returns the internal encoding set when the instance was created" do - @io = new_io @name, "#{@object}:utf-8:euc-jp" - @io.internal_encoding.should equal(Encoding::EUC_JP) - end - - it "does not change when set and Encoding.default_internal is changed" do - @io = new_io @name, "#{@object}:utf-8:euc-jp" - Encoding.default_internal = Encoding::IBM437 - @io.internal_encoding.should equal(Encoding::EUC_JP) - end - - it "returns the value set by #set_encoding" do - @io = new_io @name, @object - @io.set_encoding(Encoding::US_ASCII, Encoding::IBM437) - @io.internal_encoding.should equal(Encoding::IBM437) - end - - it "returns nil when Encoding.default_external is ASCII-8BIT and the internal encoding is not set" do - Encoding.default_external = Encoding::ASCII_8BIT - @io = new_io @name, @object - @io.internal_encoding.should be_nil - end - - it "returns nil when the external encoding is ASCII-8BIT and the internal encoding is not set" do - @io = new_io @name, "#{@object}:ascii-8bit" - @io.internal_encoding.should be_nil - end +describe :io_internal_encoding, shared: true do + describe "when Encoding.default_internal is not set" do + before :each do + Encoding.default_internal = nil + end + + it "returns nil if the internal encoding is not set" do + @io = new_io @name, @object + @io.internal_encoding.should be_nil + end + + it "returns nil if Encoding.default_internal is changed after the instance is created" do + @io = new_io @name, @object + Encoding.default_internal = Encoding::IBM437 + @io.internal_encoding.should be_nil + end + + it "returns the value set when the instance was created" do + @io = new_io @name, "#{@object}:utf-8:euc-jp" + Encoding.default_internal = Encoding::IBM437 + @io.internal_encoding.should equal(Encoding::EUC_JP) + end + + it "returns the value set by #set_encoding" do + @io = new_io @name, @object + @io.set_encoding(Encoding::US_ASCII, Encoding::IBM437) + @io.internal_encoding.should equal(Encoding::IBM437) end end - describe "IO#internal_encoding" do + describe "when Encoding.default_internal == Encoding.default_external" do before :each do - @external = Encoding.default_external - @internal = Encoding.default_internal + Encoding.default_external = Encoding::IBM866 + Encoding.default_internal = Encoding::IBM866 + end + + it "returns nil" do + @io = new_io @name, @object + @io.internal_encoding.should be_nil + end - @name = tmp("io_internal_encoding") - touch(@name) + it "returns nil regardless of Encoding.default_internal changes" do + @io = new_io @name, @object + Encoding.default_internal = Encoding::IBM437 + @io.internal_encoding.should be_nil end + end - after :each do - @io.close if @io - rm_r @name + describe "when Encoding.default_internal != Encoding.default_external" do + before :each do + Encoding.default_external = Encoding::IBM437 + Encoding.default_internal = Encoding::IBM866 + end - Encoding.default_external = @external - Encoding.default_internal = @internal + it "returns the value of Encoding.default_internal when the instance was created if the internal encoding is not set" do + @io = new_io @name, @object + @io.internal_encoding.should equal(Encoding::IBM866) end - describe "with 'r' mode" do - it_behaves_like :io_internal_encoding, nil, "r" + it "does not change when Encoding.default_internal is changed" do + @io = new_io @name, @object + Encoding.default_internal = Encoding::IBM437 + @io.internal_encoding.should equal(Encoding::IBM866) end - describe "with 'r+' mode" do - it_behaves_like :io_internal_encoding, nil, "r+" + it "returns the internal encoding set when the instance was created" do + @io = new_io @name, "#{@object}:utf-8:euc-jp" + @io.internal_encoding.should equal(Encoding::EUC_JP) end - describe "with 'w' mode" do - it_behaves_like :io_internal_encoding, nil, "w" + it "does not change when set and Encoding.default_internal is changed" do + @io = new_io @name, "#{@object}:utf-8:euc-jp" + Encoding.default_internal = Encoding::IBM437 + @io.internal_encoding.should equal(Encoding::EUC_JP) end - describe "with 'w+' mode" do - it_behaves_like :io_internal_encoding, nil, "w+" + it "returns the value set by #set_encoding" do + @io = new_io @name, @object + @io.set_encoding(Encoding::US_ASCII, Encoding::IBM437) + @io.internal_encoding.should equal(Encoding::IBM437) end - describe "with 'a' mode" do - it_behaves_like :io_internal_encoding, nil, "a" + it "returns nil when Encoding.default_external is ASCII-8BIT and the internal encoding is not set" do + Encoding.default_external = Encoding::ASCII_8BIT + @io = new_io @name, @object + @io.internal_encoding.should be_nil end - describe "with 'a+' mode" do - it_behaves_like :io_internal_encoding, nil, "a+" + it "returns nil when the external encoding is ASCII-8BIT and the internal encoding is not set" do + @io = new_io @name, "#{@object}:ascii-8bit" + @io.internal_encoding.should be_nil end end end + +describe "IO#internal_encoding" do + before :each do + @external = Encoding.default_external + @internal = Encoding.default_internal + + @name = tmp("io_internal_encoding") + touch(@name) + end + + after :each do + @io.close if @io + rm_r @name + + Encoding.default_external = @external + Encoding.default_internal = @internal + end + + describe "with 'r' mode" do + it_behaves_like :io_internal_encoding, nil, "r" + end + + describe "with 'r+' mode" do + it_behaves_like :io_internal_encoding, nil, "r+" + end + + describe "with 'w' mode" do + it_behaves_like :io_internal_encoding, nil, "w" + end + + describe "with 'w+' mode" do + it_behaves_like :io_internal_encoding, nil, "w+" + end + + describe "with 'a' mode" do + it_behaves_like :io_internal_encoding, nil, "a" + end + + describe "with 'a+' mode" do + it_behaves_like :io_internal_encoding, nil, "a+" + end +end diff --git a/spec/ruby/core/io/popen_spec.rb b/spec/ruby/core/io/popen_spec.rb index d15ac48fe4..289bb076e4 100644 --- a/spec/ruby/core/io/popen_spec.rb +++ b/spec/ruby/core/io/popen_spec.rb @@ -136,7 +136,7 @@ describe "IO.popen" do end end - with_feature :fork do + platform_is_not :windows do it "starts returns a forked process if the command is -" do io = IO.popen("-") @@ -153,22 +153,20 @@ describe "IO.popen" do end end - with_feature :encoding do - it "has the given external encoding" do - @io = IO.popen(ruby_cmd('exit'), external_encoding: Encoding::EUC_JP) - @io.external_encoding.should == Encoding::EUC_JP - end + it "has the given external encoding" do + @io = IO.popen(ruby_cmd('exit'), external_encoding: Encoding::EUC_JP) + @io.external_encoding.should == Encoding::EUC_JP + end - it "has the given internal encoding" do - @io = IO.popen(ruby_cmd('exit'), internal_encoding: Encoding::EUC_JP) - @io.internal_encoding.should == Encoding::EUC_JP - end + it "has the given internal encoding" do + @io = IO.popen(ruby_cmd('exit'), internal_encoding: Encoding::EUC_JP) + @io.internal_encoding.should == Encoding::EUC_JP + end - it "sets the internal encoding to nil if it's the same as the external encoding" do - @io = IO.popen(ruby_cmd('exit'), external_encoding: Encoding::EUC_JP, - internal_encoding: Encoding::EUC_JP) - @io.internal_encoding.should be_nil - end + it "sets the internal encoding to nil if it's the same as the external encoding" do + @io = IO.popen(ruby_cmd('exit'), external_encoding: Encoding::EUC_JP, + internal_encoding: Encoding::EUC_JP) + @io.internal_encoding.should be_nil end context "with a leading ENV Hash" do diff --git a/spec/ruby/core/io/puts_spec.rb b/spec/ruby/core/io/puts_spec.rb index e99cffb00f..e8d599730f 100644 --- a/spec/ruby/core/io/puts_spec.rb +++ b/spec/ruby/core/io/puts_spec.rb @@ -114,28 +114,26 @@ describe "IO#puts" do lambda { IOSpecs.closed_io.puts("stuff") }.should raise_error(IOError) end - with_feature :encoding do - it "writes crlf when IO is opened with newline: :crlf" do - File.open(@name, 'wt', newline: :crlf) do |file| - file.puts - end - File.binread(@name).should == "\r\n" + it "writes crlf when IO is opened with newline: :crlf" do + File.open(@name, 'wt', newline: :crlf) do |file| + file.puts end + File.binread(@name).should == "\r\n" + end - it "writes cr when IO is opened with newline: :cr" do - File.open(@name, 'wt', newline: :cr) do |file| - file.puts - end - File.binread(@name).should == "\r" + it "writes cr when IO is opened with newline: :cr" do + File.open(@name, 'wt', newline: :cr) do |file| + file.puts end + File.binread(@name).should == "\r" + end - platform_is_not :windows do # https://bugs.ruby-lang.org/issues/12436 - it "writes lf when IO is opened with newline: :lf" do - File.open(@name, 'wt', newline: :lf) do |file| - file.puts - end - File.binread(@name).should == "\n" + platform_is_not :windows do # https://bugs.ruby-lang.org/issues/12436 + it "writes lf when IO is opened with newline: :lf" do + File.open(@name, 'wt', newline: :lf) do |file| + file.puts end + File.binread(@name).should == "\n" end end end diff --git a/spec/ruby/core/io/read_spec.rb b/spec/ruby/core/io/read_spec.rb index 6f6713d957..ccb341a1f9 100644 --- a/spec/ruby/core/io/read_spec.rb +++ b/spec/ruby/core/io/read_spec.rb @@ -95,16 +95,14 @@ describe "IO.read" do lambda { IO.read @fname, -1, -1 }.should raise_error(Errno::EINVAL) end - with_feature :encoding do - it "uses the external encoding specified via the :external_encoding option" do - str = IO.read(@fname, external_encoding: Encoding::ISO_8859_1) - str.encoding.should == Encoding::ISO_8859_1 - end + it "uses the external encoding specified via the :external_encoding option" do + str = IO.read(@fname, external_encoding: Encoding::ISO_8859_1) + str.encoding.should == Encoding::ISO_8859_1 + end - it "uses the external encoding specified via the :encoding option" do - str = IO.read(@fname, encoding: Encoding::ISO_8859_1) - str.encoding.should == Encoding::ISO_8859_1 - end + it "uses the external encoding specified via the :encoding option" do + str = IO.read(@fname, encoding: Encoding::ISO_8859_1) + str.encoding.should == Encoding::ISO_8859_1 end end @@ -117,7 +115,7 @@ describe "IO.read from a pipe" do IO.read(cmd).should == "hello\n" end - with_feature :fork do + platform_is_not :windows do it "opens a pipe to a fork if the rest is -" do str = IO.read("|-") if str # parent @@ -456,135 +454,133 @@ describe "IO.read with BOM" do end end -with_feature :encoding do - describe :io_read_internal_encoding, shared: true do - it "returns a transcoded String" do - @io.read.should == "ありがとう\n" +describe :io_read_internal_encoding, shared: true do + it "returns a transcoded String" do + @io.read.should == "ありがとう\n" + end + + it "sets the String encoding to the internal encoding" do + @io.read.encoding.should equal(Encoding::UTF_8) + end + + describe "when passed nil for limit" do + it "sets the buffer to a transcoded String" do + result = @io.read(nil, buf = "") + buf.should equal(result) + buf.should == "ありがとう\n" end - it "sets the String encoding to the internal encoding" do - @io.read.encoding.should equal(Encoding::UTF_8) + it "sets the buffer's encoding to the internal encoding" do + buf = "".force_encoding Encoding::ISO_8859_1 + @io.read(nil, buf) + buf.encoding.should equal(Encoding::UTF_8) end + end +end - describe "when passed nil for limit" do - it "sets the buffer to a transcoded String" do - result = @io.read(nil, buf = "") - buf.should equal(result) - buf.should == "ありがとう\n" - end +describe :io_read_size_internal_encoding, shared: true do + it "reads bytes when passed a size" do + @io.read(2).should == [164, 162].pack('C*').force_encoding(Encoding::ASCII_8BIT) + end - it "sets the buffer's encoding to the internal encoding" do - buf = "".force_encoding Encoding::ISO_8859_1 - @io.read(nil, buf) - buf.encoding.should equal(Encoding::UTF_8) - end - end + it "returns a String in ASCII-8BIT when passed a size" do + @io.read(4).encoding.should equal(Encoding::ASCII_8BIT) end - describe :io_read_size_internal_encoding, shared: true do - it "reads bytes when passed a size" do - @io.read(2).should == [164, 162].pack('C*').force_encoding(Encoding::ASCII_8BIT) - end + it "does not change the buffer's encoding when passed a limit" do + buf = "".force_encoding Encoding::ISO_8859_1 + @io.read(4, buf) + buf.should == [164, 162, 164, 234].pack('C*').force_encoding(Encoding::ISO_8859_1) + buf.encoding.should equal(Encoding::ISO_8859_1) + end - it "returns a String in ASCII-8BIT when passed a size" do - @io.read(4).encoding.should equal(Encoding::ASCII_8BIT) - end + it "truncates the buffer but does not change the buffer's encoding when no data remains" do + buf = "abc".force_encoding Encoding::ISO_8859_1 + @io.read - it "does not change the buffer's encoding when passed a limit" do - buf = "".force_encoding Encoding::ISO_8859_1 - @io.read(4, buf) - buf.should == [164, 162, 164, 234].pack('C*').force_encoding(Encoding::ISO_8859_1) - buf.encoding.should equal(Encoding::ISO_8859_1) + @io.read(1, buf).should be_nil + buf.size.should == 0 + buf.encoding.should equal(Encoding::ISO_8859_1) + end +end + +describe "IO#read" do + describe "when IO#external_encoding and IO#internal_encoding are nil" do + before :each do + @name = tmp("io_read.txt") + touch(@name) { |f| f.write "\x00\x01\x02" } + @io = new_io @name, "r+" end - it "truncates the buffer but does not change the buffer's encoding when no data remains" do - buf = "abc".force_encoding Encoding::ISO_8859_1 - @io.read + after :each do + @io.close if @io + rm_r @name + end - @io.read(1, buf).should be_nil - buf.size.should == 0 - buf.encoding.should equal(Encoding::ISO_8859_1) + it "sets the String encoding to Encoding.default_external" do + @io.read.encoding.should equal(Encoding.default_external) end end - describe "IO#read" do - describe "when IO#external_encoding and IO#internal_encoding are nil" do - before :each do - @name = tmp("io_read.txt") - touch(@name) { |f| f.write "\x00\x01\x02" } - @io = new_io @name, "r+" - end + describe "with internal encoding" do + after :each do + @io.close if @io + end - after :each do - @io.close if @io - rm_r @name + describe "not specified" do + before :each do + @io = IOSpecs.io_fixture "read_euc_jp.txt", "r:euc-jp" end - it "sets the String encoding to Encoding.default_external" do - @io.read.encoding.should equal(Encoding.default_external) + it "does not transcode the String" do + @io.read.should == ("ありがとう\n").encode(Encoding::EUC_JP) end - end - describe "with internal encoding" do - after :each do - @io.close if @io + it "sets the String encoding to the external encoding" do + @io.read.encoding.should equal(Encoding::EUC_JP) end - describe "not specified" do - before :each do - @io = IOSpecs.io_fixture "read_euc_jp.txt", "r:euc-jp" - end - - it "does not transcode the String" do - @io.read.should == ("ありがとう\n").encode(Encoding::EUC_JP) - end - - it "sets the String encoding to the external encoding" do - @io.read.encoding.should equal(Encoding::EUC_JP) - end + it_behaves_like :io_read_size_internal_encoding, nil + end - it_behaves_like :io_read_size_internal_encoding, nil + describe "specified by open mode" do + before :each do + @io = IOSpecs.io_fixture "read_euc_jp.txt", "r:euc-jp:utf-8" end - describe "specified by open mode" do - before :each do - @io = IOSpecs.io_fixture "read_euc_jp.txt", "r:euc-jp:utf-8" - end + it_behaves_like :io_read_internal_encoding, nil + it_behaves_like :io_read_size_internal_encoding, nil + end - it_behaves_like :io_read_internal_encoding, nil - it_behaves_like :io_read_size_internal_encoding, nil + describe "specified by mode: option" do + before :each do + @io = IOSpecs.io_fixture "read_euc_jp.txt", mode: "r:euc-jp:utf-8" end - describe "specified by mode: option" do - before :each do - @io = IOSpecs.io_fixture "read_euc_jp.txt", mode: "r:euc-jp:utf-8" - end + it_behaves_like :io_read_internal_encoding, nil + it_behaves_like :io_read_size_internal_encoding, nil + end - it_behaves_like :io_read_internal_encoding, nil - it_behaves_like :io_read_size_internal_encoding, nil + describe "specified by internal_encoding: option" do + before :each do + options = { mode: "r", + internal_encoding: "utf-8", + external_encoding: "euc-jp" } + @io = IOSpecs.io_fixture "read_euc_jp.txt", options end - describe "specified by internal_encoding: option" do - before :each do - options = { mode: "r", - internal_encoding: "utf-8", - external_encoding: "euc-jp" } - @io = IOSpecs.io_fixture "read_euc_jp.txt", options - end + it_behaves_like :io_read_internal_encoding, nil + it_behaves_like :io_read_size_internal_encoding, nil + end - it_behaves_like :io_read_internal_encoding, nil - it_behaves_like :io_read_size_internal_encoding, nil + describe "specified by encoding: option" do + before :each do + options = { mode: "r", encoding: "euc-jp:utf-8" } + @io = IOSpecs.io_fixture "read_euc_jp.txt", options end - describe "specified by encoding: option" do - before :each do - options = { mode: "r", encoding: "euc-jp:utf-8" } - @io = IOSpecs.io_fixture "read_euc_jp.txt", options - end - - it_behaves_like :io_read_internal_encoding, nil - it_behaves_like :io_read_size_internal_encoding, nil - end + it_behaves_like :io_read_internal_encoding, nil + it_behaves_like :io_read_size_internal_encoding, nil end end end diff --git a/spec/ruby/core/io/readlines_spec.rb b/spec/ruby/core/io/readlines_spec.rb index c1ea706b26..9e145f12f4 100644 --- a/spec/ruby/core/io/readlines_spec.rb +++ b/spec/ruby/core/io/readlines_spec.rb @@ -112,7 +112,7 @@ describe "IO#readlines" do lines.should == ["hello\n", "line2\n"] end - with_feature :fork do + platform_is_not :windows do it "gets data from a fork when passed -" do lines = IO.readlines("|-") @@ -139,13 +139,13 @@ describe "IO#readlines" do it "raises an IOError if the stream is opened for append only" do lambda do - File.open(@name, fmode("a:utf-8")) { |f| f.readlines } + File.open(@name, "a:utf-8") { |f| f.readlines } end.should raise_error(IOError) end it "raises an IOError if the stream is opened for write only" do lambda do - File.open(@name, fmode("w:utf-8")) { |f| f.readlines } + File.open(@name, "w:utf-8") { |f| f.readlines } end.should raise_error(IOError) end end diff --git a/spec/ruby/core/io/reopen_spec.rb b/spec/ruby/core/io/reopen_spec.rb index 53fcc9dede..84c23472b7 100644 --- a/spec/ruby/core/io/reopen_spec.rb +++ b/spec/ruby/core/io/reopen_spec.rb @@ -145,23 +145,6 @@ describe "IO#reopen with a String" do File.read(@other_name).should == "new data" end - # File descriptor numbers are not predictable in multi-threaded code; - # MJIT will be opening/closing files the background - without_feature :mjit do - it "closes the file descriptor obtained by opening the new file" do - @io = new_io @name, "w" - - @other_io = File.open @other_name, "w" - max = @other_io.fileno - @other_io.close - - @io.reopen @other_name - - @other_io = File.open @other_name, "w" - @other_io.fileno.should == max - end - end - it "always resets the close-on-exec flag to true on non-STDIO objects" do @io = new_io @name, "w" diff --git a/spec/ruby/core/io/set_encoding_spec.rb b/spec/ruby/core/io/set_encoding_spec.rb index 9875d64ab8..a9d783325c 100644 --- a/spec/ruby/core/io/set_encoding_spec.rb +++ b/spec/ruby/core/io/set_encoding_spec.rb @@ -1,193 +1,191 @@ require_relative '../../spec_helper' -with_feature :encoding do - describe :io_set_encoding_write, shared: true do - it "sets the encodings to nil" do - @io = new_io @name, "#{@object}:ibm437:ibm866" - @io.set_encoding nil, nil +describe :io_set_encoding_write, shared: true do + it "sets the encodings to nil" do + @io = new_io @name, "#{@object}:ibm437:ibm866" + @io.set_encoding nil, nil - @io.external_encoding.should be_nil - @io.internal_encoding.should be_nil - end + @io.external_encoding.should be_nil + @io.internal_encoding.should be_nil + end - it "prevents the encodings from changing when Encoding defaults are changed" do - @io = new_io @name, "#{@object}:utf-8:us-ascii" - @io.set_encoding nil, nil + it "prevents the encodings from changing when Encoding defaults are changed" do + @io = new_io @name, "#{@object}:utf-8:us-ascii" + @io.set_encoding nil, nil - Encoding.default_external = Encoding::IBM437 - Encoding.default_internal = Encoding::IBM866 + Encoding.default_external = Encoding::IBM437 + Encoding.default_internal = Encoding::IBM866 - @io.external_encoding.should be_nil - @io.internal_encoding.should be_nil - end + @io.external_encoding.should be_nil + @io.internal_encoding.should be_nil + end - it "sets the encodings to the current Encoding defaults" do - @io = new_io @name, @object + it "sets the encodings to the current Encoding defaults" do + @io = new_io @name, @object - Encoding.default_external = Encoding::IBM437 - Encoding.default_internal = Encoding::IBM866 + Encoding.default_external = Encoding::IBM437 + Encoding.default_internal = Encoding::IBM866 - @io.set_encoding nil, nil + @io.set_encoding nil, nil - @io.external_encoding.should == Encoding::IBM437 - @io.internal_encoding.should == Encoding::IBM866 - end + @io.external_encoding.should == Encoding::IBM437 + @io.internal_encoding.should == Encoding::IBM866 end +end - describe "IO#set_encoding when passed nil, nil" do - before :each do - @external = Encoding.default_external - @internal = Encoding.default_internal +describe "IO#set_encoding when passed nil, nil" do + before :each do + @external = Encoding.default_external + @internal = Encoding.default_internal - Encoding.default_external = Encoding::UTF_8 - Encoding.default_internal = nil + Encoding.default_external = Encoding::UTF_8 + Encoding.default_internal = nil - @name = tmp('io_set_encoding.txt') - touch(@name) - end + @name = tmp('io_set_encoding.txt') + touch(@name) + end - after :each do - Encoding.default_external = @external - Encoding.default_internal = @internal + after :each do + Encoding.default_external = @external + Encoding.default_internal = @internal - @io.close if @io and not @io.closed? - rm_r @name - end + @io.close if @io and not @io.closed? + rm_r @name + end - describe "with 'r' mode" do - it "sets the encodings to the current Encoding defaults" do - @io = new_io @name, "r" + describe "with 'r' mode" do + it "sets the encodings to the current Encoding defaults" do + @io = new_io @name, "r" - Encoding.default_external = Encoding::IBM437 - Encoding.default_internal = Encoding::IBM866 + Encoding.default_external = Encoding::IBM437 + Encoding.default_internal = Encoding::IBM866 - @io.set_encoding nil, nil - @io.external_encoding.should equal(Encoding::IBM437) - @io.internal_encoding.should equal(Encoding::IBM866) - end + @io.set_encoding nil, nil + @io.external_encoding.should equal(Encoding::IBM437) + @io.internal_encoding.should equal(Encoding::IBM866) + end - it "prevents the #internal_encoding from changing when Encoding.default_internal is changed" do - @io = new_io @name, "r" - @io.set_encoding nil, nil + it "prevents the #internal_encoding from changing when Encoding.default_internal is changed" do + @io = new_io @name, "r" + @io.set_encoding nil, nil - Encoding.default_internal = Encoding::IBM437 + Encoding.default_internal = Encoding::IBM437 - @io.internal_encoding.should be_nil - end + @io.internal_encoding.should be_nil + end - it "allows the #external_encoding to change when Encoding.default_external is changed" do - @io = new_io @name, "r" - @io.set_encoding nil, nil + it "allows the #external_encoding to change when Encoding.default_external is changed" do + @io = new_io @name, "r" + @io.set_encoding nil, nil - Encoding.default_external = Encoding::IBM437 + Encoding.default_external = Encoding::IBM437 - @io.external_encoding.should equal(Encoding::IBM437) - end + @io.external_encoding.should equal(Encoding::IBM437) end + end - describe "with 'rb' mode" do - it "returns Encoding.default_external" do - @io = new_io @name, "rb" - @io.external_encoding.should equal(Encoding::ASCII_8BIT) + describe "with 'rb' mode" do + it "returns Encoding.default_external" do + @io = new_io @name, "rb" + @io.external_encoding.should equal(Encoding::ASCII_8BIT) - @io.set_encoding nil, nil - @io.external_encoding.should equal(Encoding.default_external) - end + @io.set_encoding nil, nil + @io.external_encoding.should equal(Encoding.default_external) end + end - describe "with 'r+' mode" do - it_behaves_like :io_set_encoding_write, nil, "r+" - end + describe "with 'r+' mode" do + it_behaves_like :io_set_encoding_write, nil, "r+" + end - describe "with 'w' mode" do - it_behaves_like :io_set_encoding_write, nil, "w" - end + describe "with 'w' mode" do + it_behaves_like :io_set_encoding_write, nil, "w" + end - describe "with 'w+' mode" do - it_behaves_like :io_set_encoding_write, nil, "w+" - end + describe "with 'w+' mode" do + it_behaves_like :io_set_encoding_write, nil, "w+" + end - describe "with 'a' mode" do - it_behaves_like :io_set_encoding_write, nil, "a" - end + describe "with 'a' mode" do + it_behaves_like :io_set_encoding_write, nil, "a" + end - describe "with 'a+' mode" do - it_behaves_like :io_set_encoding_write, nil, "a+" - end + describe "with 'a+' mode" do + it_behaves_like :io_set_encoding_write, nil, "a+" end +end - describe "IO#set_encoding" do - before :each do - @name = tmp('io_set_encoding.txt') - touch(@name) - @io = new_io @name - end +describe "IO#set_encoding" do + before :each do + @name = tmp('io_set_encoding.txt') + touch(@name) + @io = new_io @name + end - after :each do - @io.close unless @io.closed? - rm_r @name - end + after :each do + @io.close unless @io.closed? + rm_r @name + end - it "returns self" do - @io.set_encoding(Encoding::UTF_8).should equal(@io) - end + it "returns self" do + @io.set_encoding(Encoding::UTF_8).should equal(@io) + end - it "sets the external encoding when passed an Encoding argument" do - @io.set_encoding(Encoding::UTF_8) - @io.external_encoding.should == Encoding::UTF_8 - @io.internal_encoding.should be_nil - end + it "sets the external encoding when passed an Encoding argument" do + @io.set_encoding(Encoding::UTF_8) + @io.external_encoding.should == Encoding::UTF_8 + @io.internal_encoding.should be_nil + end - it "sets the external and internal encoding when passed two Encoding arguments" do - @io.set_encoding(Encoding::UTF_8, Encoding::UTF_16BE) - @io.external_encoding.should == Encoding::UTF_8 - @io.internal_encoding.should == Encoding::UTF_16BE - end + it "sets the external and internal encoding when passed two Encoding arguments" do + @io.set_encoding(Encoding::UTF_8, Encoding::UTF_16BE) + @io.external_encoding.should == Encoding::UTF_8 + @io.internal_encoding.should == Encoding::UTF_16BE + end - it "sets the external encoding when passed the name of an Encoding" do - @io.set_encoding("utf-8") - @io.external_encoding.should == Encoding::UTF_8 - @io.internal_encoding.should be_nil - end + it "sets the external encoding when passed the name of an Encoding" do + @io.set_encoding("utf-8") + @io.external_encoding.should == Encoding::UTF_8 + @io.internal_encoding.should be_nil + end - it "ignores the internal encoding if the same as external when passed Encoding objects" do - @io.set_encoding(Encoding::UTF_8, Encoding::UTF_8) - @io.external_encoding.should == Encoding::UTF_8 - @io.internal_encoding.should be_nil - end + it "ignores the internal encoding if the same as external when passed Encoding objects" do + @io.set_encoding(Encoding::UTF_8, Encoding::UTF_8) + @io.external_encoding.should == Encoding::UTF_8 + @io.internal_encoding.should be_nil + end - it "ignores the internal encoding if the same as external when passed encoding names separated by ':'" do - @io.set_encoding("utf-8:utf-8") - @io.external_encoding.should == Encoding::UTF_8 - @io.internal_encoding.should be_nil - end + it "ignores the internal encoding if the same as external when passed encoding names separated by ':'" do + @io.set_encoding("utf-8:utf-8") + @io.external_encoding.should == Encoding::UTF_8 + @io.internal_encoding.should be_nil + end - it "sets the external and internal encoding when passed the names of Encodings separated by ':'" do - @io.set_encoding("utf-8:utf-16be") - @io.external_encoding.should == Encoding::UTF_8 - @io.internal_encoding.should == Encoding::UTF_16BE - end + it "sets the external and internal encoding when passed the names of Encodings separated by ':'" do + @io.set_encoding("utf-8:utf-16be") + @io.external_encoding.should == Encoding::UTF_8 + @io.internal_encoding.should == Encoding::UTF_16BE + end - it "sets the external and internal encoding when passed two String arguments" do - @io.set_encoding("utf-8", "utf-16be") - @io.external_encoding.should == Encoding::UTF_8 - @io.internal_encoding.should == Encoding::UTF_16BE - end + it "sets the external and internal encoding when passed two String arguments" do + @io.set_encoding("utf-8", "utf-16be") + @io.external_encoding.should == Encoding::UTF_8 + @io.internal_encoding.should == Encoding::UTF_16BE + end - it "calls #to_str to convert an abject to a String" do - obj = mock("io_set_encoding") - obj.should_receive(:to_str).and_return("utf-8:utf-16be") - @io.set_encoding(obj) - @io.external_encoding.should == Encoding::UTF_8 - @io.internal_encoding.should == Encoding::UTF_16BE - end + it "calls #to_str to convert an abject to a String" do + obj = mock("io_set_encoding") + obj.should_receive(:to_str).and_return("utf-8:utf-16be") + @io.set_encoding(obj) + @io.external_encoding.should == Encoding::UTF_8 + @io.internal_encoding.should == Encoding::UTF_16BE + end - it "calls #to_str to convert the second argument to a String" do - obj = mock("io_set_encoding") - obj.should_receive(:to_str).at_least(1).times.and_return("utf-16be") - @io.set_encoding(Encoding::UTF_8, obj) - @io.external_encoding.should == Encoding::UTF_8 - @io.internal_encoding.should == Encoding::UTF_16BE - end + it "calls #to_str to convert the second argument to a String" do + obj = mock("io_set_encoding") + obj.should_receive(:to_str).at_least(1).times.and_return("utf-16be") + @io.set_encoding(Encoding::UTF_8, obj) + @io.external_encoding.should == Encoding::UTF_8 + @io.internal_encoding.should == Encoding::UTF_16BE end end diff --git a/spec/ruby/core/io/shared/write.rb b/spec/ruby/core/io/shared/write.rb index 3cd4f8954e..aa6b3eedeb 100644 --- a/spec/ruby/core/io/shared/write.rb +++ b/spec/ruby/core/io/shared/write.rb @@ -85,7 +85,11 @@ describe :io_write, shared: true do @r.read.should == "foo" end - without_feature :mjit do # [ruby-core:90895] MJIT worker may leave fd open in a forked child. TODO: consider acquiring GVL from MJIT worker. + # [ruby-core:90895] MJIT worker may leave fd open in a forked child. + # For instance, MJIT creates a worker before @r.close with fork(), @r.close happens, + # and the MJIT worker keeps the pipe open until the worker execve(). + # TODO: consider acquiring GVL from MJIT worker. + guard_not -> { defined?(RubyVM::MJIT) && RubyVM::MJIT.enabled? } do it "raises Errno::EPIPE if the read end is closed and does not die from SIGPIPE" do @r.close -> { @w.send(@method, "foo") }.should raise_error(Errno::EPIPE, /Broken pipe/) diff --git a/spec/ruby/core/io/write_spec.rb b/spec/ruby/core/io/write_spec.rb index 50e3df864d..5fb3941505 100644 --- a/spec/ruby/core/io/write_spec.rb +++ b/spec/ruby/core/io/write_spec.rb @@ -28,51 +28,49 @@ describe "IO#write on a file" do @file.write('').should == 0 end - with_feature :encoding do - before :each do - @external = Encoding.default_external - @internal = Encoding.default_internal + before :each do + @external = Encoding.default_external + @internal = Encoding.default_internal - Encoding.default_external = Encoding::UTF_8 - end + Encoding.default_external = Encoding::UTF_8 + end - after :each do - Encoding.default_external = @external - Encoding.default_internal = @internal - end + after :each do + Encoding.default_external = @external + Encoding.default_internal = @internal + end - it "returns the number of bytes written" do - @file.write("hellø").should == 6 - end + it "returns the number of bytes written" do + @file.write("hellø").should == 6 + end - it "uses the encoding from the given option for non-ascii encoding" do - File.open(@filename, "w", encoding: Encoding::UTF_32LE) do |file| - file.write("hi").should == 8 - end - File.binread(@filename).should == "h\u0000\u0000\u0000i\u0000\u0000\u0000" + it "uses the encoding from the given option for non-ascii encoding" do + File.open(@filename, "w", encoding: Encoding::UTF_32LE) do |file| + file.write("hi").should == 8 end + File.binread(@filename).should == "h\u0000\u0000\u0000i\u0000\u0000\u0000" + end - it "uses an :open_args option" do - IO.write(@filename, 'hi', open_args: ["w", nil, {encoding: Encoding::UTF_32LE}]).should == 8 - end + it "uses an :open_args option" do + IO.write(@filename, 'hi', open_args: ["w", nil, {encoding: Encoding::UTF_32LE}]).should == 8 + end - it "raises a invalid byte sequence error if invalid bytes are being written" do - # pack "\xFEhi" to avoid utf-8 conflict - xFEhi = ([254].pack('C*') + 'hi').force_encoding('utf-8') - File.open(@filename, "w", encoding: Encoding::US_ASCII) do |file| - lambda { file.write(xFEhi) }.should raise_error(Encoding::InvalidByteSequenceError) - end + it "raises a invalid byte sequence error if invalid bytes are being written" do + # pack "\xFEhi" to avoid utf-8 conflict + xFEhi = ([254].pack('C*') + 'hi').force_encoding('utf-8') + File.open(@filename, "w", encoding: Encoding::US_ASCII) do |file| + lambda { file.write(xFEhi) }.should raise_error(Encoding::InvalidByteSequenceError) end + end - it "writes binary data if no encoding is given" do - File.open(@filename, "w") do |file| - file.write('Hëllö'.encode('ISO-8859-1')) - end - ë = ([235].pack('U')).encode('ISO-8859-1') - ö = ([246].pack('U')).encode('ISO-8859-1') - res = "H#{ë}ll#{ö}" - File.binread(@filename).should == res.force_encoding(Encoding::ASCII_8BIT) + it "writes binary data if no encoding is given" do + File.open(@filename, "w") do |file| + file.write('Hëllö'.encode('ISO-8859-1')) end + ë = ([235].pack('U')).encode('ISO-8859-1') + ö = ([246].pack('U')).encode('ISO-8859-1') + res = "H#{ë}ll#{ö}" + File.binread(@filename).should == res.force_encoding(Encoding::ASCII_8BIT) end end diff --git a/spec/ruby/core/kernel/chomp_spec.rb b/spec/ruby/core/kernel/chomp_spec.rb index e6dcc07d42..d30e77c35a 100644 --- a/spec/ruby/core/kernel/chomp_spec.rb +++ b/spec/ruby/core/kernel/chomp_spec.rb @@ -40,28 +40,26 @@ describe "Kernel#chomp" do it_behaves_like :kernel_chomp_private, :chomp end -with_feature :encoding do - describe :kernel_chomp_encoded, shared: true do - before :each do - @external = Encoding.default_external - Encoding.default_external = Encoding::UTF_8 - end - - after :each do - Encoding.default_external = @external - end - - it "removes the final carriage return, newline from a multi-byte $_" do - script = fixture __FILE__, "#{@method}.rb" - KernelSpecs.run_with_dash_n(script).should == "あれ" - end +describe :kernel_chomp_encoded, shared: true do + before :each do + @external = Encoding.default_external + Encoding.default_external = Encoding::UTF_8 end - describe "Kernel.chomp" do - it_behaves_like :kernel_chomp_encoded, "chomp" + after :each do + Encoding.default_external = @external end - describe "Kernel#chomp" do - it_behaves_like :kernel_chomp_encoded, "chomp_f" + it "removes the final carriage return, newline from a multi-byte $_" do + script = fixture __FILE__, "#{@method}.rb" + KernelSpecs.run_with_dash_n(script).should == "あれ" end end + +describe "Kernel.chomp" do + it_behaves_like :kernel_chomp_encoded, "chomp" +end + +describe "Kernel#chomp" do + it_behaves_like :kernel_chomp_encoded, "chomp_f" +end diff --git a/spec/ruby/core/kernel/chop_spec.rb b/spec/ruby/core/kernel/chop_spec.rb index e9338d8990..9b91c011bc 100644 --- a/spec/ruby/core/kernel/chop_spec.rb +++ b/spec/ruby/core/kernel/chop_spec.rb @@ -28,28 +28,26 @@ describe "Kernel#chop" do it_behaves_like :kernel_chop, "chop" end -with_feature :encoding do - describe :kernel_chop_encoded, shared: true do - before :each do - @external = Encoding.default_external - Encoding.default_external = Encoding::UTF_8 - end - - after :each do - Encoding.default_external = @external - end - - it "removes the final multi-byte character from $_" do - script = fixture __FILE__, "#{@method}.rb" - KernelSpecs.run_with_dash_n(script).should == "あ" - end +describe :kernel_chop_encoded, shared: true do + before :each do + @external = Encoding.default_external + Encoding.default_external = Encoding::UTF_8 end - describe "Kernel.chop" do - it_behaves_like :kernel_chop_encoded, "chop" + after :each do + Encoding.default_external = @external end - describe "Kernel#chop" do - it_behaves_like :kernel_chop_encoded, "chop_f" + it "removes the final multi-byte character from $_" do + script = fixture __FILE__, "#{@method}.rb" + KernelSpecs.run_with_dash_n(script).should == "あ" end end + +describe "Kernel.chop" do + it_behaves_like :kernel_chop_encoded, "chop" +end + +describe "Kernel#chop" do + it_behaves_like :kernel_chop_encoded, "chop_f" +end diff --git a/spec/ruby/core/marshal/dump_spec.rb b/spec/ruby/core/marshal/dump_spec.rb index b2120ab2e6..b041a95d4b 100644 --- a/spec/ruby/core/marshal/dump_spec.rb +++ b/spec/ruby/core/marshal/dump_spec.rb @@ -204,26 +204,24 @@ describe "Marshal.dump" do Marshal.dump(str.force_encoding("binary")).should == "\x04\bI\"\x00\x06:\t@foo\"\bbar" end - with_feature :encoding do - it "dumps a US-ASCII String" do - str = "abc".force_encoding("us-ascii") - Marshal.dump(str).should == "\x04\bI\"\babc\x06:\x06EF" - end + it "dumps a US-ASCII String" do + str = "abc".force_encoding("us-ascii") + Marshal.dump(str).should == "\x04\bI\"\babc\x06:\x06EF" + end - it "dumps a UTF-8 String" do - str = "\x6d\xc3\xb6\x68\x72\x65".force_encoding("utf-8") - Marshal.dump(str).should == "\x04\bI\"\vm\xC3\xB6hre\x06:\x06ET" - end + it "dumps a UTF-8 String" do + str = "\x6d\xc3\xb6\x68\x72\x65".force_encoding("utf-8") + Marshal.dump(str).should == "\x04\bI\"\vm\xC3\xB6hre\x06:\x06ET" + end - it "dumps a String in another encoding" do - str = "\x6d\x00\xf6\x00\x68\x00\x72\x00\x65\x00".force_encoding("utf-16le") - result = "\x04\bI\"\x0Fm\x00\xF6\x00h\x00r\x00e\x00\x06:\rencoding\"\rUTF-16LE" - Marshal.dump(str).should == result - end + it "dumps a String in another encoding" do + str = "\x6d\x00\xf6\x00\x68\x00\x72\x00\x65\x00".force_encoding("utf-16le") + result = "\x04\bI\"\x0Fm\x00\xF6\x00h\x00r\x00e\x00\x06:\rencoding\"\rUTF-16LE" + Marshal.dump(str).should == result + end - it "dumps multiple strings using symlinks for the :E (encoding) symbol" do - Marshal.dump(["".encode("us-ascii"), "".encode("utf-8")]).should == "\x04\b[\aI\"\x00\x06:\x06EFI\"\x00\x06;\x00T" - end + it "dumps multiple strings using symlinks for the :E (encoding) symbol" do + Marshal.dump(["".encode("us-ascii"), "".encode("utf-8")]).should == "\x04\b[\aI\"\x00\x06:\x06EFI\"\x00\x06;\x00T" end end @@ -541,17 +539,15 @@ describe "Marshal.dump" do lambda { Marshal.dump("test", obj) }.should raise_error(TypeError) end - with_feature :encoding do - - it "calls binmode when it's defined" do - obj = mock('test') - obj.should_receive(:write).at_least(1) - obj.should_receive(:binmode).at_least(1) - Marshal.dump("test", obj) - end + it "calls binmode when it's defined" do + obj = mock('test') + obj.should_receive(:write).at_least(1) + obj.should_receive(:binmode).at_least(1) + Marshal.dump("test", obj) end + end describe "when passed a StringIO" do diff --git a/spec/ruby/core/marshal/shared/load.rb b/spec/ruby/core/marshal/shared/load.rb index 0f1d49b115..a10885346e 100644 --- a/spec/ruby/core/marshal/shared/load.rb +++ b/spec/ruby/core/marshal/shared/load.rb @@ -422,38 +422,36 @@ describe :marshal_load, shared: true do str.should be_an_instance_of(UserCustomConstructorString) end - with_feature :encoding do - it "loads a US-ASCII String" do - str = "abc".force_encoding("us-ascii") - data = "\x04\bI\"\babc\x06:\x06EF" - result = Marshal.send(@method, data) - result.should == str - result.encoding.should equal(Encoding::US_ASCII) - end - - it "loads a UTF-8 String" do - str = "\x6d\xc3\xb6\x68\x72\x65".force_encoding("utf-8") - data = "\x04\bI\"\vm\xC3\xB6hre\x06:\x06ET" - result = Marshal.send(@method, data) - result.should == str - result.encoding.should equal(Encoding::UTF_8) - end - - it "loads a String in another encoding" do - str = "\x6d\x00\xf6\x00\x68\x00\x72\x00\x65\x00".force_encoding("utf-16le") - data = "\x04\bI\"\x0Fm\x00\xF6\x00h\x00r\x00e\x00\x06:\rencoding\"\rUTF-16LE" - result = Marshal.send(@method, data) - result.should == str - result.encoding.should equal(Encoding::UTF_16LE) - end - - it "loads a String as ASCII-8BIT if no encoding is specified at the end" do - str = "\xC3\xB8".force_encoding("ASCII-8BIT") - data = "\x04\b\"\a\xC3\xB8".force_encoding("UTF-8") - result = Marshal.send(@method, data) - result.encoding.should == Encoding::ASCII_8BIT - result.should == str - end + it "loads a US-ASCII String" do + str = "abc".force_encoding("us-ascii") + data = "\x04\bI\"\babc\x06:\x06EF" + result = Marshal.send(@method, data) + result.should == str + result.encoding.should equal(Encoding::US_ASCII) + end + + it "loads a UTF-8 String" do + str = "\x6d\xc3\xb6\x68\x72\x65".force_encoding("utf-8") + data = "\x04\bI\"\vm\xC3\xB6hre\x06:\x06ET" + result = Marshal.send(@method, data) + result.should == str + result.encoding.should equal(Encoding::UTF_8) + end + + it "loads a String in another encoding" do + str = "\x6d\x00\xf6\x00\x68\x00\x72\x00\x65\x00".force_encoding("utf-16le") + data = "\x04\bI\"\x0Fm\x00\xF6\x00h\x00r\x00e\x00\x06:\rencoding\"\rUTF-16LE" + result = Marshal.send(@method, data) + result.should == str + result.encoding.should equal(Encoding::UTF_16LE) + end + + it "loads a String as ASCII-8BIT if no encoding is specified at the end" do + str = "\xC3\xB8".force_encoding("ASCII-8BIT") + data = "\x04\b\"\a\xC3\xB8".force_encoding("UTF-8") + result = Marshal.send(@method, data) + result.encoding.should == Encoding::ASCII_8BIT + result.should == str end end diff --git a/spec/ruby/core/matchdata/post_match_spec.rb b/spec/ruby/core/matchdata/post_match_spec.rb index 43e25561af..6e13438124 100644 --- a/spec/ruby/core/matchdata/post_match_spec.rb +++ b/spec/ruby/core/matchdata/post_match_spec.rb @@ -22,15 +22,13 @@ describe "MatchData#post_match" do $'.untrusted?.should be_true end - with_feature :encoding do - it "sets the encoding to the encoding of the source String" do - str = "abc".force_encoding Encoding::EUC_JP - str.match(/b/).post_match.encoding.should equal(Encoding::EUC_JP) - end + it "sets the encoding to the encoding of the source String" do + str = "abc".force_encoding Encoding::EUC_JP + str.match(/b/).post_match.encoding.should equal(Encoding::EUC_JP) + end - it "sets an empty result to the encoding of the source String" do - str = "abc".force_encoding Encoding::ISO_8859_1 - str.match(/c/).post_match.encoding.should equal(Encoding::ISO_8859_1) - end + it "sets an empty result to the encoding of the source String" do + str = "abc".force_encoding Encoding::ISO_8859_1 + str.match(/c/).post_match.encoding.should equal(Encoding::ISO_8859_1) end end diff --git a/spec/ruby/core/matchdata/pre_match_spec.rb b/spec/ruby/core/matchdata/pre_match_spec.rb index f71920354c..816cc91eb2 100644 --- a/spec/ruby/core/matchdata/pre_match_spec.rb +++ b/spec/ruby/core/matchdata/pre_match_spec.rb @@ -22,15 +22,13 @@ describe "MatchData#pre_match" do $`.untrusted?.should be_true end - with_feature :encoding do - it "sets the encoding to the encoding of the source String" do - str = "abc".force_encoding Encoding::EUC_JP - str.match(/b/).pre_match.encoding.should equal(Encoding::EUC_JP) - end + it "sets the encoding to the encoding of the source String" do + str = "abc".force_encoding Encoding::EUC_JP + str.match(/b/).pre_match.encoding.should equal(Encoding::EUC_JP) + end - it "sets an empty result to the encoding of the source String" do - str = "abc".force_encoding Encoding::ISO_8859_1 - str.match(/a/).pre_match.encoding.should equal(Encoding::ISO_8859_1) - end + it "sets an empty result to the encoding of the source String" do + str = "abc".force_encoding Encoding::ISO_8859_1 + str.match(/a/).pre_match.encoding.should equal(Encoding::ISO_8859_1) end end diff --git a/spec/ruby/core/objectspace/define_finalizer_spec.rb b/spec/ruby/core/objectspace/define_finalizer_spec.rb index e2869ee706..b7e47473a0 100644 --- a/spec/ruby/core/objectspace/define_finalizer_spec.rb +++ b/spec/ruby/core/objectspace/define_finalizer_spec.rb @@ -3,8 +3,6 @@ require_relative 'fixtures/classes' # NOTE: A call to define_finalizer does not guarantee that the # passed proc or callable will be called at any particular time. -# It is highly questionable whether these aspects of ObjectSpace -# should be spec'd at all. describe "ObjectSpace.define_finalizer" do it "raises an ArgumentError if the action does not respond to call" do lambda { @@ -30,72 +28,41 @@ describe "ObjectSpace.define_finalizer" do end # see [ruby-core:24095] - with_feature :fork do - it "calls finalizer on process termination" do - rd, wr = IO.pipe - pid = Process.fork do - rd.close - handler = ObjectSpaceFixtures.scoped(wr) - obj = "Test" - ObjectSpace.define_finalizer(obj, handler) - exit 0 + it "calls finalizer on process termination" do + code = <<-RUBY + def scoped + Proc.new { puts "finalized" } end + handler = scoped + obj = "Test" + ObjectSpace.define_finalizer(obj, handler) + exit 0 + RUBY - wr.close - begin - rd.read.should == "finalized" - ensure - rd.close - Process.wait pid - end - end - - it "calls finalizer at exit even if it is self-referencing" do - rd, wr = IO.pipe - pid = Process.fork do - rd.close - obj = "Test" - handler = Proc.new { wr.write "finalized"; wr.close } - ObjectSpace.define_finalizer(obj, handler) - exit 0 - end - - wr.close - begin - rd.read.should == "finalized" - ensure - rd.close - Process.wait pid - end - end - - # These specs are defined under the fork specs because there is no - # deterministic way to force finalizers to be run, except process exit, so - # we rely on that. - it "allows multiple finalizers with different 'callables' to be defined" do - rd1, wr1 = IO.pipe - rd2, wr2 = IO.pipe + ruby_exe(code).should == "finalized\n" + end - pid = Kernel::fork do - rd1.close - rd2.close - obj = mock("ObjectSpace.define_finalizer multiple") + it "calls finalizer at exit even if it is self-referencing" do + code = <<-RUBY + obj = "Test" + handler = Proc.new { puts "finalized" } + ObjectSpace.define_finalizer(obj, handler) + exit 0 + RUBY - ObjectSpace.define_finalizer(obj, Proc.new { wr1.write "finalized1"; wr1.close }) - ObjectSpace.define_finalizer(obj, Proc.new { wr2.write "finalized2"; wr2.close }) + ruby_exe(code).should == "finalized\n" + end - exit 0 - end + it "allows multiple finalizers with different 'callables' to be defined" do + code = <<-RUBY + obj = Object.new - wr1.close - wr2.close + ObjectSpace.define_finalizer(obj, Proc.new { STDOUT.write "finalized1\n" }) + ObjectSpace.define_finalizer(obj, Proc.new { STDOUT.write "finalized2\n" }) - rd1.read.should == "finalized1" - rd2.read.should == "finalized2" + exit 0 + RUBY - rd1.close - rd2.close - Process.wait pid - end + ruby_exe(code).lines.sort.should == ["finalized1\n", "finalized2\n"] end end diff --git a/spec/ruby/core/process/euid_spec.rb b/spec/ruby/core/process/euid_spec.rb index bc3f52592e..ffb71a7178 100644 --- a/spec/ruby/core/process/euid_spec.rb +++ b/spec/ruby/core/process/euid_spec.rb @@ -33,25 +33,12 @@ describe "Process.euid=" do as_superuser do describe "if run by a superuser" do - with_feature :fork do - it "sets the effective user id for the current process if run by a superuser" do - read, write = IO.pipe - pid = Process.fork do - begin - read.close - Process.euid = 1 - write << Process.euid - write.close - rescue Exception => e - write << e << e.backtrace - end - Process.exit! - end - write.close - euid = read.gets - euid.should == "1" - Process.wait pid - end + it "sets the effective user id for the current process if run by a superuser" do + code = <<-RUBY + Process.euid = 1 + puts Process.euid + RUBY + ruby_exe(code).should == "1\n" end end end diff --git a/spec/ruby/core/process/ppid_spec.rb b/spec/ruby/core/process/ppid_spec.rb index e0bdfef30b..7d22755c77 100644 --- a/spec/ruby/core/process/ppid_spec.rb +++ b/spec/ruby/core/process/ppid_spec.rb @@ -1,23 +1,7 @@ require_relative '../../spec_helper' describe "Process.ppid" do - with_feature :fork do - it "returns the process id of the parent of this process" do - - read, write = IO.pipe - - child_pid = Process.fork { - read.close - write << "#{Process.ppid}\n" - write.close - exit! - } - - write.close - pid = read.gets - read.close - Process.wait(child_pid) - pid.to_i.should == Process.pid - end + it "returns the process id of the parent of this process" do + ruby_exe("puts Process.ppid").should == "#{Process.pid}\n" end end diff --git a/spec/ruby/core/process/setpgid_spec.rb b/spec/ruby/core/process/setpgid_spec.rb index 992fbc3f4d..be724e9007 100644 --- a/spec/ruby/core/process/setpgid_spec.rb +++ b/spec/ruby/core/process/setpgid_spec.rb @@ -1,7 +1,8 @@ require_relative '../../spec_helper' describe "Process.setpgid" do - with_feature :fork do + platform_is_not :windows do + # Must use fork as setpgid(2) gives EACCESS after execve() it "sets the process group id of the specified process" do rd, wr = IO.pipe diff --git a/spec/ruby/core/process/setsid_spec.rb b/spec/ruby/core/process/setsid_spec.rb index d00508a1f7..c83f912066 100644 --- a/spec/ruby/core/process/setsid_spec.rb +++ b/spec/ruby/core/process/setsid_spec.rb @@ -1,37 +1,16 @@ require_relative '../../spec_helper' describe "Process.setsid" do - with_feature :fork do + platform_is_not :windows do it "establishes this process as a new session and process group leader" do - read, write = IO.pipe - read2, write2 = IO.pipe - pid = Process.fork { - begin - read.close - write2.close - pgid = Process.setsid - write << pgid - write.close - read2.gets - rescue Exception => e - write << e << e.backtrace - end - Process.exit! - } - write.close - read2.close - pgid_child = Integer(read.gets) - read.close - platform_is_not :aix, :openbsd do - # AIX does not allow Process.getsid(pid) - # if pid is in a different session. - pgid = Process.getsid(pid) - pgid_child.should == pgid - end - write2.close - Process.wait pid + sid = Process.getsid - pgid_child.should_not == Process.getsid + out = ruby_exe("p Process.getsid; p Process.setsid; p Process.getsid").lines + out[0].should == "#{sid}\n" + out[1].should == out[2] + out[2].should_not == "#{sid}\n" + + sid.should == Process.getsid end end end diff --git a/spec/ruby/core/process/uid_spec.rb b/spec/ruby/core/process/uid_spec.rb index 4a66beaa2a..350779aff3 100644 --- a/spec/ruby/core/process/uid_spec.rb +++ b/spec/ruby/core/process/uid_spec.rb @@ -18,7 +18,6 @@ describe "Process.uid" do end describe "Process.uid=" do - platform_is_not :windows do it "raises TypeError if not passed an Integer" do lambda { Process.uid = Object.new }.should raise_error(TypeError) @@ -36,49 +35,23 @@ describe "Process.uid=" do as_superuser do describe "if run by a superuser" do - with_feature :fork do - it "sets the real user id for the current process" do - read, write = IO.pipe - pid = Process.fork do - begin - read.close - Process.uid = 1 - write << Process.uid - write.close - rescue Exception => e - write << e << e.backtrace - end - Process.exit! - end - write.close - uid = read.gets - uid.should == "1" - Process.wait pid - end + it "sets the real user id for the current process" do + code = <<-RUBY + Process.uid = 1 + puts Process.uid + RUBY + ruby_exe(code).should == "1\n" + end - it "sets the real user id if preceded by Process.euid=id" do - read, write = IO.pipe - pid = Process.fork do - begin - read.close - Process.euid = 1 - Process.uid = 1 - write << Process.uid - write.close - rescue Exception => e - write << e << e.backtrace - end - Process.exit! - end - write.close - uid = read.gets - uid.should == "1" - Process.wait pid - end + it "sets the real user id if preceded by Process.euid=id" do + code = <<-RUBY + Process.euid = 1 + Process.uid = 1 + puts Process.uid + RUBY + ruby_exe(code).should == "1\n" end end end end - - it "needs to be reviewed for spec completeness" end diff --git a/spec/ruby/core/process/wait2_spec.rb b/spec/ruby/core/process/wait2_spec.rb index 18bf4be432..4b6491ccd2 100644 --- a/spec/ruby/core/process/wait2_spec.rb +++ b/spec/ruby/core/process/wait2_spec.rb @@ -8,9 +8,7 @@ describe "Process.wait2" do # but we shouldn't reap them from Ruby-space begin Process.wait(-1, Process::WNOHANG) - without_feature :mjit do - $stderr.puts "Leaked process before wait2 specs! Waiting for it" - end + $stderr.puts "Leaked process before wait2 specs! Waiting for it" leaked = Process.waitall $stderr.puts "leaked before wait2 specs: #{leaked}" unless leaked.empty? # Ruby-space should not see PIDs used by mjit diff --git a/spec/ruby/core/regexp/match_spec.rb b/spec/ruby/core/regexp/match_spec.rb index 45ed4a5932..ebbba38211 100644 --- a/spec/ruby/core/regexp/match_spec.rb +++ b/spec/ruby/core/regexp/match_spec.rb @@ -44,15 +44,13 @@ describe "Regexp#match" do /(.).(.)/.match("01234", 1).captures.should == ["1", "3"] end - with_feature :encoding do - it "uses the start as a character offset" do - /(.).(.)/.match("零一二三四", 1).captures.should == ["一", "三"] - end - - it "raises an ArgumentError for an invalid encoding" do - x96 = ([150].pack('C')).force_encoding('utf-8') - lambda { /(.).(.)/.match("Hello, #{x96} world!", 1) }.should raise_error(ArgumentError) - end + it "uses the start as a character offset" do + /(.).(.)/.match("零一二三四", 1).captures.should == ["一", "三"] + end + + it "raises an ArgumentError for an invalid encoding" do + x96 = ([150].pack('C')).force_encoding('utf-8') + lambda { /(.).(.)/.match("Hello, #{x96} world!", 1) }.should raise_error(ArgumentError) end end @@ -61,15 +59,13 @@ describe "Regexp#match" do /(.).(.)/.match("01234", -4).captures.should == ["1", "3"] end - with_feature :encoding do - it "uses the start as a character offset" do - /(.).(.)/.match("零一二三四", -4).captures.should == ["一", "三"] - end + it "uses the start as a character offset" do + /(.).(.)/.match("零一二三四", -4).captures.should == ["一", "三"] + end - it "raises an ArgumentError for an invalid encoding" do - x96 = ([150].pack('C')).force_encoding('utf-8') - lambda { /(.).(.)/.match("Hello, #{x96} world!", -1) }.should raise_error(ArgumentError) - end + it "raises an ArgumentError for an invalid encoding" do + x96 = ([150].pack('C')).force_encoding('utf-8') + lambda { /(.).(.)/.match("Hello, #{x96} world!", -1) }.should raise_error(ArgumentError) end end diff --git a/spec/ruby/core/string/ascii_only_spec.rb b/spec/ruby/core/string/ascii_only_spec.rb index 3dce10fab3..e9f2dc1a36 100644 --- a/spec/ruby/core/string/ascii_only_spec.rb +++ b/spec/ruby/core/string/ascii_only_spec.rb @@ -2,84 +2,82 @@ require_relative '../../spec_helper' require_relative 'fixtures/classes' -with_feature :encoding do - describe "String#ascii_only?" do - describe "with ASCII only characters" do - it "returns true if the encoding is UTF-8" do - [ ["hello", true], - ["hello".encode('UTF-8'), true], - ["hello".force_encoding('UTF-8'), true], - ].should be_computed_by(:ascii_only?) - end - - it "returns true if the encoding is US-ASCII" do - "hello".force_encoding(Encoding::US_ASCII).ascii_only?.should be_true - "hello".encode(Encoding::US_ASCII).ascii_only?.should be_true - end - - it "returns true for all single-character UTF-8 Strings" do - 0.upto(127) do |n| - n.chr.ascii_only?.should be_true - end - end +describe "String#ascii_only?" do + describe "with ASCII only characters" do + it "returns true if the encoding is UTF-8" do + [ ["hello", true], + ["hello".encode('UTF-8'), true], + ["hello".force_encoding('UTF-8'), true], + ].should be_computed_by(:ascii_only?) end - describe "with non-ASCII only characters" do - it "returns false if the encoding is ASCII-8BIT" do - chr = 128.chr - chr.encoding.should == Encoding::ASCII_8BIT - chr.ascii_only?.should be_false - end - - it "returns false if the String contains any non-ASCII characters" do - [ ["\u{6666}", false], - ["hello, \u{6666}", false], - ["\u{6666}".encode('UTF-8'), false], - ["\u{6666}".force_encoding('UTF-8'), false], - ].should be_computed_by(:ascii_only?) - end + it "returns true if the encoding is US-ASCII" do + "hello".force_encoding(Encoding::US_ASCII).ascii_only?.should be_true + "hello".encode(Encoding::US_ASCII).ascii_only?.should be_true + end - it "returns false if the encoding is US-ASCII" do - [ ["\u{6666}".force_encoding(Encoding::US_ASCII), false], - ["hello, \u{6666}".force_encoding(Encoding::US_ASCII), false], - ].should be_computed_by(:ascii_only?) + it "returns true for all single-character UTF-8 Strings" do + 0.upto(127) do |n| + n.chr.ascii_only?.should be_true end end + end - it "returns true for the empty String with an ASCII-compatible encoding" do - "".ascii_only?.should be_true - "".encode('UTF-8').ascii_only?.should be_true + describe "with non-ASCII only characters" do + it "returns false if the encoding is ASCII-8BIT" do + chr = 128.chr + chr.encoding.should == Encoding::ASCII_8BIT + chr.ascii_only?.should be_false end - it "returns false for the empty String with a non-ASCII-compatible encoding" do - "".force_encoding('UTF-16LE').ascii_only?.should be_false - "".encode('UTF-16BE').ascii_only?.should be_false + it "returns false if the String contains any non-ASCII characters" do + [ ["\u{6666}", false], + ["hello, \u{6666}", false], + ["\u{6666}".encode('UTF-8'), false], + ["\u{6666}".force_encoding('UTF-8'), false], + ].should be_computed_by(:ascii_only?) end - it "returns false for a non-empty String with non-ASCII-compatible encoding" do - "\x78\x00".force_encoding("UTF-16LE").ascii_only?.should be_false + it "returns false if the encoding is US-ASCII" do + [ ["\u{6666}".force_encoding(Encoding::US_ASCII), false], + ["hello, \u{6666}".force_encoding(Encoding::US_ASCII), false], + ].should be_computed_by(:ascii_only?) end + end - it "returns false when interpolating non ascii strings" do - base = "EU currency is" - base.force_encoding(Encoding::US_ASCII) - euro = "\u20AC" - interp = "#{base} #{euro}" - euro.ascii_only?.should be_false - base.ascii_only?.should be_true - interp.ascii_only?.should be_false - end + it "returns true for the empty String with an ASCII-compatible encoding" do + "".ascii_only?.should be_true + "".encode('UTF-8').ascii_only?.should be_true + end - it "returns false after appending non ASCII characters to an empty String" do - ("" << "λ").ascii_only?.should be_false - end + it "returns false for the empty String with a non-ASCII-compatible encoding" do + "".force_encoding('UTF-16LE').ascii_only?.should be_false + "".encode('UTF-16BE').ascii_only?.should be_false + end - it "returns false when concatenating an ASCII and non-ASCII String" do - "".concat("λ").ascii_only?.should be_false - end + it "returns false for a non-empty String with non-ASCII-compatible encoding" do + "\x78\x00".force_encoding("UTF-16LE").ascii_only?.should be_false + end - it "returns false when replacing an ASCII String with a non-ASCII String" do - "".replace("λ").ascii_only?.should be_false - end + it "returns false when interpolating non ascii strings" do + base = "EU currency is" + base.force_encoding(Encoding::US_ASCII) + euro = "\u20AC" + interp = "#{base} #{euro}" + euro.ascii_only?.should be_false + base.ascii_only?.should be_true + interp.ascii_only?.should be_false + end + + it "returns false after appending non ASCII characters to an empty String" do + ("" << "λ").ascii_only?.should be_false + end + + it "returns false when concatenating an ASCII and non-ASCII String" do + "".concat("λ").ascii_only?.should be_false + end + + it "returns false when replacing an ASCII String with a non-ASCII String" do + "".replace("λ").ascii_only?.should be_false end end diff --git a/spec/ruby/core/string/b_spec.rb b/spec/ruby/core/string/b_spec.rb index 6599c23d73..638971f9ce 100644 --- a/spec/ruby/core/string/b_spec.rb +++ b/spec/ruby/core/string/b_spec.rb @@ -2,23 +2,21 @@ require_relative '../../spec_helper' describe "String#b" do - with_feature :encoding do - it "returns an ASCII-8BIT encoded string" do - "Hello".b.should == "Hello".force_encoding(Encoding::ASCII_8BIT) - "こんちには".b.should == "こんちには".force_encoding(Encoding::ASCII_8BIT) - end + it "returns an ASCII-8BIT encoded string" do + "Hello".b.should == "Hello".force_encoding(Encoding::ASCII_8BIT) + "こんちには".b.should == "こんちには".force_encoding(Encoding::ASCII_8BIT) + end - it "returns new string without modifying self" do - str = "こんちには" - str.b.should_not equal(str) - str.should == "こんちには" - end + it "returns new string without modifying self" do + str = "こんちには" + str.b.should_not equal(str) + str.should == "こんちには" + end - it "copies own tainted/untrusted status to the returning value" do - utf_8 = "こんちには".taint.untrust - ret = utf_8.b - ret.tainted?.should be_true - ret.untrusted?.should be_true - end + it "copies own tainted/untrusted status to the returning value" do + utf_8 = "こんちには".taint.untrust + ret = utf_8.b + ret.tainted?.should be_true + ret.untrusted?.should be_true end end diff --git a/spec/ruby/core/string/bytes_spec.rb b/spec/ruby/core/string/bytes_spec.rb index e7d3a7fbd8..96f1ae9cf2 100644 --- a/spec/ruby/core/string/bytes_spec.rb +++ b/spec/ruby/core/string/bytes_spec.rb @@ -36,22 +36,20 @@ describe "String#bytes" do end end -with_feature :encoding do - describe "String#bytes" do - before :each do - @utf8 = "東京" - @ascii = 'Tokyo' - @utf8_ascii = @utf8 + @ascii - end +describe "String#bytes" do + before :each do + @utf8 = "東京" + @ascii = 'Tokyo' + @utf8_ascii = @utf8 + @ascii + end - it "agrees with #getbyte" do - @utf8_ascii.bytes.to_a.each_with_index do |byte,index| - byte.should == @utf8_ascii.getbyte(index) - end + it "agrees with #getbyte" do + @utf8_ascii.bytes.to_a.each_with_index do |byte,index| + byte.should == @utf8_ascii.getbyte(index) end + end - it "is unaffected by #force_encoding" do - @utf8.force_encoding('ASCII').bytes.to_a.should == @utf8.bytes.to_a - end + it "is unaffected by #force_encoding" do + @utf8.force_encoding('ASCII').bytes.to_a.should == @utf8.bytes.to_a end end diff --git a/spec/ruby/core/string/bytesize_spec.rb b/spec/ruby/core/string/bytesize_spec.rb index 527b4a5dd5..b63d718c6c 100644 --- a/spec/ruby/core/string/bytesize_spec.rb +++ b/spec/ruby/core/string/bytesize_spec.rb @@ -2,36 +2,34 @@ require_relative '../../spec_helper' require_relative 'fixtures/classes' -with_feature :encoding do - describe "#String#bytesize" do - it "needs to be reviewed for spec completeness" +describe "#String#bytesize" do + it "needs to be reviewed for spec completeness" - it "returns the length of self in bytes" do - "hello".bytesize.should == 5 - " ".bytesize.should == 1 - end + it "returns the length of self in bytes" do + "hello".bytesize.should == 5 + " ".bytesize.should == 1 + end - it "works with strings containing single UTF-8 characters" do - "\u{6666}".bytesize.should == 3 - end + it "works with strings containing single UTF-8 characters" do + "\u{6666}".bytesize.should == 3 + end - it "works with pseudo-ASCII strings containing single UTF-8 characters" do - "\u{6666}".force_encoding('ASCII').bytesize.should == 3 - end + it "works with pseudo-ASCII strings containing single UTF-8 characters" do + "\u{6666}".force_encoding('ASCII').bytesize.should == 3 + end - it "works with strings containing UTF-8 characters" do - "c \u{6666}".force_encoding('UTF-8').bytesize.should == 5 - "c \u{6666}".bytesize.should == 5 - end + it "works with strings containing UTF-8 characters" do + "c \u{6666}".force_encoding('UTF-8').bytesize.should == 5 + "c \u{6666}".bytesize.should == 5 + end - it "works with pseudo-ASCII strings containing UTF-8 characters" do - "c \u{6666}".force_encoding('ASCII').bytesize.should == 5 - end + it "works with pseudo-ASCII strings containing UTF-8 characters" do + "c \u{6666}".force_encoding('ASCII').bytesize.should == 5 + end - it "returns 0 for the empty string" do - "".bytesize.should == 0 - "".force_encoding('ASCII').bytesize.should == 0 - "".force_encoding('UTF-8').bytesize.should == 0 - end + it "returns 0 for the empty string" do + "".bytesize.should == 0 + "".force_encoding('ASCII').bytesize.should == 0 + "".force_encoding('UTF-8').bytesize.should == 0 end end diff --git a/spec/ruby/core/string/byteslice_spec.rb b/spec/ruby/core/string/byteslice_spec.rb index df99db95c6..a49da040eb 100644 --- a/spec/ruby/core/string/byteslice_spec.rb +++ b/spec/ruby/core/string/byteslice_spec.rb @@ -17,13 +17,11 @@ describe "String#byteslice with Range" do it_behaves_like :string_slice_range, :byteslice end -with_feature :encoding do - describe "String#byteslice on on non ASCII strings" do - it "returns byteslice of unicode strings" do - "\u3042".byteslice(1).should == "\x81".force_encoding("UTF-8") - "\u3042".byteslice(1, 2).should == "\x81\x82".force_encoding("UTF-8") - "\u3042".byteslice(1..2).should == "\x81\x82".force_encoding("UTF-8") - "\u3042".byteslice(-1).should == "\x82".force_encoding("UTF-8") - end +describe "String#byteslice on on non ASCII strings" do + it "returns byteslice of unicode strings" do + "\u3042".byteslice(1).should == "\x81".force_encoding("UTF-8") + "\u3042".byteslice(1, 2).should == "\x81\x82".force_encoding("UTF-8") + "\u3042".byteslice(1..2).should == "\x81\x82".force_encoding("UTF-8") + "\u3042".byteslice(-1).should == "\x82".force_encoding("UTF-8") end end diff --git a/spec/ruby/core/string/center_spec.rb b/spec/ruby/core/string/center_spec.rb index 145db01b70..3a9e689eac 100644 --- a/spec/ruby/core/string/center_spec.rb +++ b/spec/ruby/core/string/center_spec.rb @@ -104,30 +104,28 @@ describe "String#center with length, padding" do "hello".center(6, 'X'.taint).tainted?.should be_true end - with_feature :encoding do - describe "with width" do - it "returns a String in the same encoding as the original" do - str = "abc".force_encoding Encoding::IBM437 - result = str.center 6 - result.should == " abc " - result.encoding.should equal(Encoding::IBM437) - end + describe "with width" do + it "returns a String in the same encoding as the original" do + str = "abc".force_encoding Encoding::IBM437 + result = str.center 6 + result.should == " abc " + result.encoding.should equal(Encoding::IBM437) + end + end + + describe "with width, pattern" do + it "returns a String in the compatible encoding" do + str = "abc".force_encoding Encoding::IBM437 + result = str.center 6, "あ" + result.should == "あabcああ" + result.encoding.should equal(Encoding::UTF_8) end - describe "with width, pattern" do - it "returns a String in the compatible encoding" do - str = "abc".force_encoding Encoding::IBM437 - result = str.center 6, "あ" - result.should == "あabcああ" - result.encoding.should equal(Encoding::UTF_8) - end - - it "raises an Encoding::CompatibilityError if the encodings are incompatible" do - pat = "ア".encode Encoding::EUC_JP - lambda do - "あれ".center 5, pat - end.should raise_error(Encoding::CompatibilityError) - end + it "raises an Encoding::CompatibilityError if the encodings are incompatible" do + pat = "ア".encode Encoding::EUC_JP + lambda do + "あれ".center 5, pat + end.should raise_error(Encoding::CompatibilityError) end end end diff --git a/spec/ruby/core/string/chomp_spec.rb b/spec/ruby/core/string/chomp_spec.rb index d6ad710382..7400d71336 100644 --- a/spec/ruby/core/string/chomp_spec.rb +++ b/spec/ruby/core/string/chomp_spec.rb @@ -330,62 +330,60 @@ describe "String#chomp!" do end end -with_feature :encoding do - describe "String#chomp" do - before :each do - @before_separator = $/ - end +describe "String#chomp" do + before :each do + @before_separator = $/ + end - after :each do - $/ = @before_separator - end + after :each do + $/ = @before_separator + end - it "does not modify a multi-byte character" do - "あれ".chomp.should == "あれ" - end + it "does not modify a multi-byte character" do + "あれ".chomp.should == "あれ" + end - it "removes the final carriage return, newline from a multibyte String" do - "あれ\r\n".chomp.should == "あれ" - end + it "removes the final carriage return, newline from a multibyte String" do + "あれ\r\n".chomp.should == "あれ" + end - it "removes the final carriage return, newline from a non-ASCII String" do - str = "abc\r\n".encode "utf-32be" - str.chomp.should == "abc".encode("utf-32be") - end + it "removes the final carriage return, newline from a non-ASCII String" do + str = "abc\r\n".encode "utf-32be" + str.chomp.should == "abc".encode("utf-32be") + end - it "removes the final carriage return, newline from a non-ASCII String when the record separator is changed" do - $/ = "\n".encode("utf-8") - str = "abc\r\n".encode "utf-32be" - str.chomp.should == "abc".encode("utf-32be") - end + it "removes the final carriage return, newline from a non-ASCII String when the record separator is changed" do + $/ = "\n".encode("utf-8") + str = "abc\r\n".encode "utf-32be" + str.chomp.should == "abc".encode("utf-32be") end +end - describe "String#chomp!" do - before :each do - @before_separator = $/ - end +describe "String#chomp!" do + before :each do + @before_separator = $/ + end - after :each do - $/ = @before_separator - end + after :each do + $/ = @before_separator + end - it "returns nil when the String is not modified" do - "あれ".chomp!.should be_nil - end + it "returns nil when the String is not modified" do + "あれ".chomp!.should be_nil + end - it "removes the final carriage return, newline from a multibyte String" do - "あれ\r\n".chomp!.should == "あれ" - end + it "removes the final carriage return, newline from a multibyte String" do + "あれ\r\n".chomp!.should == "あれ" + end - it "removes the final carriage return, newline from a non-ASCII String" do - str = "abc\r\n".encode "utf-32be" - str.chomp!.should == "abc".encode("utf-32be") - end + it "removes the final carriage return, newline from a non-ASCII String" do + str = "abc\r\n".encode "utf-32be" + str.chomp!.should == "abc".encode("utf-32be") + end - it "removes the final carriage return, newline from a non-ASCII String when the record separator is changed" do - $/ = "\n".encode("utf-8") - str = "abc\r\n".encode "utf-32be" - str.chomp!.should == "abc".encode("utf-32be") - end + it "removes the final carriage return, newline from a non-ASCII String when the record separator is changed" do + $/ = "\n".encode("utf-8") + str = "abc\r\n".encode "utf-32be" + str.chomp!.should == "abc".encode("utf-32be") end end diff --git a/spec/ruby/core/string/chop_spec.rb b/spec/ruby/core/string/chop_spec.rb index 033a11a95b..f33da3ecc4 100644 --- a/spec/ruby/core/string/chop_spec.rb +++ b/spec/ruby/core/string/chop_spec.rb @@ -27,19 +27,17 @@ describe "String#chop" do "abc\r\n\r\n".chop.should == "abc\r\n" end - with_feature :encoding do - it "removes a multi-byte character" do - "あれ".chop.should == "あ" - end + it "removes a multi-byte character" do + "あれ".chop.should == "あ" + end - it "removes the final carriage return, newline from a multibyte String" do - "あれ\r\n".chop.should == "あれ" - end + it "removes the final carriage return, newline from a multibyte String" do + "あれ\r\n".chop.should == "あれ" + end - it "removes the final carriage return, newline from a non-ASCII String" do - str = "abc\r\n".encode "utf-32be" - str.chop.should == "abc".encode("utf-32be") - end + it "removes the final carriage return, newline from a non-ASCII String" do + str = "abc\r\n".encode "utf-32be" + str.chop.should == "abc".encode("utf-32be") end it "returns an empty string when applied to an empty string" do @@ -91,19 +89,17 @@ describe "String#chop!" do "abc\r\n\r\n".chop!.should == "abc\r\n" end - with_feature :encoding do - it "removes a multi-byte character" do - "あれ".chop!.should == "あ" - end + it "removes a multi-byte character" do + "あれ".chop!.should == "あ" + end - it "removes the final carriage return, newline from a multibyte String" do - "あれ\r\n".chop!.should == "あれ" - end + it "removes the final carriage return, newline from a multibyte String" do + "あれ\r\n".chop!.should == "あれ" + end - it "removes the final carriage return, newline from a non-ASCII String" do - str = "abc\r\n".encode "utf-32be" - str.chop!.should == "abc".encode("utf-32be") - end + it "removes the final carriage return, newline from a non-ASCII String" do + str = "abc\r\n".encode "utf-32be" + str.chop!.should == "abc".encode("utf-32be") end it "returns self if modifications were made" do diff --git a/spec/ruby/core/string/chr_spec.rb b/spec/ruby/core/string/chr_spec.rb index ca56955866..9ed29542e6 100644 --- a/spec/ruby/core/string/chr_spec.rb +++ b/spec/ruby/core/string/chr_spec.rb @@ -1,44 +1,42 @@ require_relative '../../spec_helper' -with_feature :encoding do - describe "String#chr" do - it "returns a copy of self" do - s = 'e' - s.should_not equal s.chr - end - - it "returns a String" do - 'glark'.chr.should be_an_instance_of(String) - end - - it "returns an empty String if self is an empty String" do - "".chr.should == "" - end - - it "returns a 1-character String" do - "glark".chr.size.should == 1 - end - - it "returns the character at the start of the String" do - "Goodbye, world".chr.should == "G" - end - - it "returns a String in the same encoding as self" do - "\x24".encode(Encoding::US_ASCII).chr.encoding.should == Encoding::US_ASCII - end - - it "understands multi-byte characters" do - s = "\u{9879}" - s.bytesize.should == 3 - s.chr.should == s - end - - it "understands Strings that contain a mixture of character widths" do - three = "\u{8082}" - three.bytesize.should == 3 - four = "\u{77082}" - four.bytesize.should == 4 - "#{three}#{four}".chr.should == three - end +describe "String#chr" do + it "returns a copy of self" do + s = 'e' + s.should_not equal s.chr + end + + it "returns a String" do + 'glark'.chr.should be_an_instance_of(String) + end + + it "returns an empty String if self is an empty String" do + "".chr.should == "" + end + + it "returns a 1-character String" do + "glark".chr.size.should == 1 + end + + it "returns the character at the start of the String" do + "Goodbye, world".chr.should == "G" + end + + it "returns a String in the same encoding as self" do + "\x24".encode(Encoding::US_ASCII).chr.encoding.should == Encoding::US_ASCII + end + + it "understands multi-byte characters" do + s = "\u{9879}" + s.bytesize.should == 3 + s.chr.should == s + end + + it "understands Strings that contain a mixture of character widths" do + three = "\u{8082}" + three.bytesize.should == 3 + four = "\u{77082}" + four.bytesize.should == 4 + "#{three}#{four}".chr.should == three end end diff --git a/spec/ruby/core/string/clear_spec.rb b/spec/ruby/core/string/clear_spec.rb index 8b0ff8a8e6..45d452e947 100644 --- a/spec/ruby/core/string/clear_spec.rb +++ b/spec/ruby/core/string/clear_spec.rb @@ -1,39 +1,37 @@ require_relative '../../spec_helper' -with_feature :encoding do - describe "String#clear" do - before :each do - @s = "Jolene" - end +describe "String#clear" do + before :each do + @s = "Jolene" + end - it "sets self equal to the empty String" do - @s.clear - @s.should == "" - end + it "sets self equal to the empty String" do + @s.clear + @s.should == "" + end - it "returns self after emptying it" do - cleared = @s.clear - cleared.should == "" - cleared.should equal @s - end + it "returns self after emptying it" do + cleared = @s.clear + cleared.should == "" + cleared.should equal @s + end - it "preserves its encoding" do - @s.encode!(Encoding::SHIFT_JIS) - @s.encoding.should == Encoding::SHIFT_JIS - @s.clear.encoding.should == Encoding::SHIFT_JIS - @s.encoding.should == Encoding::SHIFT_JIS - end + it "preserves its encoding" do + @s.encode!(Encoding::SHIFT_JIS) + @s.encoding.should == Encoding::SHIFT_JIS + @s.clear.encoding.should == Encoding::SHIFT_JIS + @s.encoding.should == Encoding::SHIFT_JIS + end - it "works with multibyte Strings" do - s = "\u{9765}\u{876}" - s.clear - s.should == "" - end + it "works with multibyte Strings" do + s = "\u{9765}\u{876}" + s.clear + s.should == "" + end - it "raises a #{frozen_error_class} if self is frozen" do - @s.freeze - lambda { @s.clear }.should raise_error(frozen_error_class) - lambda { "".freeze.clear }.should raise_error(frozen_error_class) - end + it "raises a #{frozen_error_class} if self is frozen" do + @s.freeze + lambda { @s.clear }.should raise_error(frozen_error_class) + lambda { "".freeze.clear }.should raise_error(frozen_error_class) end end diff --git a/spec/ruby/core/string/codepoints_spec.rb b/spec/ruby/core/string/codepoints_spec.rb index bccb3d0484..e5eeb8b69d 100644 --- a/spec/ruby/core/string/codepoints_spec.rb +++ b/spec/ruby/core/string/codepoints_spec.rb @@ -3,18 +3,16 @@ require_relative '../../spec_helper' require_relative 'shared/codepoints' require_relative 'shared/each_codepoint_without_block' -with_feature :encoding do - describe "String#codepoints" do - it_behaves_like :string_codepoints, :codepoints +describe "String#codepoints" do + it_behaves_like :string_codepoints, :codepoints - it "returns an Array when no block is given" do - "abc".codepoints.should == [?a.ord, ?b.ord, ?c.ord] - end + it "returns an Array when no block is given" do + "abc".codepoints.should == [?a.ord, ?b.ord, ?c.ord] + end - it "raises an ArgumentError when no block is given if self has an invalid encoding" do - s = "\xDF".force_encoding(Encoding::UTF_8) - s.valid_encoding?.should be_false - lambda { s.codepoints }.should raise_error(ArgumentError) - end + it "raises an ArgumentError when no block is given if self has an invalid encoding" do + s = "\xDF".force_encoding(Encoding::UTF_8) + s.valid_encoding?.should be_false + lambda { s.codepoints }.should raise_error(ArgumentError) end end diff --git a/spec/ruby/core/string/downcase_spec.rb b/spec/ruby/core/string/downcase_spec.rb index 241bd8c147..9d57ea8e25 100644 --- a/spec/ruby/core/string/downcase_spec.rb +++ b/spec/ruby/core/string/downcase_spec.rb @@ -174,9 +174,7 @@ describe "String#downcase!" do lambda { "hello".freeze.downcase! }.should raise_error(frozen_error_class) end - with_feature :encoding do - it "sets the result String encoding to the source String encoding" do - "ABC".downcase.encoding.should equal(Encoding::UTF_8) - end + it "sets the result String encoding to the source String encoding" do + "ABC".downcase.encoding.should equal(Encoding::UTF_8) end end diff --git a/spec/ruby/core/string/each_codepoint_spec.rb b/spec/ruby/core/string/each_codepoint_spec.rb index 41ca527653..c11cb1beae 100644 --- a/spec/ruby/core/string/each_codepoint_spec.rb +++ b/spec/ruby/core/string/each_codepoint_spec.rb @@ -2,9 +2,7 @@ require_relative '../../spec_helper' require_relative 'shared/codepoints' require_relative 'shared/each_codepoint_without_block' -with_feature :encoding do - describe "String#each_codepoint" do - it_behaves_like :string_codepoints, :each_codepoint - it_behaves_like :string_each_codepoint_without_block, :each_codepoint - end +describe "String#each_codepoint" do + it_behaves_like :string_codepoints, :each_codepoint + it_behaves_like :string_each_codepoint_without_block, :each_codepoint end diff --git a/spec/ruby/core/string/element_set_spec.rb b/spec/ruby/core/string/element_set_spec.rb index 340bd2b9ca..f85256d36e 100644 --- a/spec/ruby/core/string/element_set_spec.rb +++ b/spec/ruby/core/string/element_set_spec.rb @@ -83,68 +83,66 @@ describe "String#[]= with Fixnum index" do lambda { "test"[1] = nil }.should raise_error(TypeError) end - with_feature :encoding do - it "raises a TypeError if passed a Fixnum replacement" do - lambda { "abc"[1] = 65 }.should raise_error(TypeError) - end + it "raises a TypeError if passed a Fixnum replacement" do + lambda { "abc"[1] = 65 }.should raise_error(TypeError) + end - it "raises an IndexError if the index is greater than character size" do - lambda { "あれ"[4] = "a" }.should raise_error(IndexError) - end + it "raises an IndexError if the index is greater than character size" do + lambda { "あれ"[4] = "a" }.should raise_error(IndexError) + end - it "calls #to_int to convert the index" do - index = mock("string element set") - index.should_receive(:to_int).and_return(1) + it "calls #to_int to convert the index" do + index = mock("string element set") + index.should_receive(:to_int).and_return(1) - str = "あれ" - str[index] = "a" - str.should == "あa" - end + str = "あれ" + str[index] = "a" + str.should == "あa" + end - it "raises a TypeError if #to_int does not return an Fixnum" do - index = mock("string element set") - index.should_receive(:to_int).and_return('1') + it "raises a TypeError if #to_int does not return an Fixnum" do + index = mock("string element set") + index.should_receive(:to_int).and_return('1') - lambda { "abc"[index] = "d" }.should raise_error(TypeError) - end + lambda { "abc"[index] = "d" }.should raise_error(TypeError) + end - it "raises an IndexError if #to_int returns a value out of range" do - index = mock("string element set") - index.should_receive(:to_int).and_return(4) + it "raises an IndexError if #to_int returns a value out of range" do + index = mock("string element set") + index.should_receive(:to_int).and_return(4) - lambda { "ab"[index] = "c" }.should raise_error(IndexError) - end + lambda { "ab"[index] = "c" }.should raise_error(IndexError) + end - it "replaces a character with a multibyte character" do - str = "ありがとu" - str[4] = "う" - str.should == "ありがとう" - end + it "replaces a character with a multibyte character" do + str = "ありがとu" + str[4] = "う" + str.should == "ありがとう" + end - it "replaces a multibyte character with a character" do - str = "ありがとう" - str[4] = "u" - str.should == "ありがとu" - end + it "replaces a multibyte character with a character" do + str = "ありがとう" + str[4] = "u" + str.should == "ありがとu" + end - it "replaces a multibyte character with a multibyte character" do - str = "ありがとお" - str[4] = "う" - str.should == "ありがとう" - end + it "replaces a multibyte character with a multibyte character" do + str = "ありがとお" + str[4] = "う" + str.should == "ありがとう" + end - it "encodes the String in an encoding compatible with the replacement" do - str = " ".force_encoding Encoding::US_ASCII - rep = [160].pack('C').force_encoding Encoding::ASCII_8BIT - str[0] = rep - str.encoding.should equal(Encoding::ASCII_8BIT) - end + it "encodes the String in an encoding compatible with the replacement" do + str = " ".force_encoding Encoding::US_ASCII + rep = [160].pack('C').force_encoding Encoding::ASCII_8BIT + str[0] = rep + str.encoding.should equal(Encoding::ASCII_8BIT) + end - it "raises an Encoding::CompatibilityError if the replacement encoding is incompatible" do - str = "あれ" - rep = "が".encode Encoding::EUC_JP - lambda { str[0] = rep }.should raise_error(Encoding::CompatibilityError) - end + it "raises an Encoding::CompatibilityError if the replacement encoding is incompatible" do + str = "あれ" + rep = "が".encode Encoding::EUC_JP + lambda { str[0] = rep }.should raise_error(Encoding::CompatibilityError) end end @@ -172,37 +170,35 @@ describe "String#[]= with String index" do lambda { str["g"] = "h" }.should raise_error(IndexError) end - with_feature :encoding do - it "replaces characters with a multibyte character" do - str = "ありgaとう" - str["ga"] = "が" - str.should == "ありがとう" - end + it "replaces characters with a multibyte character" do + str = "ありgaとう" + str["ga"] = "が" + str.should == "ありがとう" + end - it "replaces multibyte characters with characters" do - str = "ありがとう" - str["が"] = "ga" - str.should == "ありgaとう" - end + it "replaces multibyte characters with characters" do + str = "ありがとう" + str["が"] = "ga" + str.should == "ありgaとう" + end - it "replaces multibyte characters with multibyte characters" do - str = "ありがとう" - str["が"] = "か" - str.should == "ありかとう" - end + it "replaces multibyte characters with multibyte characters" do + str = "ありがとう" + str["が"] = "か" + str.should == "ありかとう" + end - it "encodes the String in an encoding compatible with the replacement" do - str = " ".force_encoding Encoding::US_ASCII - rep = [160].pack('C').force_encoding Encoding::ASCII_8BIT - str[" "] = rep - str.encoding.should equal(Encoding::ASCII_8BIT) - end + it "encodes the String in an encoding compatible with the replacement" do + str = " ".force_encoding Encoding::US_ASCII + rep = [160].pack('C').force_encoding Encoding::ASCII_8BIT + str[" "] = rep + str.encoding.should equal(Encoding::ASCII_8BIT) + end - it "raises an Encoding::CompatibilityError if the replacement encoding is incompatible" do - str = "あれ" - rep = "が".encode Encoding::EUC_JP - lambda { str["れ"] = rep }.should raise_error(Encoding::CompatibilityError) - end + it "raises an Encoding::CompatibilityError if the replacement encoding is incompatible" do + str = "あれ" + rep = "が".encode Encoding::EUC_JP + lambda { str["れ"] = rep }.should raise_error(Encoding::CompatibilityError) end end @@ -287,37 +283,35 @@ describe "String#[]= with a Regexp index" do end end - with_feature :encoding do - it "replaces characters with a multibyte character" do - str = "ありgaとう" - str[/ga/] = "が" - str.should == "ありがとう" - end + it "replaces characters with a multibyte character" do + str = "ありgaとう" + str[/ga/] = "が" + str.should == "ありがとう" + end - it "replaces multibyte characters with characters" do - str = "ありがとう" - str[/が/] = "ga" - str.should == "ありgaとう" - end + it "replaces multibyte characters with characters" do + str = "ありがとう" + str[/が/] = "ga" + str.should == "ありgaとう" + end - it "replaces multibyte characters with multibyte characters" do - str = "ありがとう" - str[/が/] = "か" - str.should == "ありかとう" - end + it "replaces multibyte characters with multibyte characters" do + str = "ありがとう" + str[/が/] = "か" + str.should == "ありかとう" + end - it "encodes the String in an encoding compatible with the replacement" do - str = " ".force_encoding Encoding::US_ASCII - rep = [160].pack('C').force_encoding Encoding::ASCII_8BIT - str[/ /] = rep - str.encoding.should equal(Encoding::ASCII_8BIT) - end + it "encodes the String in an encoding compatible with the replacement" do + str = " ".force_encoding Encoding::US_ASCII + rep = [160].pack('C').force_encoding Encoding::ASCII_8BIT + str[/ /] = rep + str.encoding.should equal(Encoding::ASCII_8BIT) + end - it "raises an Encoding::CompatibilityError if the replacement encoding is incompatible" do - str = "あれ" - rep = "が".encode Encoding::EUC_JP - lambda { str[/れ/] = rep }.should raise_error(Encoding::CompatibilityError) - end + it "raises an Encoding::CompatibilityError if the replacement encoding is incompatible" do + str = "あれ" + rep = "が".encode Encoding::EUC_JP + lambda { str[/れ/] = rep }.should raise_error(Encoding::CompatibilityError) end end @@ -392,55 +386,53 @@ describe "String#[]= with a Range index" do str.should == "abcxd" end - with_feature :encoding do - it "replaces characters with a multibyte character" do - str = "ありgaとう" - str[2..3] = "が" - str.should == "ありがとう" - end + it "replaces characters with a multibyte character" do + str = "ありgaとう" + str[2..3] = "が" + str.should == "ありがとう" + end - it "replaces multibyte characters with characters" do - str = "ありがとう" - str[2...3] = "ga" - str.should == "ありgaとう" - end + it "replaces multibyte characters with characters" do + str = "ありがとう" + str[2...3] = "ga" + str.should == "ありgaとう" + end - it "replaces multibyte characters by negative indexes" do - str = "ありがとう" - str[-3...-2] = "ga" - str.should == "ありgaとう" - end + it "replaces multibyte characters by negative indexes" do + str = "ありがとう" + str[-3...-2] = "ga" + str.should == "ありgaとう" + end - it "replaces multibyte characters with multibyte characters" do - str = "ありがとう" - str[2..2] = "か" - str.should == "ありかとう" - end + it "replaces multibyte characters with multibyte characters" do + str = "ありがとう" + str[2..2] = "か" + str.should == "ありかとう" + end - it "deletes a multibyte character" do - str = "ありとう" - str[2..3] = "" - str.should == "あり" - end + it "deletes a multibyte character" do + str = "ありとう" + str[2..3] = "" + str.should == "あり" + end - it "inserts a multibyte character" do - str = "ありとう" - str[2...2] = "が" - str.should == "ありがとう" - end + it "inserts a multibyte character" do + str = "ありとう" + str[2...2] = "が" + str.should == "ありがとう" + end - it "encodes the String in an encoding compatible with the replacement" do - str = " ".force_encoding Encoding::US_ASCII - rep = [160].pack('C').force_encoding Encoding::ASCII_8BIT - str[0..1] = rep - str.encoding.should equal(Encoding::ASCII_8BIT) - end + it "encodes the String in an encoding compatible with the replacement" do + str = " ".force_encoding Encoding::US_ASCII + rep = [160].pack('C').force_encoding Encoding::ASCII_8BIT + str[0..1] = rep + str.encoding.should equal(Encoding::ASCII_8BIT) + end - it "raises an Encoding::CompatibilityError if the replacement encoding is incompatible" do - str = "あれ" - rep = "が".encode Encoding::EUC_JP - lambda { str[0..1] = rep }.should raise_error(Encoding::CompatibilityError) - end + it "raises an Encoding::CompatibilityError if the replacement encoding is incompatible" do + str = "あれ" + rep = "が".encode Encoding::EUC_JP + lambda { str[0..1] = rep }.should raise_error(Encoding::CompatibilityError) end end @@ -561,52 +553,50 @@ describe "String#[]= with Fixnum index, count" do lambda { "hello"[0, 2] = 33 }.should raise_error(TypeError) end - with_feature :encoding do - it "replaces characters with a multibyte character" do - str = "ありgaとう" - str[2, 2] = "が" - str.should == "ありがとう" - end + it "replaces characters with a multibyte character" do + str = "ありgaとう" + str[2, 2] = "が" + str.should == "ありがとう" + end - it "replaces multibyte characters with characters" do - str = "ありがとう" - str[2, 1] = "ga" - str.should == "ありgaとう" - end + it "replaces multibyte characters with characters" do + str = "ありがとう" + str[2, 1] = "ga" + str.should == "ありgaとう" + end - it "replaces multibyte characters with multibyte characters" do - str = "ありがとう" - str[2, 1] = "か" - str.should == "ありかとう" - end + it "replaces multibyte characters with multibyte characters" do + str = "ありがとう" + str[2, 1] = "か" + str.should == "ありかとう" + end - it "deletes a multibyte character" do - str = "ありとう" - str[2, 2] = "" - str.should == "あり" - end + it "deletes a multibyte character" do + str = "ありとう" + str[2, 2] = "" + str.should == "あり" + end - it "inserts a multibyte character" do - str = "ありとう" - str[2, 0] = "が" - str.should == "ありがとう" - end + it "inserts a multibyte character" do + str = "ありとう" + str[2, 0] = "が" + str.should == "ありがとう" + end - it "raises an IndexError if the character index is out of range of a multibyte String" do - lambda { "あれ"[3, 0] = "り" }.should raise_error(IndexError) - end + it "raises an IndexError if the character index is out of range of a multibyte String" do + lambda { "あれ"[3, 0] = "り" }.should raise_error(IndexError) + end - it "encodes the String in an encoding compatible with the replacement" do - str = " ".force_encoding Encoding::US_ASCII - rep = [160].pack('C').force_encoding Encoding::ASCII_8BIT - str[0, 1] = rep - str.encoding.should equal(Encoding::ASCII_8BIT) - end + it "encodes the String in an encoding compatible with the replacement" do + str = " ".force_encoding Encoding::US_ASCII + rep = [160].pack('C').force_encoding Encoding::ASCII_8BIT + str[0, 1] = rep + str.encoding.should equal(Encoding::ASCII_8BIT) + end - it "raises an Encoding::CompatibilityError if the replacement encoding is incompatible" do - str = "あれ" - rep = "が".encode Encoding::EUC_JP - lambda { str[0, 1] = rep }.should raise_error(Encoding::CompatibilityError) - end + it "raises an Encoding::CompatibilityError if the replacement encoding is incompatible" do + str = "あれ" + rep = "が".encode Encoding::EUC_JP + lambda { str[0, 1] = rep }.should raise_error(Encoding::CompatibilityError) end end diff --git a/spec/ruby/core/string/encode_spec.rb b/spec/ruby/core/string/encode_spec.rb index f582d50794..0be26011ea 100644 --- a/spec/ruby/core/string/encode_spec.rb +++ b/spec/ruby/core/string/encode_spec.rb @@ -2,158 +2,156 @@ require_relative '../../spec_helper' require_relative 'shared/encode' -with_feature :encoding do - describe "String#encode" do - before :each do - @external = Encoding.default_external - @internal = Encoding.default_internal - end +describe "String#encode" do + before :each do + @external = Encoding.default_external + @internal = Encoding.default_internal + end - after :each do - Encoding.default_external = @external - Encoding.default_internal = @internal - end + after :each do + Encoding.default_external = @external + Encoding.default_internal = @internal + end - it_behaves_like :string_encode, :encode + it_behaves_like :string_encode, :encode - describe "when passed no options" do - it "returns a copy when Encoding.default_internal is nil" do - Encoding.default_internal = nil - str = "あ" - str.encode.should_not equal(str) - end + describe "when passed no options" do + it "returns a copy when Encoding.default_internal is nil" do + Encoding.default_internal = nil + str = "あ" + str.encode.should_not equal(str) + end - it "returns a copy for a ASCII-only String when Encoding.default_internal is nil" do - Encoding.default_internal = nil - str = "abc" - str.encode.should_not equal(str) - end + it "returns a copy for a ASCII-only String when Encoding.default_internal is nil" do + Encoding.default_internal = nil + str = "abc" + str.encode.should_not equal(str) + end - it "encodes an ascii substring of a binary string to UTF-8" do - x82 = [0x82].pack('C') - str = "#{x82}foo".force_encoding("ascii-8bit")[1..-1].encode("utf-8") - str.should == "foo".force_encoding("utf-8") - str.encoding.should equal(Encoding::UTF_8) - end + it "encodes an ascii substring of a binary string to UTF-8" do + x82 = [0x82].pack('C') + str = "#{x82}foo".force_encoding("ascii-8bit")[1..-1].encode("utf-8") + str.should == "foo".force_encoding("utf-8") + str.encoding.should equal(Encoding::UTF_8) end + end - describe "when passed to encoding" do - it "returns a copy when passed the same encoding as the String" do - str = "あ" - str.encode(Encoding::UTF_8).should_not equal(str) - end + describe "when passed to encoding" do + it "returns a copy when passed the same encoding as the String" do + str = "あ" + str.encode(Encoding::UTF_8).should_not equal(str) + end - it "round trips a String" do - str = "abc def".force_encoding Encoding::US_ASCII - str.encode("utf-32be").encode("ascii").should == "abc def" - end + it "round trips a String" do + str = "abc def".force_encoding Encoding::US_ASCII + str.encode("utf-32be").encode("ascii").should == "abc def" end + end - describe "when passed options" do - it "returns a copy when Encoding.default_internal is nil" do - Encoding.default_internal = nil - str = "あ" - str.encode(invalid: :replace).should_not equal(str) - end + describe "when passed options" do + it "returns a copy when Encoding.default_internal is nil" do + Encoding.default_internal = nil + str = "あ" + str.encode(invalid: :replace).should_not equal(str) + end - it "normalizes newlines" do - "\r\nfoo".encode(universal_newline: true).should == "\nfoo" + it "normalizes newlines" do + "\r\nfoo".encode(universal_newline: true).should == "\nfoo" - "\rfoo".encode(universal_newline: true).should == "\nfoo" - end + "\rfoo".encode(universal_newline: true).should == "\nfoo" end + end - describe "when passed to, from" do - it "returns a copy in the destination encoding when both encodings are the same" do - str = "あ" - str.force_encoding("ascii-8bit") - encoded = str.encode("utf-8", "utf-8") - - encoded.should_not equal(str) - encoded.encoding.should == Encoding::UTF_8 - end + describe "when passed to, from" do + it "returns a copy in the destination encoding when both encodings are the same" do + str = "あ" + str.force_encoding("ascii-8bit") + encoded = str.encode("utf-8", "utf-8") - it "returns the transcoded string" do - str = "\x00\x00\x00\x1F" - str.encode(Encoding::UTF_8, Encoding::UTF_16BE).should == "\u0000\u001f" - end + encoded.should_not equal(str) + encoded.encoding.should == Encoding::UTF_8 end - describe "when passed to, options" do - it "returns a copy when the destination encoding is the same as the String encoding" do - str = "あ" - str.encode(Encoding::UTF_8, undef: :replace).should_not equal(str) - end + it "returns the transcoded string" do + str = "\x00\x00\x00\x1F" + str.encode(Encoding::UTF_8, Encoding::UTF_16BE).should == "\u0000\u001f" end + end - describe "when passed to, from, options" do - it "returns a copy when both encodings are the same" do - str = "あ" - str.encode("utf-8", "utf-8", invalid: :replace).should_not equal(str) - end + describe "when passed to, options" do + it "returns a copy when the destination encoding is the same as the String encoding" do + str = "あ" + str.encode(Encoding::UTF_8, undef: :replace).should_not equal(str) end end - describe "String#encode!" do - before :each do - @external = Encoding.default_external - @internal = Encoding.default_internal + describe "when passed to, from, options" do + it "returns a copy when both encodings are the same" do + str = "あ" + str.encode("utf-8", "utf-8", invalid: :replace).should_not equal(str) end + end +end - after :each do - Encoding.default_external = @external - Encoding.default_internal = @internal - end +describe "String#encode!" do + before :each do + @external = Encoding.default_external + @internal = Encoding.default_internal + end - it_behaves_like :string_encode, :encode! + after :each do + Encoding.default_external = @external + Encoding.default_internal = @internal + end - it "raises a #{frozen_error_class} when called on a frozen String" do - lambda { "foo".freeze.encode!("euc-jp") }.should raise_error(frozen_error_class) - end + it_behaves_like :string_encode, :encode! - # http://redmine.ruby-lang.org/issues/show/1836 - it "raises a #{frozen_error_class} when called on a frozen String when it's a no-op" do - lambda { "foo".freeze.encode!("utf-8") }.should raise_error(frozen_error_class) - end + it "raises a #{frozen_error_class} when called on a frozen String" do + lambda { "foo".freeze.encode!("euc-jp") }.should raise_error(frozen_error_class) + end - describe "when passed no options" do - it "returns self when Encoding.default_internal is nil" do - Encoding.default_internal = nil - str = "あ" - str.encode!.should equal(str) - end + # http://redmine.ruby-lang.org/issues/show/1836 + it "raises a #{frozen_error_class} when called on a frozen String when it's a no-op" do + lambda { "foo".freeze.encode!("utf-8") }.should raise_error(frozen_error_class) + end + + describe "when passed no options" do + it "returns self when Encoding.default_internal is nil" do + Encoding.default_internal = nil + str = "あ" + str.encode!.should equal(str) + end - it "returns self for a ASCII-only String when Encoding.default_internal is nil" do - Encoding.default_internal = nil - str = "abc" - str.encode!.should equal(str) - end + it "returns self for a ASCII-only String when Encoding.default_internal is nil" do + Encoding.default_internal = nil + str = "abc" + str.encode!.should equal(str) end + end - describe "when passed options" do - it "returns self for ASCII-only String when Encoding.default_internal is nil" do - Encoding.default_internal = nil - str = "abc" - str.encode!(invalid: :replace).should equal(str) - end + describe "when passed options" do + it "returns self for ASCII-only String when Encoding.default_internal is nil" do + Encoding.default_internal = nil + str = "abc" + str.encode!(invalid: :replace).should equal(str) end + end - describe "when passed to encoding" do - it "returns self" do - str = "abc" - result = str.encode!(Encoding::BINARY) - result.encoding.should equal(Encoding::BINARY) - result.should equal(str) - end + describe "when passed to encoding" do + it "returns self" do + str = "abc" + result = str.encode!(Encoding::BINARY) + result.encoding.should equal(Encoding::BINARY) + result.should equal(str) end + end - describe "when passed to, from" do - it "returns self" do - str = "ああ" - result = str.encode!("euc-jp", "utf-8") - result.encoding.should equal(Encoding::EUC_JP) - result.should equal(str) - end + describe "when passed to, from" do + it "returns self" do + str = "ああ" + result = str.encode!("euc-jp", "utf-8") + result.encoding.should equal(Encoding::EUC_JP) + result.should equal(str) end end end diff --git a/spec/ruby/core/string/encoding_spec.rb b/spec/ruby/core/string/encoding_spec.rb index b2861f2264..6182e8eb50 100644 --- a/spec/ruby/core/string/encoding_spec.rb +++ b/spec/ruby/core/string/encoding_spec.rb @@ -2,188 +2,186 @@ require_relative '../../spec_helper' require_relative 'fixtures/iso-8859-9-encoding' -with_feature :encoding do - describe "String#encoding" do - it "returns an Encoding object" do - String.new.encoding.should be_an_instance_of(Encoding) - end - - it "is equal to the source encoding by default" do - s = StringSpecs::ISO88599Encoding.new - s.cedilla.encoding.should == s.source_encoding - end - - it "returns the given encoding if #force_encoding has been called" do - "a".force_encoding(Encoding::SHIFT_JIS).encoding.should == Encoding::SHIFT_JIS - end - - it "returns the given encoding if #encode!has been called" do - "a".encode!(Encoding::SHIFT_JIS).encoding.should == Encoding::SHIFT_JIS - end - end - - describe "String#encoding for US-ASCII Strings" do - it "returns US-ASCII if self is US-ASCII" do - "a".encoding.should == Encoding::US_ASCII - end - - it "returns US-ASCII if self is US-ASCII only, despite the default internal encoding being different" do - default_internal = Encoding.default_internal - Encoding.default_internal = Encoding::UTF_8 - "a".encoding.should == Encoding::US_ASCII - Encoding.default_internal = default_internal - end - - it "returns US-ASCII if self is US-ASCII only, despite the default external encoding being different" do - default_external = Encoding.default_external - Encoding.default_external = Encoding::UTF_8 - "a".encoding.should == Encoding::US_ASCII - Encoding.default_external = default_external - end - - it "returns US-ASCII if self is US-ASCII only, despite the default internal and external encodings being different" do - default_internal = Encoding.default_internal - default_external = Encoding.default_external - Encoding.default_internal = Encoding::UTF_8 - Encoding.default_external = Encoding::UTF_8 - "a".encoding.should == Encoding::US_ASCII - Encoding.default_external = default_external - Encoding.default_internal = default_internal - end - - it "returns US-ASCII if self is US-ASCII only, despite the default encodings being different" do - default_internal = Encoding.default_internal - default_external = Encoding.default_external - Encoding.default_internal = Encoding::UTF_8 - Encoding.default_external = Encoding::UTF_8 - "a".encoding.should == Encoding::US_ASCII - Encoding.default_external = default_external - Encoding.default_internal = default_internal - end - - end - - describe "String#encoding for Strings with \\u escapes" do - it "returns UTF-8" do - "\u{4040}".encoding.should == Encoding::UTF_8 - end - - it "returns US-ASCII if self is US-ASCII only" do - s = "\u{40}" - s.ascii_only?.should be_true - s.encoding.should == Encoding::US_ASCII - end - - it "returns UTF-8 if self isn't US-ASCII only" do - s = "\u{4076}\u{619}" - s.ascii_only?.should be_false - s.encoding.should == Encoding::UTF_8 - end - - it "is not affected by the default internal encoding" do - default_internal = Encoding.default_internal - Encoding.default_internal = Encoding::ISO_8859_15 - "\u{5050}".encoding.should == Encoding::UTF_8 - "\u{50}".encoding.should == Encoding::US_ASCII - Encoding.default_internal = default_internal - end - - it "is not affected by the default external encoding" do - default_external = Encoding.default_external - Encoding.default_external = Encoding::SHIFT_JIS - "\u{50}".encoding.should == Encoding::US_ASCII - "\u{5050}".encoding.should == Encoding::UTF_8 - Encoding.default_external = default_external - end - - it "is not affected by both the default internal and external encoding being set at the same time" do - default_internal = Encoding.default_internal - default_external = Encoding.default_external - Encoding.default_internal = Encoding::EUC_JP - Encoding.default_external = Encoding::SHIFT_JIS - "\u{50}".encoding.should == Encoding::US_ASCII - "\u{507}".encoding.should == Encoding::UTF_8 - Encoding.default_external = default_external - Encoding.default_internal = default_internal - end - - it "returns the given encoding if #force_encoding has been called" do - "\u{20}".force_encoding(Encoding::SHIFT_JIS).encoding.should == Encoding::SHIFT_JIS - "\u{2020}".force_encoding(Encoding::SHIFT_JIS).encoding.should == Encoding::SHIFT_JIS - end - - it "returns the given encoding if #encode!has been called" do - "\u{20}".encode!(Encoding::SHIFT_JIS).encoding.should == Encoding::SHIFT_JIS - "\u{2020}".encode!(Encoding::SHIFT_JIS).encoding.should == Encoding::SHIFT_JIS - end - end - - describe "String#encoding for Strings with \\x escapes" do - - it "returns US-ASCII if self is US-ASCII only" do - s = "\x61" - s.ascii_only?.should be_true - s.encoding.should == Encoding::US_ASCII - end - - it "returns ASCII-8BIT when an escape creates a byte with the 8th bit set if the source encoding is US-ASCII" do - __ENCODING__.should == Encoding::US_ASCII - str = " " - str.encoding.should == Encoding::US_ASCII - str += [0xDF].pack('C') - str.ascii_only?.should be_false - str.encoding.should == Encoding::ASCII_8BIT - end - - # TODO: Deal with case when the byte in question isn't valid in the source - # encoding? - it "returns the source encoding when an escape creates a byte with the 8th bit set if the source encoding isn't US-ASCII" do - fixture = StringSpecs::ISO88599Encoding.new - fixture.source_encoding.should == Encoding::ISO8859_9 - fixture.x_escape.ascii_only?.should be_false - fixture.x_escape.encoding.should == Encoding::ISO8859_9 - end - - it "is not affected by the default internal encoding" do - default_internal = Encoding.default_internal - Encoding.default_internal = Encoding::ISO_8859_15 - "\x50".encoding.should == Encoding::US_ASCII - "\x50".encoding.should == Encoding::US_ASCII - Encoding.default_internal = default_internal - end - - it "is not affected by the default external encoding" do - default_external = Encoding.default_external - Encoding.default_external = Encoding::SHIFT_JIS - "\x50".encoding.should == Encoding::US_ASCII - [0xD4].pack('C').encoding.should == Encoding::ASCII_8BIT - Encoding.default_external = default_external - end - - it "is not affected by both the default internal and external encoding being set at the same time" do - default_internal = Encoding.default_internal - default_external = Encoding.default_external - Encoding.default_internal = Encoding::EUC_JP - Encoding.default_external = Encoding::SHIFT_JIS - x50 = "\x50" - x50.encoding.should == Encoding::US_ASCII - [0xD4].pack('C').encoding.should == Encoding::ASCII_8BIT - Encoding.default_external = default_external - Encoding.default_internal = default_internal - end - - it "returns the given encoding if #force_encoding has been called" do - x50 = "\x50" - x50.force_encoding(Encoding::SHIFT_JIS).encoding.should == Encoding::SHIFT_JIS - xD4 = [212].pack('C') - xD4.force_encoding(Encoding::ISO_8859_9).encoding.should == Encoding::ISO_8859_9 - end - - it "returns the given encoding if #encode!has been called" do - x50 = "\x50" - x50.encode!(Encoding::SHIFT_JIS).encoding.should == Encoding::SHIFT_JIS - x00 = "x\00" - x00.encode!(Encoding::UTF_8).encoding.should == Encoding::UTF_8 - end +describe "String#encoding" do + it "returns an Encoding object" do + String.new.encoding.should be_an_instance_of(Encoding) + end + + it "is equal to the source encoding by default" do + s = StringSpecs::ISO88599Encoding.new + s.cedilla.encoding.should == s.source_encoding + end + + it "returns the given encoding if #force_encoding has been called" do + "a".force_encoding(Encoding::SHIFT_JIS).encoding.should == Encoding::SHIFT_JIS + end + + it "returns the given encoding if #encode!has been called" do + "a".encode!(Encoding::SHIFT_JIS).encoding.should == Encoding::SHIFT_JIS + end +end + +describe "String#encoding for US-ASCII Strings" do + it "returns US-ASCII if self is US-ASCII" do + "a".encoding.should == Encoding::US_ASCII + end + + it "returns US-ASCII if self is US-ASCII only, despite the default internal encoding being different" do + default_internal = Encoding.default_internal + Encoding.default_internal = Encoding::UTF_8 + "a".encoding.should == Encoding::US_ASCII + Encoding.default_internal = default_internal + end + + it "returns US-ASCII if self is US-ASCII only, despite the default external encoding being different" do + default_external = Encoding.default_external + Encoding.default_external = Encoding::UTF_8 + "a".encoding.should == Encoding::US_ASCII + Encoding.default_external = default_external + end + + it "returns US-ASCII if self is US-ASCII only, despite the default internal and external encodings being different" do + default_internal = Encoding.default_internal + default_external = Encoding.default_external + Encoding.default_internal = Encoding::UTF_8 + Encoding.default_external = Encoding::UTF_8 + "a".encoding.should == Encoding::US_ASCII + Encoding.default_external = default_external + Encoding.default_internal = default_internal + end + + it "returns US-ASCII if self is US-ASCII only, despite the default encodings being different" do + default_internal = Encoding.default_internal + default_external = Encoding.default_external + Encoding.default_internal = Encoding::UTF_8 + Encoding.default_external = Encoding::UTF_8 + "a".encoding.should == Encoding::US_ASCII + Encoding.default_external = default_external + Encoding.default_internal = default_internal + end + +end + +describe "String#encoding for Strings with \\u escapes" do + it "returns UTF-8" do + "\u{4040}".encoding.should == Encoding::UTF_8 + end + + it "returns US-ASCII if self is US-ASCII only" do + s = "\u{40}" + s.ascii_only?.should be_true + s.encoding.should == Encoding::US_ASCII + end + + it "returns UTF-8 if self isn't US-ASCII only" do + s = "\u{4076}\u{619}" + s.ascii_only?.should be_false + s.encoding.should == Encoding::UTF_8 + end + + it "is not affected by the default internal encoding" do + default_internal = Encoding.default_internal + Encoding.default_internal = Encoding::ISO_8859_15 + "\u{5050}".encoding.should == Encoding::UTF_8 + "\u{50}".encoding.should == Encoding::US_ASCII + Encoding.default_internal = default_internal + end + + it "is not affected by the default external encoding" do + default_external = Encoding.default_external + Encoding.default_external = Encoding::SHIFT_JIS + "\u{50}".encoding.should == Encoding::US_ASCII + "\u{5050}".encoding.should == Encoding::UTF_8 + Encoding.default_external = default_external + end + + it "is not affected by both the default internal and external encoding being set at the same time" do + default_internal = Encoding.default_internal + default_external = Encoding.default_external + Encoding.default_internal = Encoding::EUC_JP + Encoding.default_external = Encoding::SHIFT_JIS + "\u{50}".encoding.should == Encoding::US_ASCII + "\u{507}".encoding.should == Encoding::UTF_8 + Encoding.default_external = default_external + Encoding.default_internal = default_internal + end + + it "returns the given encoding if #force_encoding has been called" do + "\u{20}".force_encoding(Encoding::SHIFT_JIS).encoding.should == Encoding::SHIFT_JIS + "\u{2020}".force_encoding(Encoding::SHIFT_JIS).encoding.should == Encoding::SHIFT_JIS + end + + it "returns the given encoding if #encode!has been called" do + "\u{20}".encode!(Encoding::SHIFT_JIS).encoding.should == Encoding::SHIFT_JIS + "\u{2020}".encode!(Encoding::SHIFT_JIS).encoding.should == Encoding::SHIFT_JIS + end +end + +describe "String#encoding for Strings with \\x escapes" do + + it "returns US-ASCII if self is US-ASCII only" do + s = "\x61" + s.ascii_only?.should be_true + s.encoding.should == Encoding::US_ASCII + end + + it "returns ASCII-8BIT when an escape creates a byte with the 8th bit set if the source encoding is US-ASCII" do + __ENCODING__.should == Encoding::US_ASCII + str = " " + str.encoding.should == Encoding::US_ASCII + str += [0xDF].pack('C') + str.ascii_only?.should be_false + str.encoding.should == Encoding::ASCII_8BIT + end + + # TODO: Deal with case when the byte in question isn't valid in the source + # encoding? + it "returns the source encoding when an escape creates a byte with the 8th bit set if the source encoding isn't US-ASCII" do + fixture = StringSpecs::ISO88599Encoding.new + fixture.source_encoding.should == Encoding::ISO8859_9 + fixture.x_escape.ascii_only?.should be_false + fixture.x_escape.encoding.should == Encoding::ISO8859_9 + end + + it "is not affected by the default internal encoding" do + default_internal = Encoding.default_internal + Encoding.default_internal = Encoding::ISO_8859_15 + "\x50".encoding.should == Encoding::US_ASCII + "\x50".encoding.should == Encoding::US_ASCII + Encoding.default_internal = default_internal + end + + it "is not affected by the default external encoding" do + default_external = Encoding.default_external + Encoding.default_external = Encoding::SHIFT_JIS + "\x50".encoding.should == Encoding::US_ASCII + [0xD4].pack('C').encoding.should == Encoding::ASCII_8BIT + Encoding.default_external = default_external + end + + it "is not affected by both the default internal and external encoding being set at the same time" do + default_internal = Encoding.default_internal + default_external = Encoding.default_external + Encoding.default_internal = Encoding::EUC_JP + Encoding.default_external = Encoding::SHIFT_JIS + x50 = "\x50" + x50.encoding.should == Encoding::US_ASCII + [0xD4].pack('C').encoding.should == Encoding::ASCII_8BIT + Encoding.default_external = default_external + Encoding.default_internal = default_internal + end + + it "returns the given encoding if #force_encoding has been called" do + x50 = "\x50" + x50.force_encoding(Encoding::SHIFT_JIS).encoding.should == Encoding::SHIFT_JIS + xD4 = [212].pack('C') + xD4.force_encoding(Encoding::ISO_8859_9).encoding.should == Encoding::ISO_8859_9 + end + + it "returns the given encoding if #encode!has been called" do + x50 = "\x50" + x50.encode!(Encoding::SHIFT_JIS).encoding.should == Encoding::SHIFT_JIS + x00 = "x\00" + x00.encode!(Encoding::UTF_8).encoding.should == Encoding::UTF_8 end end diff --git a/spec/ruby/core/string/force_encoding_spec.rb b/spec/ruby/core/string/force_encoding_spec.rb index 06e04b8d95..83641a37b4 100644 --- a/spec/ruby/core/string/force_encoding_spec.rb +++ b/spec/ruby/core/string/force_encoding_spec.rb @@ -1,73 +1,71 @@ require_relative '../../spec_helper' -with_feature :encoding do - describe "String#force_encoding" do - it "accepts a String as the name of an Encoding" do - "abc".force_encoding('shift_jis').encoding.should == Encoding::Shift_JIS - end - - describe "with a special encoding name" do - before :each do - @original_encoding = Encoding.default_internal - end +describe "String#force_encoding" do + it "accepts a String as the name of an Encoding" do + "abc".force_encoding('shift_jis').encoding.should == Encoding::Shift_JIS + end - after :each do - Encoding.default_internal = @original_encoding - end + describe "with a special encoding name" do + before :each do + @original_encoding = Encoding.default_internal + end - it "accepts valid special encoding names" do - Encoding.default_internal = "US-ASCII" - "abc".force_encoding("internal").encoding.should == Encoding::US_ASCII - end + after :each do + Encoding.default_internal = @original_encoding + end - it "defaults to ASCII-8BIT if special encoding name is not set" do - Encoding.default_internal = nil - "abc".force_encoding("internal").encoding.should == Encoding::ASCII_8BIT - end + it "accepts valid special encoding names" do + Encoding.default_internal = "US-ASCII" + "abc".force_encoding("internal").encoding.should == Encoding::US_ASCII end - it "accepts an Encoding instance" do - "abc".force_encoding(Encoding::SHIFT_JIS).encoding.should == Encoding::Shift_JIS + it "defaults to ASCII-8BIT if special encoding name is not set" do + Encoding.default_internal = nil + "abc".force_encoding("internal").encoding.should == Encoding::ASCII_8BIT end + end - it "calls #to_str to convert an object to an encoding name" do - obj = mock("force_encoding") - obj.should_receive(:to_str).and_return("utf-8") + it "accepts an Encoding instance" do + "abc".force_encoding(Encoding::SHIFT_JIS).encoding.should == Encoding::Shift_JIS + end - "abc".force_encoding(obj).encoding.should == Encoding::UTF_8 - end + it "calls #to_str to convert an object to an encoding name" do + obj = mock("force_encoding") + obj.should_receive(:to_str).and_return("utf-8") - it "raises a TypeError if #to_str does not return a String" do - obj = mock("force_encoding") - obj.should_receive(:to_str).and_return(1) + "abc".force_encoding(obj).encoding.should == Encoding::UTF_8 + end - lambda { "abc".force_encoding(obj) }.should raise_error(TypeError) - end + it "raises a TypeError if #to_str does not return a String" do + obj = mock("force_encoding") + obj.should_receive(:to_str).and_return(1) - it "raises a TypeError if passed nil" do - lambda { "abc".force_encoding(nil) }.should raise_error(TypeError) - end + lambda { "abc".force_encoding(obj) }.should raise_error(TypeError) + end - it "returns self" do - str = "abc" - str.force_encoding('utf-8').should equal(str) - end + it "raises a TypeError if passed nil" do + lambda { "abc".force_encoding(nil) }.should raise_error(TypeError) + end - it "sets the encoding even if the String contents are invalid in that encoding" do - str = "\u{9765}" - str.force_encoding('euc-jp') - str.encoding.should == Encoding::EUC_JP - str.valid_encoding?.should be_false - end + it "returns self" do + str = "abc" + str.force_encoding('utf-8').should equal(str) + end - it "does not transcode self" do - str = "\u{8612}" - str.dup.force_encoding('utf-16le').should_not == str.encode('utf-16le') - end + it "sets the encoding even if the String contents are invalid in that encoding" do + str = "\u{9765}" + str.force_encoding('euc-jp') + str.encoding.should == Encoding::EUC_JP + str.valid_encoding?.should be_false + end - it "raises a #{frozen_error_class} if self is frozen" do - str = "abcd".freeze - lambda { str.force_encoding(str.encoding) }.should raise_error(frozen_error_class) - end + it "does not transcode self" do + str = "\u{8612}" + str.dup.force_encoding('utf-16le').should_not == str.encode('utf-16le') + end + + it "raises a #{frozen_error_class} if self is frozen" do + str = "abcd".freeze + lambda { str.force_encoding(str.encoding) }.should raise_error(frozen_error_class) end end diff --git a/spec/ruby/core/string/index_spec.rb b/spec/ruby/core/string/index_spec.rb index 3ed27034e1..fb5f4e75e7 100644 --- a/spec/ruby/core/string/index_spec.rb +++ b/spec/ruby/core/string/index_spec.rb @@ -140,25 +140,23 @@ describe "String#index with String" do "I’ve got a multibyte character.\n".index("\n\n").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 of a multibyte character" do + "ありがとう".index("が").should == 2 + end - it "returns the character index after offset" do - "われわれ".index("わ", 1).should == 2 - end + it "returns the character index after offset" do + "われわれ".index("わ", 1).should == 2 + end - it "returns the character index after a partial first match" do - "