1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
# -*- encoding: utf-8 -*-
require_relative '../../spec_helper'
require_relative 'fixtures/classes'
describe "String#rjust with length, padding" do
it "returns a new string of specified length with self right justified and padded with padstr" do
"hello".rjust(20, '1234').should == "123412341234123hello"
"".rjust(1, "abcd").should == "a"
"".rjust(2, "abcd").should == "ab"
"".rjust(3, "abcd").should == "abc"
"".rjust(4, "abcd").should == "abcd"
"".rjust(6, "abcd").should == "abcdab"
"OK".rjust(3, "abcd").should == "aOK"
"OK".rjust(4, "abcd").should == "abOK"
"OK".rjust(6, "abcd").should == "abcdOK"
"OK".rjust(8, "abcd").should == "abcdabOK"
end
it "pads with whitespace if no padstr is given" do
"hello".rjust(20).should == " hello"
end
it "returns self if it's longer than or as long as the specified length" do
"".rjust(0).should == ""
"".rjust(-1).should == ""
"hello".rjust(4).should == "hello"
"hello".rjust(-1).should == "hello"
"this".rjust(3).should == "this"
"radiology".rjust(8, '-').should == "radiology"
end
ruby_version_is ''...'2.7' do
it "taints result when self or padstr is tainted" do
"x".taint.rjust(4).should.tainted?
"x".taint.rjust(0).should.tainted?
"".taint.rjust(0).should.tainted?
"x".taint.rjust(4, "*").should.tainted?
"x".rjust(4, "*".taint).should.tainted?
end
end
it "tries to convert length to an integer using to_int" do
"^".rjust(3.8, "^_").should == "^_^"
obj = mock('3')
obj.should_receive(:to_int).and_return(3)
"o".rjust(obj, "o_").should == "o_o"
end
it "raises a TypeError when length can't be converted to an integer" do
-> { "hello".rjust("x") }.should raise_error(TypeError)
-> { "hello".rjust("x", "y") }.should raise_error(TypeError)
-> { "hello".rjust([]) }.should raise_error(TypeError)
-> { "hello".rjust(mock('x')) }.should raise_error(TypeError)
end
it "tries to convert padstr to a string using to_str" do
padstr = mock('123')
padstr.should_receive(:to_str).and_return("123")
"hello".rjust(10, padstr).should == "12312hello"
end
it "raises a TypeError when padstr can't be converted" do
-> { "hello".rjust(20, []) }.should raise_error(TypeError)
-> { "hello".rjust(20, Object.new)}.should raise_error(TypeError)
-> { "hello".rjust(20, mock('x')) }.should raise_error(TypeError)
end
it "raises an ArgumentError when padstr is empty" do
-> { "hello".rjust(10, '') }.should raise_error(ArgumentError)
end
ruby_version_is ''...'3.0' do
it "returns subclass instances when called on subclasses" do
StringSpecs::MyString.new("").rjust(10).should be_an_instance_of(StringSpecs::MyString)
StringSpecs::MyString.new("foo").rjust(10).should be_an_instance_of(StringSpecs::MyString)
StringSpecs::MyString.new("foo").rjust(10, StringSpecs::MyString.new("x")).should be_an_instance_of(StringSpecs::MyString)
"".rjust(10, StringSpecs::MyString.new("x")).should be_an_instance_of(String)
"foo".rjust(10, StringSpecs::MyString.new("x")).should be_an_instance_of(String)
end
end
ruby_version_is '3.0' do
it "returns String instances when called on subclasses" do
StringSpecs::MyString.new("").rjust(10).should be_an_instance_of(String)
StringSpecs::MyString.new("foo").rjust(10).should be_an_instance_of(String)
StringSpecs::MyString.new("foo").rjust(10, StringSpecs::MyString.new("x")).should be_an_instance_of(String)
"".rjust(10, StringSpecs::MyString.new("x")).should be_an_instance_of(String)
"foo".rjust(10, StringSpecs::MyString.new("x")).should be_an_instance_of(String)
end
end
ruby_version_is ''...'2.7' do
it "when padding is tainted and self is untainted returns a tainted string if and only if length is longer than self" do
"hello".rjust(4, 'X'.taint).tainted?.should be_false
"hello".rjust(5, 'X'.taint).tainted?.should be_false
"hello".rjust(6, 'X'.taint).tainted?.should be_true
end
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.rjust 5
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.rjust 5, "あ"
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
-> do
"あれ".rjust 5, pat
end.should raise_error(Encoding::CompatibilityError)
end
end
end
|
