github
/
ruby
зеркало из https://github.com/github/ruby.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность

Update to ruby/spec@7de852d

This commit is contained in:
Benoit Daloze 2019-04-28 23:20:11 +02:00
Родитель 994833085a
Коммит 79671ec57e
135 изменённых файлов: 4415 добавлений и 4885 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

30
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

30
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

8
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

16
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

20
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

60
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

14
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

708
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
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
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 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 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
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 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 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 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
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 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 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
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 US-ASCII" do
Encoding.compatible?(@str, "def".encode("us-ascii")).should be_nil
end
it "returns nil when the second String is ASCII-8BIT and ASCII only" do
Encoding.compatible?(@str, "\x7f").should be_nil
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 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
describe "when the first's Encoding is invalid" do
before :each do
@str = "\xff".force_encoding Encoding::UTF_8
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 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 ASCII-8BIT but not ASCII only" do
Encoding.compatible?(@str, "\xff").should be_nil
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 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 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
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 = "abc".force_encoding Encoding::US_ASCII
@str = "".force_encoding("utf-8")
end
it "returns US-ASCII when the second's is US-ASCII" do
Encoding.compatible?(@str, "def".encode("us-ascii")).should == Encoding::US_ASCII
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 US-ASCII if the second String is ASCII-8BIT and ASCII only" do
Encoding.compatible?(@str, "\x7f").should == 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 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 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
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 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 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 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
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 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 encoding is ASCII compatible but neither String's encoding is ASCII only" do
Encoding.compatible?("\xff", "\u3042".encode("utf-8")).should be_nil
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 first's Encoding is not ASCII compatible" do
before :each do
@str = "abc".force_encoding Encoding::UTF_7
@str = "".force_encoding Encoding::UTF_7
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 when the second String is ASCII-8BIT and ASCII only" do
Encoding.compatible?(@str, "\x7f").should be_nil
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 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
describe "when the first's Encoding is invalid" do
before :each do
@str = "\xff".force_encoding Encoding::UTF_8
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 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 ASCII-8BIT but not ASCII only" do
Encoding.compatible?(@str, "\xff").should be_nil
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 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 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
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 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'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 first's Encoding is not ASCII compatible" do
before :each do
@str = "".force_encoding Encoding::UTF_7
end
it "returns the second string's encoding" do
Encoding.compatible?(@str, "def".encode("us-ascii")).should == Encoding::US_ASCII
end
end
end
describe "when the second String is empty" do
before :each do
@str = "abc".force_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/)
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
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 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
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 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 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 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
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
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
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? 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
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
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
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
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
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 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
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 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 Symbol, Object" do
Encoding.compatible?(:sym, Object.new).should be_nil
it "returns the first Encoding" do
Encoding.compatible?(@str, "").should == Encoding::UTF_7
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
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
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 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
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 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 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 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
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
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
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? 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
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
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
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
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
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 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
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 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 Symbol, Object" do
Encoding.compatible?(:sym, Object.new).should be_nil
end
end

58
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

252
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
it "has a Fixnum value" do
Encoding::Converter::INVALID_MASK.should be_an_instance_of(Fixnum)
end
describe "Encoding::Converter::INVALID_MASK" do
it "exists" do
Encoding::Converter.should have_constant(:INVALID_MASK)
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
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
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
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
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
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
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
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
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
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
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
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::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
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
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
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
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
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
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
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
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
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
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
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
it "has a Fixnum value" do
Encoding::Converter::XML_ATTR_QUOTE_DECORATOR.should be_an_instance_of(Fixnum)
end
end

70
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

36
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

14
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

54
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

154
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

188
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
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 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 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

328
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
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 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 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 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 "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 "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 "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"
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, 1)
dest.should == "aab"
@ec.primitive_convert("b",dest, nil, 2)
dest.should == "aabbb"
end
@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 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 "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 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 "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 "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 "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 "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 "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 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 "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
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
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 "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
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
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 "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
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
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 :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 "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)
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
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 "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
it "clears the source buffer when returning :finished" do
s = "glark".force_encoding('utf-8')
@ec.primitive_convert(s, "").should == :finished
s.should == ""
end
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 "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
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
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)
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
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 = ""
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 == :invalid_byte_sequence
s.should == "bcd"
@ec.primitive_errinfo[4].should == "a"
@ec.primitive_convert(s, dest).should == :finished
s.should == ""
@ec.primitive_convert(s, dest).should == :finished
s.should == ""
dest.should == "abcd"
end
dest.should == "abcd"
end
end

110
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

74
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

132
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
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
ec = Encoding::Converter.new("utf-8", "sjis")
ec.replacement.should == "?"
ec.replacement.encoding.should == Encoding::US_ASCII
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 "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 "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 "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
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
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 "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 "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
status.should == :finished
dest.should == "!!123"
end
end

50
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

14
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

112
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
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 the default external encoding" do
Encoding.default_external = Encoding::SHIFT_JIS
Encoding.default_external.should == Encoding::SHIFT_JIS
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 "returns an Encoding object" do
Encoding.default_external.should be_an_instance_of(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
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 "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 an ArgumentError if the argument is nil" do
lambda { Encoding.default_external = nil }.should raise_error(ArgumentError)
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
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
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 "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 an ArgumentError if the argument is nil" do
lambda { Encoding.default_external = nil }.should raise_error(ArgumentError)
end
end

130
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
after :each do
Encoding.default_internal = @original_encoding
end
it "is nil by default" do
Encoding.default_internal.should be_nil
end
it "sets the default internal encoding" do
Encoding.default_internal = Encoding::SHIFT_JIS
Encoding.default_internal.should == Encoding::SHIFT_JIS
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 "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 "returns nil if no default internal encoding is set" do
Encoding.default_internal = nil
Encoding.default_internal.should be_nil
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')
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
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 "returns the default internal encoding" do
Encoding.default_internal = Encoding::ASCII_8BIT
Encoding.default_internal.should == Encoding::ASCII_8BIT
end
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 "sets the default internal encoding" do
Encoding.default_internal = Encoding::SHIFT_JIS
Encoding.default_internal.should == Encoding::SHIFT_JIS
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 "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')
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
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
end

20
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

154
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
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 "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
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
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
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
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
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"
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
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 "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
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
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
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
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
end

24
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 #<Encoding:name> for a non-dummy encoding named 'name'" do
Encoding.list.to_a.reject {|e| e.dummy? }.each do |enc|
enc.inspect.should =~ /#<Encoding:#{enc.name}>/
end
it "returns #<Encoding:name> for a non-dummy encoding named 'name'" do
Encoding.list.to_a.reject {|e| e.dummy? }.each do |enc|
enc.inspect.should =~ /#<Encoding:#{enc.name}>/
end
end
it "returns #<Encoding:name (dummy)> for a dummy encoding named 'name'" do
Encoding.list.to_a.select {|e| e.dummy? }.each do |enc|
enc.inspect.should =~ /#<Encoding:#{enc.name} \(dummy\)>/
end
it "returns #<Encoding:name (dummy)> for a dummy encoding named 'name'" do
Encoding.list.to_a.select {|e| e.dummy? }.each do |enc|
enc.inspect.should =~ /#<Encoding:#{enc.name} \(dummy\)>/
end
end
end

26
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

26
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

42
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

42
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
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
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

42
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

44
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

52
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

76
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
it "returns each encoding only once" do
orig = Encoding.list.map {|e| e.name}
orig.should == orig.uniq
end
it "includes the default external encoding" do
Encoding.list.include?(Encoding.default_external).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 all aliased encodings" do
Encoding.aliases.values.each do |enc_alias|
Encoding.list.include?(Encoding.find(enc_alias)).should be_true
end
end
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"
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
it "returns each encoding only once" do
orig = Encoding.list.map {|e| e.name}
orig.should == orig.uniq
end
it "includes the default external encoding" do
Encoding.list.include?(Encoding.default_external).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 all aliased encodings" do
Encoding.aliases.values.each do |enc_alias|
Encoding.list.include?(Encoding.find(enc_alias)).should be_true
end
end
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

68
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

30
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

6
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

56
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
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
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}
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
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

74
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

6
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

20
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

20
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

38
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

44
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

46
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

52
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

54
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"
@locale_encoding = Encoding.find "locale"
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
ENV.send(@method) do |key, value|
key.encoding.should equal(@locale_encoding)
value.encoding.should equal(@locale_encoding)
end
end
after :each do
Encoding.default_external = @external
Encoding.default_internal = @internal
end
it "transcodes from the locale encoding to Encoding.default_internal if set" do
Encoding.default_internal = internal = Encoding::IBM437
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
end
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

48
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
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
Encoding.default_external = Encoding::ASCII_8BIT
end
after :each do
Encoding.default_external = @external
Encoding.default_internal = @internal
ENV.replace @orig
end
after :each do
Encoding.default_external = @external
Encoding.default_internal = @internal
ENV.replace @orig
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
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.find("locale"))
pair.last.encoding.should equal(Encoding.find("locale"))
end
it "transcodes from the locale encoding to Encoding.default_internal if set" do
Encoding.default_internal = Encoding::IBM437
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
pair = ENV.shift
pair.first.encoding.should equal(Encoding::IBM437)
pair.last.encoding.should equal(Encoding::IBM437)
end
end

60
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

87
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
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
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
wr.close
Process.waitpid pid
rd.read.should == "executed"
rd.close
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
RUBY
ruby_exe(code).should == "ensure executed\n"
end
end

76
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
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
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 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 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 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 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 "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
: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

20
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

56
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)
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
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

8
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

19
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

10
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

30
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

56
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

340
spec/ruby/core/io/external_encoding_spec.rb
Просмотреть файл

@ -1,51 +1,124 @@
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
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
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 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
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
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"
@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
@ -58,161 +131,86 @@ with_feature :encoding do
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"
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, "#{@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
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
end
describe "IO#external_encoding" do
before :each do
@external = Encoding.default_external
@internal = Encoding.default_internal
@name = tmp("io_external_encoding")
touch(@name)
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
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
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+"
end
describe "with 'w' mode" do
it_behaves_like :io_external_encoding_write, nil, "w"
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
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 '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+"
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+"
end
describe "with 'w' mode" do
it_behaves_like :io_external_encoding_write, nil, "w"
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
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 '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
end

4
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

2
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 = $$

8
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

30
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 "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
# 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
end
it "raises a TypeError when passed an IO" do

220
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
describe :io_internal_encoding, shared: true do
describe "when Encoding.default_internal is not set" do
before :each do
Encoding.default_internal = nil
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
it "returns nil if the internal encoding is not set" do
@io = new_io @name, @object
@io.internal_encoding.should be_nil
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 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 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 "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 "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
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
@name = tmp("io_internal_encoding")
touch(@name)
Encoding.default_external = Encoding::IBM866
Encoding.default_internal = Encoding::IBM866
end
after :each do
@io.close if @io
rm_r @name
Encoding.default_external = @external
Encoding.default_internal = @internal
it "returns nil" do
@io = new_io @name, @object
@io.internal_encoding.should be_nil
end
describe "with 'r' mode" do
it_behaves_like :io_internal_encoding, nil, "r"
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
describe "with 'r+' mode" do
it_behaves_like :io_internal_encoding, nil, "r+"
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 'w' mode" do
it_behaves_like :io_internal_encoding, nil, "w"
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 'w+' mode" do
it_behaves_like :io_internal_encoding, nil, "w+"
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 'a' mode" do
it_behaves_like :io_internal_encoding, nil, "a"
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 'a+' mode" do
it_behaves_like :io_internal_encoding, nil, "a+"
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
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

28
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

38
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|
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"
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 == "\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"
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"
end
File.binread(@name).should == "\n"
end
end
end

220
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"
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 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
describe :io_read_internal_encoding, shared: true do
it "returns a transcoded String" do
@io.read.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)
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 "returns a String in ASCII-8BIT when passed a size" do
@io.read(4).encoding.should equal(Encoding::ASCII_8BIT)
end
it "does not change the buffer's encoding when passed a limit" do
it "sets the buffer's encoding to the internal encoding" 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(nil, buf)
buf.encoding.should equal(Encoding::UTF_8)
end
end
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 "returns a String in ASCII-8BIT when passed a size" do
@io.read(4).encoding.should equal(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 "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
@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
after :each do
@io.close if @io
rm_r @name
end
it "sets the String encoding to Encoding.default_external" do
@io.read.encoding.should equal(Encoding.default_external)
end
describe "with internal encoding" do
after :each do
@io.close if @io
end
describe "with internal encoding" do
after :each do
@io.close if @io
describe "not specified" do
before :each do
@io = IOSpecs.io_fixture "read_euc_jp.txt", "r: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
it "does not transcode the String" do
@io.read.should == ("ありがとう\n").encode(Encoding::EUC_JP)
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
it "sets the String encoding to the external encoding" do
@io.read.encoding.should equal(Encoding::EUC_JP)
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_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 open mode" do
before :each do
@io = IOSpecs.io_fixture "read_euc_jp.txt", "r:euc-jp:utf-8"
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 mode: option" do
before :each do
@io = IOSpecs.io_fixture "read_euc_jp.txt", mode: "r:euc-jp:utf-8"
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
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
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
end
end

6
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

17
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"

356
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
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
@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
Encoding.default_external = Encoding::IBM437
Encoding.default_internal = Encoding::IBM866
@io.set_encoding nil, nil
@io.external_encoding.should == Encoding::IBM437
@io.internal_encoding.should == Encoding::IBM866
end
@io.external_encoding.should be_nil
@io.internal_encoding.should be_nil
end
describe "IO#set_encoding when passed nil, nil" do
before :each do
@external = Encoding.default_external
@internal = Encoding.default_internal
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::UTF_8
Encoding.default_internal = nil
Encoding.default_external = Encoding::IBM437
Encoding.default_internal = Encoding::IBM866
@name = tmp('io_set_encoding.txt')
touch(@name)
end
after :each do
Encoding.default_external = @external
Encoding.default_internal = @internal
@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"
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
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
@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
Encoding.default_external = Encoding::IBM437
@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)
@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 '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
@io.external_encoding.should be_nil
@io.internal_encoding.should be_nil
end
describe "IO#set_encoding" do
before :each do
@name = tmp('io_set_encoding.txt')
touch(@name)
@io = new_io @name
end
it "sets the encodings to the current Encoding defaults" do
@io = new_io @name, @object
after :each do
@io.close unless @io.closed?
rm_r @name
end
Encoding.default_external = Encoding::IBM437
Encoding.default_internal = Encoding::IBM866
it "returns self" do
@io.set_encoding(Encoding::UTF_8).should equal(@io)
end
@io.set_encoding nil, nil
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 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 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 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 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
@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
Encoding.default_external = Encoding::UTF_8
Encoding.default_internal = nil
@name = tmp('io_set_encoding.txt')
touch(@name)
end
after :each do
Encoding.default_external = @external
Encoding.default_internal = @internal
@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"
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
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
@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
Encoding.default_external = Encoding::IBM437
@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)
@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 '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
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
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 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 "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 "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 "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
end

6
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/)

68
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

36
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

36
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

46
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

56
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 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 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 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 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

16
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

16
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

89
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
ruby_exe(code).should == "finalized\n"
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
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
wr.close
begin
rd.read.should == "finalized"
ensure
rd.close
Process.wait pid
end
end
ruby_exe(code).should == "finalized\n"
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
it "allows multiple finalizers with different 'callables' to be defined" do
code = <<-RUBY
obj = Object.new
pid = Kernel::fork do
rd1.close
rd2.close
obj = mock("ObjectSpace.define_finalizer multiple")
ObjectSpace.define_finalizer(obj, Proc.new { STDOUT.write "finalized1\n" })
ObjectSpace.define_finalizer(obj, Proc.new { STDOUT.write "finalized2\n" })
ObjectSpace.define_finalizer(obj, Proc.new { wr1.write "finalized1"; wr1.close })
ObjectSpace.define_finalizer(obj, Proc.new { wr2.write "finalized2"; wr2.close })
exit 0
RUBY
exit 0
end
wr1.close
wr2.close
rd1.read.should == "finalized1"
rd2.read.should == "finalized2"
rd1.close
rd2.close
Process.wait pid
end
ruby_exe(code).lines.sort.should == ["finalized1\n", "finalized2\n"]
end
end

25
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

20
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

3
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

37
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

55
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

4
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

28
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 "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 "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

152
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?)
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
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
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 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 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 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 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 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
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 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 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 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 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 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

30
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

28
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
end
it "is unaffected by #force_encoding" do
@utf8.force_encoding('ASCII').bytes.to_a.should == @utf8.bytes.to_a
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
end

48
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

14
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

42
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

100
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
after :each do
$/ = @before_separator
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 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
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 "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
describe "String#chomp!" do
before :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 "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 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

40
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

64
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
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 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 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 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 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 "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 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
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

58
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

20
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

6
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

8
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

Некоторые файлы не были показаны из-за слишком большого количества измененных файлов Показать больше