source:
EcnlProtoTool/trunk/mruby-1.3.0/test/t/array.rb@
331
Last change on this file since 331 was 331, checked in by , 6 years ago | |
---|---|
|
|
File size: 9.7 KB |
Rev | Line | |
---|---|---|
[270] | 1 | ## |
2 | # Array ISO Test | |
3 | ||
4 | assert('Array', '15.2.12') do | |
5 | assert_equal(Class, Array.class) | |
6 | end | |
7 | ||
8 | assert('Array inclueded modules', '15.2.12.3') do | |
9 | assert_true(Array.include?(Enumerable)) | |
10 | end | |
11 | ||
12 | assert('Array.[]', '15.2.12.4.1') do | |
13 | assert_equal([1, 2, 3], Array.[](1,2,3)) | |
14 | end | |
15 | ||
[331] | 16 | class SubArray < Array |
17 | end | |
18 | ||
19 | assert('SubArray.[]') do | |
20 | a = SubArray[1, 2, 3] | |
21 | assert_equal(SubArray, a.class) | |
22 | end | |
23 | ||
[270] | 24 | assert('Array#+', '15.2.12.5.1') do |
25 | assert_equal([1, 1], [1].+([1])) | |
26 | end | |
27 | ||
28 | assert('Array#*', '15.2.12.5.2') do | |
29 | assert_raise(ArgumentError) do | |
30 | # this will cause an exception due to the wrong argument | |
31 | [1].*(-1) | |
32 | end | |
33 | assert_equal([1, 1, 1], [1].*(3)) | |
34 | assert_equal([], [1].*(0)) | |
35 | end | |
36 | ||
37 | assert('Array#<<', '15.2.12.5.3') do | |
38 | assert_equal([1, 1], [1].<<(1)) | |
39 | end | |
40 | ||
41 | assert('Array#[]', '15.2.12.5.4') do | |
42 | a = Array.new | |
43 | assert_raise(ArgumentError) do | |
44 | # this will cause an exception due to the wrong arguments | |
45 | a.[]() | |
46 | end | |
47 | assert_raise(ArgumentError) do | |
48 | # this will cause an exception due to the wrong arguments | |
49 | a.[](1,2,3) | |
50 | end | |
51 | ||
52 | assert_equal(2, [1,2,3].[](1)) | |
53 | assert_equal(nil, [1,2,3].[](4)) | |
54 | assert_equal(3, [1,2,3].[](-1)) | |
55 | assert_equal(nil, [1,2,3].[](-4)) | |
56 | ||
57 | a = [ "a", "b", "c", "d", "e" ] | |
58 | assert_equal("b", a[1.1]) | |
59 | assert_equal(["b", "c"], a[1,2]) | |
60 | assert_equal(["b", "c", "d"], a[1..-2]) | |
61 | end | |
62 | ||
63 | assert('Array#[]=', '15.2.12.5.5') do | |
64 | a = Array.new | |
65 | assert_raise(ArgumentError) do | |
66 | # this will cause an exception due to the wrong arguments | |
67 | a.[]=() | |
68 | end | |
69 | assert_raise(ArgumentError) do | |
70 | # this will cause an exception due to the wrong arguments | |
71 | a.[]=(1,2,3,4) | |
72 | end | |
73 | assert_raise(IndexError) do | |
74 | # this will cause an exception due to the wrong arguments | |
75 | a = [1,2,3,4,5] | |
76 | a[1, -1] = 10 | |
77 | end | |
78 | ||
79 | assert_equal(4, [1,2,3].[]=(1,4)) | |
80 | assert_equal(3, [1,2,3].[]=(1,2,3)) | |
81 | ||
82 | a = [1,2,3,4,5] | |
83 | a[3..-1] = 6 | |
84 | assert_equal([1,2,3,6], a) | |
85 | ||
86 | a = [1,2,3,4,5] | |
87 | a[3..-1] = [] | |
88 | assert_equal([1,2,3], a) | |
89 | ||
90 | a = [1,2,3,4,5] | |
91 | a[2...4] = 6 | |
92 | assert_equal([1,2,6,5], a) | |
[331] | 93 | |
94 | # passing self (#3274) | |
95 | a = [1,2,3] | |
96 | a[1,0] = a | |
97 | assert_equal([1,1,2,3,2,3], a) | |
98 | a = [1,2,3] | |
99 | a[-1,0] = a | |
100 | assert_equal([1,2,1,2,3,3], a) | |
[270] | 101 | end |
102 | ||
103 | assert('Array#clear', '15.2.12.5.6') do | |
104 | a = [1] | |
105 | a.clear | |
106 | assert_equal([], a) | |
107 | end | |
108 | ||
109 | assert('Array#collect!', '15.2.12.5.7') do | |
110 | a = [1,2,3] | |
111 | a.collect! { |i| i + i } | |
112 | assert_equal([2,4,6], a) | |
113 | end | |
114 | ||
115 | assert('Array#concat', '15.2.12.5.8') do | |
116 | assert_equal([1,2,3,4], [1, 2].concat([3, 4])) | |
[331] | 117 | |
118 | # passing self (#3302) | |
119 | a = [1,2,3] | |
120 | a.concat(a) | |
121 | assert_equal([1,2,3,1,2,3], a) | |
[270] | 122 | end |
123 | ||
124 | assert('Array#delete_at', '15.2.12.5.9') do | |
125 | a = [1,2,3] | |
126 | assert_equal(2, a.delete_at(1)) | |
127 | assert_equal([1,3], a) | |
128 | assert_equal(nil, a.delete_at(3)) | |
129 | assert_equal([1,3], a) | |
130 | assert_equal(nil, a.delete_at(-3)) | |
131 | assert_equal([1,3], a) | |
132 | assert_equal(3, a.delete_at(-1)) | |
133 | assert_equal([1], a) | |
134 | end | |
135 | ||
136 | assert('Array#each', '15.2.12.5.10') do | |
137 | a = [1,2,3] | |
138 | b = 0 | |
139 | a.each {|i| b += i} | |
140 | assert_equal(6, b) | |
141 | end | |
142 | ||
143 | assert('Array#each_index', '15.2.12.5.11') do | |
144 | a = [1] | |
145 | b = nil | |
146 | a.each_index {|i| b = i} | |
147 | assert_equal(0, b) | |
148 | end | |
149 | ||
150 | assert('Array#empty?', '15.2.12.5.12') do | |
151 | a = [] | |
152 | b = [b] | |
153 | assert_true([].empty?) | |
154 | assert_false([1].empty?) | |
155 | end | |
156 | ||
157 | assert('Array#first', '15.2.12.5.13') do | |
158 | assert_raise(ArgumentError) do | |
159 | # this will cause an exception due to the wrong argument | |
160 | [1,2,3].first(-1) | |
161 | end | |
162 | assert_raise(ArgumentError) do | |
163 | # this will cause an exception due to the wrong argument | |
164 | [1,2,3].first(1,2) | |
165 | end | |
166 | ||
167 | assert_nil([].first) | |
168 | ||
169 | b = [1,2,3] | |
170 | assert_equal(1, b.first) | |
171 | assert_equal([], b.first(0)) | |
172 | assert_equal([1], b.first(1)) | |
173 | assert_equal([1,2,3], b.first(4)) | |
174 | end | |
175 | ||
176 | assert('Array#index', '15.2.12.5.14') do | |
177 | a = [1,2,3] | |
178 | ||
179 | assert_equal(1, a.index(2)) | |
180 | assert_equal(nil, a.index(0)) | |
181 | end | |
182 | ||
183 | assert('Array#initialize', '15.2.12.5.15') do | |
184 | a = [].initialize(1) | |
185 | b = [].initialize(2) | |
186 | c = [].initialize(2, 1) | |
187 | d = [].initialize(2) {|i| i} | |
188 | ||
189 | assert_equal([nil], a) | |
190 | assert_equal([nil,nil], b) | |
191 | assert_equal([1,1], c) | |
192 | assert_equal([0,1], d) | |
193 | end | |
194 | ||
195 | assert('Array#initialize_copy', '15.2.12.5.16') do | |
196 | a = [1,2,3] | |
197 | b = [].initialize_copy(a) | |
198 | ||
199 | assert_equal([1,2,3], b) | |
200 | end | |
201 | ||
202 | assert('Array#join', '15.2.12.5.17') do | |
203 | a = [1,2,3].join | |
204 | b = [1,2,3].join(',') | |
205 | ||
206 | assert_equal('123', a) | |
207 | assert_equal('1,2,3', b) | |
208 | end | |
209 | ||
210 | assert('Array#last', '15.2.12.5.18') do | |
211 | assert_raise(ArgumentError) do | |
212 | # this will cause an exception due to the wrong argument | |
213 | [1,2,3].last(-1) | |
214 | end | |
215 | ||
216 | a = [1,2,3] | |
217 | assert_equal(3, a.last) | |
218 | assert_nil([].last) | |
219 | end | |
220 | ||
221 | assert('Array#length', '15.2.12.5.19') do | |
222 | a = [1,2,3] | |
223 | ||
224 | assert_equal(3, a.length) | |
225 | end | |
226 | ||
227 | assert('Array#map!', '15.2.12.5.20') do | |
228 | a = [1,2,3] | |
229 | a.map! { |i| i + i } | |
230 | assert_equal([2,4,6], a) | |
231 | end | |
232 | ||
233 | assert('Array#pop', '15.2.12.5.21') do | |
234 | a = [1,2,3] | |
235 | b = a.pop | |
236 | ||
237 | assert_nil([].pop) | |
238 | assert_equal([1,2], a) | |
239 | assert_equal(3, b) | |
240 | end | |
241 | ||
242 | assert('Array#push', '15.2.12.5.22') do | |
243 | a = [1,2,3] | |
244 | b = a.push(4) | |
245 | ||
246 | assert_equal([1,2,3,4], a) | |
247 | assert_equal([1,2,3,4], b) | |
248 | end | |
249 | ||
250 | assert('Array#replace', '15.2.12.5.23') do | |
251 | a = [1,2,3] | |
252 | b = [].replace(a) | |
253 | ||
254 | assert_equal([1,2,3], b) | |
255 | end | |
256 | ||
257 | assert('Array#reverse', '15.2.12.5.24') do | |
258 | a = [1,2,3] | |
259 | b = a.reverse | |
260 | ||
261 | assert_equal([1,2,3], a) | |
262 | assert_equal([3,2,1], b) | |
263 | end | |
264 | ||
265 | assert('Array#reverse!', '15.2.12.5.25') do | |
266 | a = [1,2,3] | |
267 | b = a.reverse! | |
268 | ||
269 | assert_equal([3,2,1], a) | |
270 | assert_equal([3,2,1], b) | |
271 | end | |
272 | ||
273 | assert('Array#rindex', '15.2.12.5.26') do | |
274 | a = [1,2,3] | |
275 | ||
276 | assert_equal(1, a.rindex(2)) | |
277 | assert_equal(nil, a.rindex(0)) | |
278 | end | |
279 | ||
280 | assert('Array#shift', '15.2.12.5.27') do | |
281 | a = [1,2,3] | |
282 | b = a.shift | |
283 | ||
284 | assert_nil([].shift) | |
285 | assert_equal([2,3], a) | |
286 | assert_equal(1, b) | |
287 | end | |
288 | ||
289 | assert('Array#size', '15.2.12.5.28') do | |
290 | a = [1,2,3] | |
291 | ||
292 | assert_equal(3, a.size) | |
293 | end | |
294 | ||
295 | assert('Array#slice', '15.2.12.5.29') do | |
296 | a = "12345".slice(1, 3) | |
297 | b = a.slice(0) | |
298 | ||
299 | assert_equal("2:", "#{b}:") | |
300 | assert_equal(2, [1,2,3].[](1)) | |
301 | end | |
302 | ||
303 | assert('Array#unshift', '15.2.12.5.30') do | |
304 | a = [2,3] | |
305 | b = a.unshift(1) | |
306 | c = [2,3] | |
307 | d = c.unshift(0, 1) | |
308 | ||
309 | assert_equal([1,2,3], a) | |
310 | assert_equal([1,2,3], b) | |
311 | assert_equal([0,1,2,3], c) | |
312 | assert_equal([0,1,2,3], d) | |
313 | end | |
314 | ||
315 | assert('Array#to_s', '15.2.12.5.31 / 15.2.12.5.32') do | |
316 | a = [2, 3, 4, 5] | |
317 | r1 = a.to_s | |
318 | r2 = a.inspect | |
319 | ||
320 | assert_equal(r2, r1) | |
321 | assert_equal("[2, 3, 4, 5]", r1) | |
322 | end | |
323 | ||
324 | assert('Array#==', '15.2.12.5.33') do | |
325 | assert_false(["a", "c"] == ["a", "c", 7]) | |
326 | assert_true(["a", "c", 7] == ["a", "c", 7]) | |
327 | assert_false(["a", "c", 7] == ["a", "d", "f"]) | |
328 | end | |
329 | ||
330 | assert('Array#eql?', '15.2.12.5.34') do | |
331 | a1 = [ 1, 2, 3 ] | |
332 | a2 = [ 1, 2, 3 ] | |
333 | a3 = [ 1.0, 2.0, 3.0 ] | |
334 | ||
335 | assert_true(a1.eql? a2) | |
336 | assert_false(a1.eql? a3) | |
337 | end | |
338 | ||
339 | assert('Array#hash', '15.2.12.5.35') do | |
340 | a = [ 1, 2, 3 ] | |
341 | ||
[331] | 342 | #assert_true(a.hash.is_a? Integer) |
343 | assert_true(a.hash.is_a? Integral) # mruby special | |
[270] | 344 | assert_equal([1,2].hash, [1,2].hash) |
345 | end | |
346 | ||
347 | assert('Array#<=>', '15.2.12.5.36') do | |
348 | r1 = [ "a", "a", "c" ] <=> [ "a", "b", "c" ] #=> -1 | |
349 | r2 = [ 1, 2, 3, 4, 5, 6 ] <=> [ 1, 2 ] #=> +1 | |
350 | r3 = [ "a", "b", "c" ] <=> [ "a", "b", "c" ] #=> 0 | |
351 | ||
352 | assert_equal(-1, r1) | |
353 | assert_equal(+1, r2) | |
354 | assert_equal(0, r3) | |
355 | end | |
356 | ||
357 | # Not ISO specified | |
358 | ||
359 | assert("Array (Shared Array Corruption)") do | |
360 | a = [ "a", "b", "c", "d", "e", "f" ] | |
361 | b = a.slice(1, 3) | |
362 | a.clear | |
363 | b.clear | |
364 | end | |
365 | ||
366 | assert("Array (Longish inline array)") do | |
367 | ary = [[0, 0], [1, 1], [2, 2], [3, 3], [4, 4], [5, 5], [6, 6], [7, 7], [8, 8], [9, 9], [10, 10], [11, 11], [12, 12], [13, 13], [14, 14], [15, 15], [16, 16], [17, 17], [18, 18], [19, 19], [20, 20], [21, 21], [22, 22], [23, 23], [24, 24], [25, 25], [26, 26], [27, 27], [28, 28], [29, 29], [30, 30], [31, 31], [32, 32], [33, 33], [34, 34], [35, 35], [36, 36], [37, 37], [38, 38], [39, 39], [40, 40], [41, 41], [42, 42], [43, 43], [44, 44], [45, 45], [46, 46], [47, 47], [48, 48], [49, 49], [50, 50], [51, 51], [52, 52], [53, 53], [54, 54], [55, 55], [56, 56], [57, 57], [58, 58], [59, 59], [60, 60], [61, 61], [62, 62], [63, 63], [64, 64], [65, 65], [66, 66], [67, 67], [68, 68], [69, 69], [70, 70], [71, 71], [72, 72], [73, 73], [74, 74], [75, 75], [76, 76], [77, 77], [78, 78], [79, 79], [80, 80], [81, 81], [82, 82], [83, 83], [84, 84], [85, 85], [86, 86], [87, 87], [88, 88], [89, 89], [90, 90], [91, 91], [92, 92], [93, 93], [94, 94], [95, 95], [96, 96], [97, 97], [98, 98], [99, 99], [100, 100], [101, 101], [102, 102], [103, 103], [104, 104], [105, 105], [106, 106], [107, 107], [108, 108], [109, 109], [110, 110], [111, 111], [112, 112], [113, 113], [114, 114], [115, 115], [116, 116], [117, 117], [118, 118], [119, 119], [120, 120], [121, 121], [122, 122], [123, 123], [124, 124], [125, 125], [126, 126], [127, 127], [128, 128], [129, 129], [130, 130], [131, 131], [132, 132], [133, 133], [134, 134], [135, 135], [136, 136], [137, 137], [138, 138], [139, 139], [140, 140], [141, 141], [142, 142], [143, 143], [144, 144], [145, 145], [146, 146], [147, 147], [148, 148], [149, 149], [150, 150], [151, 151], [152, 152], [153, 153], [154, 154], [155, 155], [156, 156], [157, 157], [158, 158], [159, 159], [160, 160], [161, 161], [162, 162], [163, 163], [164, 164], [165, 165], [166, 166], [167, 167], [168, 168], [169, 169], [170, 170], [171, 171], [172, 172], [173, 173], [174, 174], [175, 175], [176, 176], [177, 177], [178, 178], [179, 179], [180, 180], [181, 181], [182, 182], [183, 183], [184, 184], [185, 185], [186, 186], [187, 187], [188, 188], [189, 189], [190, 190], [191, 191], [192, 192], [193, 193], [194, 194], [195, 195], [196, 196], [197, 197], [198, 198], [199, 199]] | |
368 | h = Hash.new(0) | |
369 | ary.each {|p| h[p.class] += 1} | |
370 | assert_equal({Array=>200}, h) | |
371 | end | |
[331] | 372 | |
373 | assert("Array#rindex") do | |
374 | class Sneaky | |
375 | def ==(*) | |
376 | $a.clear | |
377 | $a.replace([1]) | |
378 | false | |
379 | end | |
380 | end | |
381 | $a = [2, 3, 4, 5, 6, 7, 8, 9, 10, Sneaky.new] | |
382 | assert_equal 0, $a.rindex(1) | |
383 | end | |
384 | ||
385 | assert('Array#freeze') do | |
386 | a = [].freeze | |
387 | assert_raise(RuntimeError) do | |
388 | a[0] = 1 | |
389 | end | |
390 | end |
Note:
See TracBrowser
for help on using the repository browser.