cast 0.1.0 → 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,50 +1,50 @@
1
- ###
2
- ### ##################################################################
3
- ###
4
- ### Tests for NodeList classes.
5
- ###
6
- ### ##################################################################
7
- ###
8
-
9
- ###
10
- ### NodeListTest classes are abstract, inherited by classes which
11
- ### define List() to return a NodeList class. The tests defined in
12
- ### NodeListTest subclasses are therefore used to test all NodeList
13
- ### classes.
14
- ###
1
+ ######################################################################
2
+ #
3
+ # Tests for NodeList classes.
4
+ #
5
+ ######################################################################
6
+
7
+ require 'test/test_helper'
8
+
9
+ #
10
+ # NodeListTest classes are abstract, inherited by classes which define
11
+ # List() to return a NodeList class. The tests defined in
12
+ # NodeListTest subclasses are therefore used to test all NodeList
13
+ # classes.
14
+ #
15
15
  module NodeListTest
16
16
  @@submodules = []
17
17
  def self.submodules
18
18
  @@submodules
19
19
  end
20
- def self.included m
20
+ def self.included(m)
21
21
  @@submodules << m
22
22
  end
23
23
  def setup
24
- ## []
24
+ # []
25
25
  @empty = _List[]
26
26
 
27
- ## [a]
27
+ # [a]
28
28
  a = C::Int.new
29
29
  @one = _List[a]
30
30
  @one_els = [a]
31
31
 
32
- ## [a, b]
32
+ # [a, b]
33
33
  a, b = 2.of{C::Int.new}
34
34
  @two = _List[a, b]
35
35
  @two_els = [a, b]
36
36
 
37
- ## [a, b, c]
37
+ # [a, b, c]
38
38
  a, b, c = 3.of{C::Int.new}
39
39
  @three = _List[a, b, c]
40
40
  @three_els = [a, b, c]
41
41
 
42
- ## [a, b, c, d]
42
+ # [a, b, c, d]
43
43
  a, b, c, d = 4.of{C::Int.new}
44
44
  @four = _List[a, b, c, d]
45
45
  @four_els = [a, b, c, d]
46
46
 
47
- ## [[a,b], [c,d], [e,f], [g,h]]
47
+ # [[a,b], [c,d], [e,f], [g,h]]
48
48
  a, b, c, d, e, f, g, h = 8.of{C::Int.new}
49
49
  l0 = _List[a,b]
50
50
  l1 = _List[c,d]
@@ -53,7 +53,7 @@ module NodeListTest
53
53
  @two_by_four = _List[l0, l1, l2, l3]
54
54
  @two_by_four_els = [l0, l1, l2, l3, a, b, c, d, e, f, g, h]
55
55
 
56
- ## [a, [b,c], [d, [e], [], [[]]]]
56
+ # [a, [b,c], [d, [e], [], [[]]]]
57
57
  a, b, c, d, e = 5.of{C::Int.new}
58
58
  l1 = _List[b,c]
59
59
  l21 = _List[e]
@@ -96,82 +96,82 @@ module NodeListInitializeTest
96
96
  end
97
97
  end
98
98
 
99
- ###
100
- ### Tests dup, clone.
101
- ###
99
+ #
100
+ # Tests dup, clone.
101
+ #
102
102
  module NodeListCopyTest
103
103
  include NodeListTest
104
104
  def test_copy
105
- ## empty
105
+ # empty
106
106
  a = empty
107
107
  b = empty.dup
108
108
  c = empty.clone
109
- ##
109
+ #
110
110
  assert_copy a, b
111
- ##
111
+ #
112
112
  assert_copy a, c
113
113
 
114
- ## one
114
+ # one
115
115
  a = one
116
116
  b = one.dup
117
117
  c = one.clone
118
- ##
118
+ #
119
119
  assert_copy a, b
120
120
  assert_copy a[0], b[0]
121
- ##
121
+ #
122
122
  assert_copy a, c
123
123
  assert_copy a[0], c[0]
124
124
 
125
- ## two
125
+ # two
126
126
  a = two
127
127
  b = two.dup
128
128
  c = two.clone
129
- ##
129
+ #
130
130
  assert_copy a, b
131
131
  assert_copy a[0], b[0]
132
132
  assert_copy a[1], b[1]
133
- ##
133
+ #
134
134
  assert_copy a, c
135
135
  assert_copy a[0], c[0]
136
136
  assert_copy a[1], c[1]
137
137
 
138
- ## three
138
+ # three
139
139
  a = three
140
140
  b = three.dup
141
141
  c = three.clone
142
- ##
142
+ #
143
143
  assert_copy a, b
144
144
  assert_copy a[0], b[0]
145
145
  assert_copy a[1], b[1]
146
146
  assert_copy a[2], b[2]
147
- ##
147
+ #
148
148
  assert_copy a, c
149
149
  assert_copy a[0], c[0]
150
150
  assert_copy a[1], c[1]
151
151
  assert_copy a[2], c[2]
152
152
 
153
- ## four
153
+ # four
154
154
  a = four
155
155
  b = four.dup
156
156
  c = four.clone
157
- ##
157
+ #
158
158
  assert_copy a, b
159
159
  assert_copy a[0], b[0]
160
160
  assert_copy a[1], b[1]
161
161
  assert_copy a[2], b[2]
162
162
  assert_copy a[3], b[3]
163
- ##
163
+ #
164
164
  assert_copy a, c
165
165
  assert_copy a[0], c[0]
166
166
  assert_copy a[1], c[1]
167
167
  assert_copy a[2], c[2]
168
168
  assert_copy a[3], c[3]
169
169
 
170
- ## two_by_four
170
+ # two_by_four
171
171
  a = two_by_four
172
172
  b = two_by_four.dup
173
173
  c = two_by_four.clone
174
- ##
174
+ #
175
175
  assert_copy a, b
176
176
  assert_copy a[0], b[0]
177
177
  assert_copy a[1], b[1]
@@ -185,7 +185,7 @@ module NodeListCopyTest
185
185
  assert_copy a[2][1], b[2][1]
186
186
  assert_copy a[3][0], b[3][0]
187
187
  assert_copy a[3][1], b[3][1]
188
- ##
188
+ #
189
189
  assert_copy a, c
190
190
  assert_copy a[0], c[0]
191
191
  assert_copy a[1], c[1]
@@ -200,11 +200,11 @@ module NodeListCopyTest
200
200
  assert_copy a[3][0], c[3][0]
201
201
  assert_copy a[3][1], c[3][1]
202
202
 
203
- ## big -- [a, [b,c], [d, [e], [], [[]]]]
203
+ # big -- [a, [b,c], [d, [e], [], [[]]]]
204
204
  a = big
205
205
  b = big.dup
206
206
  c = big.clone
207
- ##
207
+ #
208
208
  assert_copy a, b
209
209
  assert_copy a[0], b[0]
210
210
  assert_copy a[1], b[1]
@@ -217,7 +217,7 @@ module NodeListCopyTest
217
217
  assert_copy a[2][2], b[2][2]
218
218
  assert_copy a[2][3], b[2][3]
219
219
  assert_copy a[2][3][0], b[2][3][0]
220
- ##
220
+ #
221
221
  assert_copy a, c
222
222
  assert_copy a[0], c[0]
223
223
  assert_copy a[1], c[1]
@@ -233,17 +233,17 @@ module NodeListCopyTest
233
233
  end
234
234
  end
235
235
 
236
- ###
237
- ### Tests ==, eql?, hash.
238
- ###
236
+ #
237
+ # Tests ==, eql?, hash.
238
+ #
239
239
  module NodeListEqualTest
240
240
  include NodeListTest
241
- def assert_eq a, b
241
+ def assert_eq(a, b)
242
242
  assert(a == b)
243
243
  assert(a.eql?(b))
244
244
  assert(a.hash == b.hash)
245
245
  end
246
- def assert_not_eq a, b
246
+ def assert_not_eq(a, b)
247
247
  assert(!(a == b))
248
248
  assert(!a.eql?(b))
249
249
  end
@@ -263,31 +263,31 @@ module NodeListEqualTest
263
263
  assert_not_eq(two, three)
264
264
  assert_not_eq(three, two)
265
265
 
266
- ## []
266
+ # []
267
267
  empty2 = _List[]
268
268
  assert_eq(empty, empty2)
269
269
 
270
- ## [a]
270
+ # [a]
271
271
  a = C::Int.new
272
272
  one2 = _List[a]
273
273
  assert_eq(one, one2)
274
274
 
275
- ## [a, b]
275
+ # [a, b]
276
276
  a, b = 2.of{C::Int.new}
277
277
  two2 = _List[a, b]
278
278
  assert_eq(two, two2)
279
279
 
280
- ## [a, b, c]
280
+ # [a, b, c]
281
281
  a, b, c = 3.of{C::Int.new}
282
282
  three2 = _List[a, b, c]
283
283
  assert_eq(three, three2)
284
284
 
285
- ## [a, b, c, d]
285
+ # [a, b, c, d]
286
286
  a, b, c, d = 4.of{C::Int.new}
287
287
  four2 = _List[a, b, c, d]
288
288
  assert_eq(four, four2)
289
289
 
290
- ## [[a,b], [c,d], [e,f], [g,h]]
290
+ # [[a,b], [c,d], [e,f], [g,h]]
291
291
  a, b, c, d, e, f, g, h = 8.of{C::Int.new}
292
292
  l0 = _List[a,b]
293
293
  l1 = _List[c,d]
@@ -296,7 +296,7 @@ module NodeListEqualTest
296
296
  two_by_four2 = _List[l0, l1, l2, l3]
297
297
  assert_eq(two_by_four, two_by_four2)
298
298
 
299
- ## [a, [b,c], [d, [e], [], [[]]]]
299
+ # [a, [b,c], [d, [e], [], [[]]]]
300
300
  a, b, c, d, e = 5.of{C::Int.new}
301
301
  l1 = _List[b,c]
302
302
  l21 = _List[e]
@@ -311,11 +311,11 @@ end
311
311
 
312
312
  module NodeListWalkTest
313
313
  include NodeListTest
314
- ###
315
- ### Collect and return the args yielded to `node.send(method)' as an
316
- ### Array, each element of which is an array of args yielded.
317
- ###
318
- def yields method, node, exp
314
+ #
315
+ # Collect and return the args yielded to `node.send(method)' as an
316
+ # Array, each element of which is an array of args yielded.
317
+ #
318
+ def yields(method, node, exp)
319
319
  ret = []
320
320
  out = node.send(method) do |*args|
321
321
  ret << args
@@ -324,18 +324,18 @@ module NodeListWalkTest
324
324
  return ret
325
325
  end
326
326
 
327
- ###
328
- ### Assert exp and out are equal, where elements are compared with
329
- ### Array#same_list?. That is, exp[i].same_list?(out[i]) for all i.
330
- ###
331
- def assert_equal_yields exp, out
327
+ #
328
+ # Assert exp and out are equal, where elements are compared with
329
+ # Array#same_list?. That is, exp[i].same_list?(out[i]) for all i.
330
+ #
331
+ def assert_equal_yields(exp, out)
332
332
  if exp.zip(out).all?{|a,b| a.same_list?(b)}
333
333
  assert(true)
334
334
  else
335
335
  flunk("walk not equal: #{walk_str(out)} (expected #{walk_str(exp)})")
336
336
  end
337
337
  end
338
- def walk_str walk
338
+ def walk_str(walk)
339
339
  walk.is_a? ::Array or
340
340
  raise "walk_str: expected ::Array"
341
341
  if walk.empty?
@@ -355,12 +355,11 @@ module NodeListWalkTest
355
355
  end
356
356
  end
357
357
 
358
- ###
359
- ### ----------------------------------------------------------------
360
- ### each, reverse_each
361
- ### ----------------------------------------------------------------
362
- ###
363
- def iter_str iter
358
+ # ------------------------------------------------------------------
359
+ # each, reverse_each
360
+ # ------------------------------------------------------------------
361
+
362
+ def iter_str(iter)
364
363
  iter.is_a? ::Array or
365
364
  raise "iter_str: expected ::Array"
366
365
  if iter.empty?
@@ -379,7 +378,7 @@ module NodeListWalkTest
379
378
  return s.string
380
379
  end
381
380
  end
382
- def check_iter node, exp
381
+ def check_iter(node, exp)
383
382
  exp.map!{|n| [n]}
384
383
 
385
384
  out = yields(:each, node, node)
@@ -391,69 +390,68 @@ module NodeListWalkTest
391
390
  end
392
391
 
393
392
  def test_each
394
- ## empty
393
+ # empty
395
394
  check_iter(empty, [])
396
395
 
397
- ## one
398
- a = *one_els
396
+ # one
397
+ a, = *one_els
399
398
  check_iter(one, [a])
400
399
 
401
- ## two
400
+ # two
402
401
  a, b = *two_els
403
402
  check_iter(two, [a, b])
404
403
 
405
- ## three
404
+ # three
406
405
  a, b, c = *three_els
407
406
  check_iter(three, [a, b, c])
408
407
 
409
- ## four
408
+ # four
410
409
  a, b, c, d = *four_els
411
410
  check_iter(four, [a, b, c, d])
412
411
 
413
- ## two_by_four
412
+ # two_by_four
414
413
  l0, l1, l2, l3, a, b, c, d, e, f, g, h = *two_by_four_els
415
414
  check_iter(two_by_four, [l0, l1, l2, l3])
416
415
 
417
- ## big
416
+ # big
418
417
  l1, l2, l21, l22, l23, l230, a, b, c, d, e = *big_els
419
418
  check_iter(big, [a, l1, l2])
420
419
  end
421
420
 
422
- ###
423
- ### ----------------------------------------------------------------
424
- ### each_index
425
- ### ----------------------------------------------------------------
426
- ###
421
+ # ------------------------------------------------------------------
422
+ # each_index
423
+ # ------------------------------------------------------------------
424
+
427
425
  def test_each_index
428
- ## empty
426
+ # empty
429
427
  assert_equal([], yields(:each_index, empty, empty))
430
428
 
431
- ## one
429
+ # one
432
430
  assert_equal([[0]], yields(:each_index, one, one))
433
431
 
434
- ## two
432
+ # two
435
433
  assert_equal([[0], [1]], yields(:each_index, two, two))
436
434
 
437
- ## two_by_four
435
+ # two_by_four
438
436
  assert_equal([[0], [1], [2], [3]], yields(:each_index, two_by_four, two_by_four))
439
437
 
440
- ## big
438
+ # big
441
439
  assert_equal([[0], [1], [2]], yields(:each_index, big, big))
442
440
  end
443
441
  end
444
442
 
445
- ###
446
- ### Tests:
447
- ### -- node_before
448
- ### -- node_after
449
- ### -- remove_node
450
- ### -- insert_before
451
- ### -- insert_after
452
- ### -- replace_node
453
- ###
443
+ #
444
+ # Tests:
445
+ # -- node_before
446
+ # -- node_after
447
+ # -- remove_node
448
+ # -- insert_before
449
+ # -- insert_after
450
+ # -- replace_node
451
+ #
454
452
  module NodeListChildManagementTests
455
453
  include NodeListTest
456
- def check_not_child list, node
454
+ def check_not_child(list, node)
457
455
  n = C::Int.new
458
456
  assert_raise(ArgumentError, list.node_before(node))
459
457
  assert_raise(ArgumentError, list.node_after(node))
@@ -463,7 +461,7 @@ module NodeListChildManagementTests
463
461
  assert_raise(ArgumentError, list.replace_node(node, n))
464
462
  end
465
463
 
466
- def check_list list, *nodes
464
+ def check_list(list, *nodes)
467
465
  afters = nodes.dup
468
466
  afters.shift
469
467
  afters.push(nil)
@@ -476,18 +474,16 @@ module NodeListChildManagementTests
476
474
  nodes.each_index do |i|
477
475
  assert_same(nodes[i], list[i], "at index #{i}")
478
476
  assert_same(list, nodes[i].parent, "at index #{i}")
479
- ## node_after
477
+ # node_after
480
478
  assert_same(afters[i], list.node_after(nodes[i]), "at index #{i} (expected id=#{afters[i].object_id}, got id=#{list.node_after(nodes[i]).object_id})")
481
- ## node_before
479
+ # node_before
482
480
  assert_same(befores[i], list.node_before(nodes[i]), "at index #{i}")
483
481
  end
484
482
  end
485
483
 
486
- ###
487
- ### ----------------------------------------------------------------
488
- ### insert_before, insert_after
489
- ### ----------------------------------------------------------------
490
- ###
484
+ # ------------------------------------------------------------------
485
+ # insert_before, insert_after
486
+ # ------------------------------------------------------------------
491
487
 
492
488
  def test_insert_one_into_one
493
489
  a1, a2 = 2.of{C::Int.new}
@@ -495,11 +491,11 @@ module NodeListChildManagementTests
495
491
  a = _List[a1]
496
492
  b = _List[b1]
497
493
 
498
- ## beginning
494
+ # beginning
499
495
  assert_same(b, b.insert_before(b1, b2))
500
496
  check_list(b, b2, b1)
501
497
 
502
- ## end
498
+ # end
503
499
  assert_same(a, a.insert_after(a1, a2))
504
500
  check_list(a, a1, a2)
505
501
  end
@@ -510,11 +506,11 @@ module NodeListChildManagementTests
510
506
  a = _List[a1]
511
507
  b = _List[b1]
512
508
 
513
- ## beginning
509
+ # beginning
514
510
  assert_same(a, a.insert_before(a1, a2, a3))
515
511
  check_list(a, a2, a3, a1)
516
512
 
517
- ## end
513
+ # end
518
514
  assert_same(b, b.insert_after(b1, b2, b3))
519
515
  check_list(b, b1, b2, b3)
520
516
  end
@@ -525,11 +521,11 @@ module NodeListChildManagementTests
525
521
  a = _List[a1]
526
522
  b = _List[b1]
527
523
 
528
- ## beginning
524
+ # beginning
529
525
  assert_same(a, a.insert_before(a1, a2, a3, a4))
530
526
  check_list(a, a2, a3, a4, a1)
531
527
 
532
- ## end
528
+ # end
533
529
  assert_same(b, b.insert_after(b1, b2, b3, b4))
534
530
  check_list(b, b1, b2, b3, b4)
535
531
  end
@@ -540,16 +536,16 @@ module NodeListChildManagementTests
540
536
  a = _List[a1]
541
537
  b = _List[b1]
542
538
 
543
- ## beginning
539
+ # beginning
544
540
  assert_same(a, a.insert_before(a1, a2, a3, a4, a5))
545
541
  check_list(a, a2, a3, a4, a5, a1)
546
542
 
547
- ## end
543
+ # end
548
544
  assert_same(b, b.insert_after(b1, b2, b3, b4, b5))
549
545
  check_list(b, b1, b2, b3, b4, b5)
550
546
  end
551
547
 
552
- def insert_one_into_two
548
+ def test_insert_one_into_two
553
549
  a1, a2, a3 = 3.of{C::Int.new}
554
550
  b1, b2, b3 = 3.of{C::Int.new}
555
551
  c1, c2, c3 = 3.of{C::Int.new}
@@ -559,19 +555,19 @@ module NodeListChildManagementTests
559
555
  c = _List[c1, c2]
560
556
  d = _List[d1, d2]
561
557
 
562
- ## beginning
558
+ # beginning
563
559
  assert_same(a, a.insert_before(a1, a3))
564
560
  check_list(a, a3, a1, a2)
565
561
 
566
- ## end
562
+ # end
567
563
  assert_same(b, b.insert_after(b2, b3))
568
564
  check_list(b, b1, b2, b3)
569
565
 
570
- ## middle (after)
566
+ # middle (after)
571
567
  assert_same(c, c.insert_after(c1, c3))
572
568
  check_list(c, c1, c3, c2)
573
569
 
574
- ## middle (before)
570
+ # middle (before)
575
571
  assert_same(d, d.insert_before(d2, d3))
576
572
  check_list(d, d1, d3, d2)
577
573
  end
@@ -586,19 +582,19 @@ module NodeListChildManagementTests
586
582
  c = _List[c1, c2]
587
583
  d = _List[d1, d2]
588
584
 
589
- ## beginning
585
+ # beginning
590
586
  assert_same(a, a.insert_before(a1, a3, a4))
591
587
  check_list(a, a3, a4, a1, a2)
592
588
 
593
- ## end
589
+ # end
594
590
  assert_same(b, b.insert_after(b2, b3, b4))
595
591
  check_list(b, b1, b2, b3, b4)
596
592
 
597
- ## middle (after)
593
+ # middle (after)
598
594
  assert_same(c, c.insert_after(c1, c3, c4))
599
595
  check_list(c, c1, c3, c4, c2)
600
596
 
601
- ## middle (before)
597
+ # middle (before)
602
598
  assert_same(d, d.insert_before(d2, d3, d4))
603
599
  check_list(d, d1, d3, d4, d2)
604
600
  end
@@ -613,19 +609,19 @@ module NodeListChildManagementTests
613
609
  c = _List[c1, c2]
614
610
  d = _List[d1, d2]
615
611
 
616
- ## beginning
612
+ # beginning
617
613
  assert_same(a, a.insert_before(a1, a3, a4, a5))
618
614
  check_list(a, a3, a4, a5, a1, a2)
619
615
 
620
- ## end
616
+ # end
621
617
  assert_same(b, b.insert_after(b2, b3, b4, b5))
622
618
  check_list(b, b1, b2, b3, b4, b5)
623
619
 
624
- ## middle (after)
620
+ # middle (after)
625
621
  assert_same(c, c.insert_after(c1, c3, c4, c5))
626
622
  check_list(c, c1, c3, c4, c5, c2)
627
623
 
628
- ## middle (before)
624
+ # middle (before)
629
625
  assert_same(d, d.insert_before(d2, d3, d4, d5))
630
626
  check_list(d, d1, d3, d4, d5, d2)
631
627
  end
@@ -640,25 +636,25 @@ module NodeListChildManagementTests
640
636
  c = _List[c1, c2]
641
637
  d = _List[d1, d2]
642
638
 
643
- ## beginning
639
+ # beginning
644
640
  assert_same(a, a.insert_before(a1, a3, a4, a5, a6))
645
641
  check_list(a, a3, a4, a5, a6, a1, a2)
646
642
 
647
- ## end
643
+ # end
648
644
  assert_same(b, b.insert_after(b2, b3, b4, b5, b6))
649
645
  check_list(b, b1, b2, b3, b4, b5, b6)
650
646
 
651
- ## middle (after)
647
+ # middle (after)
652
648
  assert_same(c, c.insert_after(c1, c3, c4, c5, c6))
653
649
  check_list(c, c1, c3, c4, c5, c6, c2)
654
650
 
655
- ## middle (before)
651
+ # middle (before)
656
652
  assert_same(d, d.insert_before(d2, d3, d4, d5, d6))
657
653
  check_list(d, d1, d3, d4, d5, d6, d2)
658
654
  end
659
655
 
660
656
  def test_insert_attached
661
- ## one (before)
657
+ # one (before)
662
658
  a1 = C::Int.new
663
659
  b1 = C::Int.new
664
660
  a = _List[a1]
@@ -669,7 +665,7 @@ module NodeListChildManagementTests
669
665
  assert_copy(b1, a[0])
670
666
  assert_same(a1, a[1])
671
667
 
672
- ## one (after)
668
+ # one (after)
673
669
  a1 = C::Int.new
674
670
  b1 = C::Int.new
675
671
  a = _List[a1]
@@ -680,7 +676,7 @@ module NodeListChildManagementTests
680
676
  assert_same(a1, a[0])
681
677
  assert_copy(b1, a[1])
682
678
 
683
- ## many (before)
679
+ # many (before)
684
680
  a1 = C::Int.new
685
681
  b1, b2, b3, b4 = 4.of{C::Int.new}
686
682
  a = _List[a1]
@@ -694,7 +690,7 @@ module NodeListChildManagementTests
694
690
  assert_copy(b4, a[3])
695
691
  assert_same(a1, a[4])
696
692
 
697
- ## many (after)
693
+ # many (after)
698
694
  a1 = C::Int.new
699
695
  b1, b2, b3, b4 = 4.of{C::Int.new}
700
696
  a = _List[a1]
@@ -709,11 +705,9 @@ module NodeListChildManagementTests
709
705
  assert_copy(b4, a[4])
710
706
  end
711
707
 
712
- ###
713
- ### ----------------------------------------------------------------
714
- ### remove_node
715
- ### ----------------------------------------------------------------
716
- ###
708
+ # ------------------------------------------------------------------
709
+ # remove_node
710
+ # ------------------------------------------------------------------
717
711
 
718
712
  def test_remove_one_from_one
719
713
  a1 = C::Int.new
@@ -730,12 +724,12 @@ module NodeListChildManagementTests
730
724
  a = _List[a1, a2]
731
725
  b = _List[b1, b2]
732
726
 
733
- ## beginning
727
+ # beginning
734
728
  assert_same(a, a.remove_node(a1))
735
729
  check_list(a, a2)
736
730
  assert_nil(a1.parent)
737
731
 
738
- ## end
732
+ # end
739
733
  assert_same(b, b.remove_node(b2))
740
734
  check_list(b, b1)
741
735
  assert_nil(b2.parent)
@@ -749,17 +743,17 @@ module NodeListChildManagementTests
749
743
  b = _List[b1, b2, b3]
750
744
  c = _List[c1, c2, c3]
751
745
 
752
- ## beginning
746
+ # beginning
753
747
  assert_same(a, a.remove_node(a1))
754
748
  check_list(a, a2, a3)
755
749
  assert_nil(a1.parent)
756
750
 
757
- ## end
751
+ # end
758
752
  assert_same(b, b.remove_node(b3))
759
753
  check_list(b, b1, b2)
760
754
  assert_nil(b3.parent)
761
755
 
762
- ## middle
756
+ # middle
763
757
  assert_same(c, c.remove_node(c2))
764
758
  check_list(c, c1, c3)
765
759
  assert_nil(c2.parent)
@@ -774,27 +768,25 @@ module NodeListChildManagementTests
774
768
  b = _List[b1, b2, b3, b4]
775
769
  c = _List[c1, c2, c3, c4]
776
770
 
777
- ## beginning
771
+ # beginning
778
772
  assert_same(a, a.remove_node(a1))
779
773
  check_list(a, a2, a3, a4)
780
774
  assert_nil(a1.parent)
781
775
 
782
- ## end
776
+ # end
783
777
  assert_same(b, b.remove_node(b4))
784
778
  check_list(b, b1, b2, b3)
785
779
  assert_nil(b4.parent)
786
780
 
787
- ## middle
781
+ # middle
788
782
  assert_same(c, c.remove_node(c2))
789
783
  check_list(c, c1, c3, c4)
790
784
  assert_nil(c2.parent)
791
785
  end
792
786
 
793
- ###
794
- ### ----------------------------------------------------------------
795
- ### replace_node
796
- ### ----------------------------------------------------------------
797
- ###
787
+ # ------------------------------------------------------------------
788
+ # replace_node
789
+ # ------------------------------------------------------------------
798
790
 
799
791
  def test_replace_with_none_in_one
800
792
  a1 = C::Int.new
@@ -810,12 +802,12 @@ module NodeListChildManagementTests
810
802
  a = _List[a1, a2]
811
803
  b = _List[b1, b2]
812
804
 
813
- ## beginning
805
+ # beginning
814
806
  assert_same(a, a.replace_node(a1))
815
807
  check_list(a, a2)
816
808
  assert_nil(a1.parent)
817
809
 
818
- ## end
810
+ # end
819
811
  assert_same(b, b.replace_node(b2))
820
812
  check_list(b, b1)
821
813
  assert_nil(b2.parent)
@@ -829,17 +821,17 @@ module NodeListChildManagementTests
829
821
  b = _List[b1, b2, b3]
830
822
  c = _List[c1, c2, c3]
831
823
 
832
- ## beginning
824
+ # beginning
833
825
  assert_same(a, a.replace_node(a1))
834
826
  check_list(a, a2, a3)
835
827
  assert_nil(a1.parent)
836
828
 
837
- ## end
829
+ # end
838
830
  assert_same(b, b.replace_node(b3))
839
831
  check_list(b, b1, b2)
840
832
  assert_nil(b3.parent)
841
833
 
842
- ## middle
834
+ # middle
843
835
  assert_same(c, c.replace_node(c2))
844
836
  check_list(c, c1, c3)
845
837
  assert_nil(c2.parent)
@@ -860,12 +852,12 @@ module NodeListChildManagementTests
860
852
  a = _List[a1, a2]
861
853
  b = _List[b1, b2]
862
854
 
863
- ## beginning
855
+ # beginning
864
856
  assert_same(a, a.replace_node(a1, a3))
865
857
  check_list(a, a3, a2)
866
858
  assert_nil(a1.parent)
867
859
 
868
- ## end
860
+ # end
869
861
  assert_same(b, b.replace_node(b2, b3))
870
862
  check_list(b, b1, b3)
871
863
  assert_nil(b2.parent)
@@ -879,17 +871,17 @@ module NodeListChildManagementTests
879
871
  b = _List[b1, b2, b3]
880
872
  c = _List[c1, c2, c3]
881
873
 
882
- ## beginning
874
+ # beginning
883
875
  assert_same(a, a.replace_node(a1, a4))
884
876
  check_list(a, a4, a2, a3)
885
877
  assert_nil(a1.parent)
886
878
 
887
- ## end
879
+ # end
888
880
  assert_same(b, b.replace_node(b3, b4))
889
881
  check_list(b, b1, b2, b4)
890
882
  assert_nil(b3.parent)
891
883
 
892
- ## middle
884
+ # middle
893
885
  assert_same(c, c.replace_node(c2, c4))
894
886
  check_list(c, c1, c4, c3)
895
887
  assert_nil(c2.parent)
@@ -910,12 +902,12 @@ module NodeListChildManagementTests
910
902
  a = _List[a1, a2]
911
903
  b = _List[b1, b2]
912
904
 
913
- ## beginning
905
+ # beginning
914
906
  assert_same(a, a.replace_node(a1, a3, a4))
915
907
  check_list(a, a3, a4, a2)
916
908
  assert_nil(a1.parent)
917
909
 
918
- ## end
910
+ # end
919
911
  assert_same(b, b.replace_node(b2, b3, b4))
920
912
  check_list(b, b1, b3, b4)
921
913
  assert_nil(b2.parent)
@@ -929,17 +921,17 @@ module NodeListChildManagementTests
929
921
  b = _List[b1, b2, b3]
930
922
  c = _List[c1, c2, c3]
931
923
 
932
- ## beginning
924
+ # beginning
933
925
  assert_same(a, a.replace_node(a1, a4, a5))
934
926
  check_list(a, a4, a5, a2, a3)
935
927
  assert_nil(a1.parent)
936
928
 
937
- ## end
929
+ # end
938
930
  assert_same(b, b.replace_node(b3, b4, b5))
939
931
  check_list(b, b1, b2, b4, b5)
940
932
  assert_nil(b3.parent)
941
933
 
942
- ## middle
934
+ # middle
943
935
  assert_same(c, c.replace_node(c2, c4, c5))
944
936
  check_list(c, c1, c4, c5, c3)
945
937
  assert_nil(c2.parent)
@@ -960,12 +952,12 @@ module NodeListChildManagementTests
960
952
  a = _List[a1, a2]
961
953
  b = _List[b1, b2]
962
954
 
963
- ## beginning
955
+ # beginning
964
956
  assert_same(a, a.replace_node(a1, a3, a4, a5))
965
957
  check_list(a, a3, a4, a5, a2)
966
958
  assert_nil(a1.parent)
967
959
 
968
- ## end
960
+ # end
969
961
  assert_same(b, b.replace_node(b2, b3, b4, b5))
970
962
  check_list(b, b1, b3, b4, b5)
971
963
  assert_nil(b2.parent)
@@ -979,17 +971,17 @@ module NodeListChildManagementTests
979
971
  b = _List[b1, b2, b3]
980
972
  c = _List[c1, c2, c3]
981
973
 
982
- ## beginning
974
+ # beginning
983
975
  assert_same(a, a.replace_node(a1, a4, a5, a6))
984
976
  check_list(a, a4, a5, a6, a2, a3)
985
977
  assert_nil(a1.parent)
986
978
 
987
- ## end
979
+ # end
988
980
  assert_same(b, b.replace_node(b3, b4, b5, b6))
989
981
  check_list(b, b1, b2, b4, b5, b6)
990
982
  assert_nil(b3.parent)
991
983
 
992
- ## middle
984
+ # middle
993
985
  assert_same(c, c.replace_node(c2, c4, c5, c6))
994
986
  check_list(c, c1, c4, c5, c6, c3)
995
987
  assert_nil(c2.parent)
@@ -1010,12 +1002,12 @@ module NodeListChildManagementTests
1010
1002
  a = _List[a1, a2]
1011
1003
  b = _List[b1, b2]
1012
1004
 
1013
- ## beginning
1005
+ # beginning
1014
1006
  assert_same(a, a.replace_node(a1, a3, a4, a5, a6))
1015
1007
  check_list(a, a3, a4, a5, a6, a2)
1016
1008
  assert_nil(a1.parent)
1017
1009
 
1018
- ## end
1010
+ # end
1019
1011
  assert_same(b, b.replace_node(b2, b3, b4, b5, b6))
1020
1012
  check_list(b, b1, b3, b4, b5, b6)
1021
1013
  assert_nil(b2.parent)
@@ -1029,24 +1021,24 @@ module NodeListChildManagementTests
1029
1021
  b = _List[b1, b2, b3]
1030
1022
  c = _List[c1, c2, c3]
1031
1023
 
1032
- ## beginning
1024
+ # beginning
1033
1025
  assert_same(a, a.replace_node(a1, a4, a5, a6, a7))
1034
1026
  check_list(a, a4, a5, a6, a7, a2, a3)
1035
1027
  assert_nil(a1.parent)
1036
1028
 
1037
- ## end
1029
+ # end
1038
1030
  assert_same(b, b.replace_node(b3, b4, b5, b6, b7))
1039
1031
  check_list(b, b1, b2, b4, b5, b6, b7)
1040
1032
  assert_nil(b3.parent)
1041
1033
 
1042
- ## middle
1034
+ # middle
1043
1035
  assert_same(c, c.replace_node(c2, c4, c5, c6, c7))
1044
1036
  check_list(c, c1, c4, c5, c6, c7, c3)
1045
1037
  assert_nil(c2.parent)
1046
1038
  end
1047
1039
 
1048
1040
  def test_replace_with_attached
1049
- ## one
1041
+ # one
1050
1042
  a1 = C::Int.new
1051
1043
  a = _List[a1]
1052
1044
  b1 = C::Int.new
@@ -1055,7 +1047,7 @@ module NodeListChildManagementTests
1055
1047
  assert_copy(b1, a[0])
1056
1048
  assert_nil(a1.parent)
1057
1049
 
1058
- ## many
1050
+ # many
1059
1051
  a1 = C::Int.new
1060
1052
  a = _List[a1]
1061
1053
  b1, b2, b3, b4 = 4.of{C::Int.new}
@@ -1069,7 +1061,7 @@ module NodeListChildManagementTests
1069
1061
  end
1070
1062
 
1071
1063
  def test_replace_with_duplicated
1072
- ## one
1064
+ # one
1073
1065
  a1, a2 = 2.of{C::Int.new}
1074
1066
  a = _List[a1]
1075
1067
  assert_same(a, a.replace_node(a1, a2, a2))
@@ -1077,7 +1069,7 @@ module NodeListChildManagementTests
1077
1069
  assert_same(a2, a[0])
1078
1070
  assert_copy(a2, a[1])
1079
1071
 
1080
- ## many
1072
+ # many
1081
1073
  a1, a2, a3, a4 = 4.of{C::Int.new}
1082
1074
  a = _List[a1, a2, a3]
1083
1075
  assert_same(a, a.replace_node(a1, a2, a4, a2, a4))
@@ -1091,13 +1083,13 @@ module NodeListChildManagementTests
1091
1083
  end
1092
1084
 
1093
1085
  def test_replace_with_replaced
1094
- ## one
1086
+ # one
1095
1087
  a1 = C::Int.new
1096
1088
  a = _List[a1]
1097
1089
  assert_same(a, a.replace_node(a1, a1))
1098
1090
  assert_same_list([a1], a)
1099
1091
 
1100
- ## many -- some are the replaced node
1092
+ # many -- some are the replaced node
1101
1093
  a1, a2, a3 = 3.of{C::Int.new}
1102
1094
  a = _List[a1]
1103
1095
  assert_same(a, a.replace_node(a1, a1, a2, a3, a1))
@@ -1107,7 +1099,7 @@ module NodeListChildManagementTests
1107
1099
  assert_same(a3, a[2])
1108
1100
  assert_copy(a1, a[3])
1109
1101
 
1110
- ## many -- all are the replaced node
1102
+ # many -- all are the replaced node
1111
1103
  a1 = C::Int.new
1112
1104
  a = _List[a1]
1113
1105
  assert_same(a, a.replace_node(a1, a1, a1, a1))
@@ -1120,18 +1112,17 @@ end
1120
1112
 
1121
1113
  module NodeListArrayQueryTests
1122
1114
  include NodeListTest
1123
- ###
1124
- ### ----------------------------------------------------------------
1125
- ### first, last
1126
- ### ----------------------------------------------------------------
1127
- ###
1115
+
1116
+ # ------------------------------------------------------------------
1117
+ # first, last
1118
+ # ------------------------------------------------------------------
1128
1119
 
1129
1120
  def test_first
1130
- ## empty
1121
+ # empty
1131
1122
  a = _List[]
1132
1123
  assert_nil(a.first)
1133
1124
 
1134
- ## one
1125
+ # one
1135
1126
  a1 = C::Int.new
1136
1127
  a = _List[a1]
1137
1128
  assert_same(a1, a.first)
@@ -1139,7 +1130,7 @@ module NodeListArrayQueryTests
1139
1130
  assert_same_list([a1], a.first(1))
1140
1131
  assert_same_list([a1], a.first(2))
1141
1132
 
1142
- ## two
1133
+ # two
1143
1134
  a1, a2 = 2.of{C::Int.new}
1144
1135
  a = _List[a1, a2]
1145
1136
  assert_same(a1, a.first)
@@ -1148,7 +1139,7 @@ module NodeListArrayQueryTests
1148
1139
  assert_same_list([a1, a2], a.first(2))
1149
1140
  assert_same_list([a1, a2], a.first(3))
1150
1141
 
1151
- ## three
1142
+ # three
1152
1143
  ret = a.first(3)
1153
1144
  a1, a2, a3 = 3.of{C::Int.new}
1154
1145
  a = _List[a1, a2, a3]
@@ -1159,16 +1150,16 @@ module NodeListArrayQueryTests
1159
1150
  assert_same_list([a1, a2, a3], a.first(3))
1160
1151
  assert_same_list([a1, a2, a3], a.first(4))
1161
1152
 
1162
- ## negative array size
1153
+ # negative array size
1163
1154
  assert_raise(ArgumentError){a.first(-1)}
1164
1155
  end
1165
1156
 
1166
1157
  def test_last
1167
- ## empty
1158
+ # empty
1168
1159
  a = _List[]
1169
1160
  assert_nil(a.last)
1170
1161
 
1171
- ## one
1162
+ # one
1172
1163
  a1 = C::Int.new
1173
1164
  a = _List[a1]
1174
1165
  assert_same(a1, a.last)
@@ -1176,7 +1167,7 @@ module NodeListArrayQueryTests
1176
1167
  assert_same_list([a1], a.last(1))
1177
1168
  assert_same_list([a1], a.last(2))
1178
1169
 
1179
- ## two
1170
+ # two
1180
1171
  a1, a2 = 2.of{C::Int.new}
1181
1172
  a = _List[a1, a2]
1182
1173
  assert_same(a2, a.last)
@@ -1185,7 +1176,7 @@ module NodeListArrayQueryTests
1185
1176
  assert_same_list([a1, a2], a.last(2))
1186
1177
  assert_same_list([a1, a2], a.last(3))
1187
1178
 
1188
- ## three
1179
+ # three
1189
1180
  ret = a.last(3)
1190
1181
  a1, a2, a3 = 3.of{C::Int.new}
1191
1182
  a = _List[a1, a2, a3]
@@ -1196,15 +1187,13 @@ module NodeListArrayQueryTests
1196
1187
  assert_same_list([a1, a2, a3], a.last(3))
1197
1188
  assert_same_list([a1, a2, a3], a.last(4))
1198
1189
 
1199
- ## negative array size
1190
+ # negative array size
1200
1191
  assert_raise(ArgumentError){a.last(-1)}
1201
1192
  end
1202
1193
 
1203
- ###
1204
- ### ----------------------------------------------------------------
1205
- ### empty?
1206
- ### ----------------------------------------------------------------
1207
- ###
1194
+ # ------------------------------------------------------------------
1195
+ # empty?
1196
+ # ------------------------------------------------------------------
1208
1197
 
1209
1198
  def test_empty
1210
1199
  assert(_List[].empty?)
@@ -1212,104 +1201,100 @@ module NodeListArrayQueryTests
1212
1201
  assert(!_List[_List[]].empty?)
1213
1202
  end
1214
1203
 
1215
- ###
1216
- ### ----------------------------------------------------------------
1217
- ### to_a
1218
- ### ----------------------------------------------------------------
1219
- ###
1204
+ # ------------------------------------------------------------------
1205
+ # to_a
1206
+ # ------------------------------------------------------------------
1220
1207
 
1221
1208
  def test_to_a
1222
- ## empty
1209
+ # empty
1223
1210
  r = empty.to_a
1224
1211
  assert_same(::Array, r.class)
1225
1212
  assert_same_list([], r)
1226
1213
 
1227
- ## one
1228
- a = *one_els
1214
+ # one
1215
+ a, = *one_els
1229
1216
  r = one.to_a
1230
1217
  assert_same(::Array, r.class)
1231
1218
  assert_same_list([a], r)
1232
1219
 
1233
- ## two
1220
+ # two
1234
1221
  a, b = *two_els
1235
1222
  r = two.to_a
1236
1223
  assert_same(::Array, r.class)
1237
1224
  assert_same_list([a, b], r)
1238
1225
 
1239
- ## three
1226
+ # three
1240
1227
  a, b, c = *three_els
1241
1228
  r = three.to_a
1242
1229
  assert_same(::Array, r.class)
1243
1230
  assert_same_list([a, b, c], r)
1244
1231
 
1245
- ## four
1232
+ # four
1246
1233
  a, b, c, d = *four_els
1247
1234
  r = four.to_a
1248
1235
  assert_same(::Array, r.class)
1249
1236
  assert_same_list([a, b, c, d], r)
1250
1237
 
1251
- ## two_by_four
1238
+ # two_by_four
1252
1239
  l0, l1, l2, l3, a, b, c, d, e, f, g, h = *two_by_four_els
1253
1240
  r = two_by_four.to_a
1254
1241
  assert_same(::Array, r.class)
1255
1242
  assert_same_list([l0, l1, l2, l3], r)
1256
1243
 
1257
- ## big
1244
+ # big
1258
1245
  l1, l2, l21, l22, l23, l230, a, b, c, d, e = *big_els
1259
1246
  r = big.to_a
1260
1247
  assert_same(::Array, r.class)
1261
1248
  assert_same_list([a, l1, l2], r)
1262
1249
  end
1263
1250
 
1264
- ###
1265
- ### ----------------------------------------------------------------
1266
- ### index, rindex
1267
- ### ----------------------------------------------------------------
1268
- ###
1251
+ # ------------------------------------------------------------------
1252
+ # index, rindex
1253
+ # ------------------------------------------------------------------
1269
1254
 
1270
1255
  def test_index
1271
- ## empty
1256
+ # empty
1272
1257
  empty = _List[]
1273
1258
  assert_nil(empty.index(C::Int.new))
1274
1259
  assert_nil(empty.index(nil))
1275
- ##
1260
+ #
1276
1261
  assert_nil(empty.rindex(C::Int.new))
1277
1262
  assert_nil(empty.rindex(nil))
1278
1263
 
1279
- ## one
1264
+ # one
1280
1265
  a = C::Int.new(1)
1281
1266
  list = _List[a]
1282
- ##
1267
+ #
1283
1268
  assert_equal(0, list.index(a))
1284
1269
  assert_equal(0, list.index(C::Int.new(1)))
1285
1270
  assert_nil(list.index(C::Int.new))
1286
1271
  assert_nil(list.index(nil))
1287
- ##
1272
+ #
1288
1273
  assert_equal(0, list.rindex(a))
1289
1274
  assert_nil(list.rindex(C::Int.new))
1290
1275
  assert_nil(list.rindex(nil))
1291
1276
 
1292
- ## two
1277
+ # two
1293
1278
  a = C::Int.new(1)
1294
1279
  b = C::Int.new(2)
1295
1280
  list = _List[a, b]
1296
- ##
1281
+ #
1297
1282
  assert_equal(0, list.index(a))
1298
1283
  assert_equal(1, list.index(b))
1299
1284
  assert_nil(list.index(C::Int.new))
1300
1285
  assert_nil(list.index(nil))
1301
- ##
1286
+ #
1302
1287
  assert_equal(0, list.rindex(a))
1303
1288
  assert_equal(1, list.rindex(b))
1304
1289
  assert_nil(list.rindex(C::Int.new))
1305
1290
  assert_nil(list.rindex(nil))
1306
1291
 
1307
- ## nested -- [a, [b]]
1292
+ # nested -- [a, [b]]
1308
1293
  a = C::Int.new(1)
1309
1294
  b = C::Int.new(2)
1310
1295
  l1 = _List[b]
1311
1296
  list = _List[a, l1]
1312
- ##
1297
+ #
1313
1298
  assert_equal(0, list.index(a))
1314
1299
  assert_equal(1, list.index(l1))
1315
1300
  assert_equal(1, list.index(_List[C::Int.new(2)]))
@@ -1317,7 +1302,7 @@ module NodeListArrayQueryTests
1317
1302
  assert_nil(list.index([a]))
1318
1303
  assert_nil(list.index(C::Int.new))
1319
1304
  assert_nil(list.index(nil))
1320
- ##
1305
+ #
1321
1306
  assert_equal(0, list.rindex(a))
1322
1307
  assert_equal(1, list.rindex(l1))
1323
1308
  assert_equal(1, list.rindex(_List[b]))
@@ -1325,11 +1310,11 @@ module NodeListArrayQueryTests
1325
1310
  assert_nil(list.rindex(C::Int.new))
1326
1311
  assert_nil(list.rindex(nil))
1327
1312
 
1328
- ## repeated
1313
+ # repeated
1329
1314
  a1, a2, a3 = 3.of{C::Int.new(-1)}
1330
1315
  b1, b2, b3 = 3.of{C::Int.new(1)}
1331
1316
  list = _List[a1, b1, a2, b2, a3, b3]
1332
- ##
1317
+ #
1333
1318
  assert_equal(0, list.index(a1))
1334
1319
  assert_equal(0, list.index(a2))
1335
1320
  assert_equal(0, list.index(a3))
@@ -1338,7 +1323,7 @@ module NodeListArrayQueryTests
1338
1323
  assert_equal(1, list.index(b3))
1339
1324
  assert_nil(list.index(C::Int.new))
1340
1325
  assert_nil(list.index(nil))
1341
- ##
1326
+ #
1342
1327
  assert_equal(4, list.rindex(a1))
1343
1328
  assert_equal(4, list.rindex(a2))
1344
1329
  assert_equal(4, list.rindex(a3))
@@ -1349,26 +1334,24 @@ module NodeListArrayQueryTests
1349
1334
  assert_nil(list.rindex(nil))
1350
1335
  end
1351
1336
 
1352
- ###
1353
- ### ----------------------------------------------------------------
1354
- ### values_at
1355
- ### ----------------------------------------------------------------
1356
- ###
1337
+ # ------------------------------------------------------------------
1338
+ # values_at
1339
+ # ------------------------------------------------------------------
1357
1340
 
1358
1341
  def test_values_at
1359
- ## empty
1342
+ # empty
1360
1343
  assert_same_list([], empty.values_at())
1361
1344
  assert_same_list([nil], empty.values_at(1))
1362
1345
  assert_same_list([nil], empty.values_at(-1))
1363
1346
 
1364
- ## one
1365
- a = *one_els
1347
+ # one
1348
+ a, = *one_els
1366
1349
  assert_same_list([], one.values_at())
1367
1350
  assert_same_list([a], one.values_at(0))
1368
1351
  assert_same_list([a], one.values_at(-1))
1369
1352
  assert_same_list([nil, a], one.values_at(1, -1))
1370
1353
 
1371
- ## big -- [a, [b,c], [d, [e], [], [[]]]]
1354
+ # big -- [a, [b,c], [d, [e], [], [[]]]]
1372
1355
  l1, l2, l21, l22, l23, l230, a, b, c, d, e = *big_els
1373
1356
  assert_same_list([], big.values_at())
1374
1357
  assert_same_list([l2], big.values_at(-1))
@@ -1376,14 +1359,12 @@ module NodeListArrayQueryTests
1376
1359
  assert_same_list([a, l1, l2], big.values_at(0, -2, -1))
1377
1360
  end
1378
1361
 
1379
- ###
1380
- ### ----------------------------------------------------------------
1381
- ### join
1382
- ### ----------------------------------------------------------------
1383
- ###
1362
+ # ------------------------------------------------------------------
1363
+ # join
1364
+ # ------------------------------------------------------------------
1384
1365
 
1385
1366
  class N < C::Node
1386
- def initialize s
1367
+ def initialize(s)
1387
1368
  @s = s
1388
1369
  end
1389
1370
  def to_s
@@ -1391,25 +1372,25 @@ module NodeListArrayQueryTests
1391
1372
  end
1392
1373
  end
1393
1374
  def test_join
1394
- ## empty
1375
+ # empty
1395
1376
  list = _List[]
1396
1377
  assert_equal('', list.join)
1397
1378
  assert_equal('', list.join('.'))
1398
1379
 
1399
- ## one
1380
+ # one
1400
1381
  a = N.new('a')
1401
1382
  list = _List[a]
1402
1383
  assert_equal('a', list.join)
1403
1384
  assert_equal('a', list.join('.'))
1404
1385
 
1405
- ## two
1386
+ # two
1406
1387
  a = N.new('a')
1407
1388
  b = N.new('b')
1408
1389
  list = _List[a, b]
1409
1390
  assert_equal('ab', list.join)
1410
1391
  assert_equal('a.b', list.join('.'))
1411
1392
 
1412
- ## two_by_two
1393
+ # two_by_two
1413
1394
  a = N.new('a')
1414
1395
  b = N.new('b')
1415
1396
  c = N.new('c')
@@ -1425,24 +1406,24 @@ end
1425
1406
  module NodeListModifierTests
1426
1407
  include NodeListTest
1427
1408
  def test_push_none
1428
- ## empty
1409
+ # empty
1429
1410
  list = _List[]
1430
1411
  assert_same(list, list.push)
1431
1412
  assert_same_list([], list)
1432
1413
 
1433
- ## one
1414
+ # one
1434
1415
  a = C::Int.new
1435
1416
  list = _List[a]
1436
1417
  assert_same(list, list.push)
1437
1418
  assert_same_list([a], list)
1438
1419
 
1439
- ## two
1420
+ # two
1440
1421
  a, b = 2.of{C::Int.new}
1441
1422
  list = _List[a, b]
1442
1423
  assert_same(list, list.push)
1443
1424
  assert_same_list([a, b], list)
1444
1425
 
1445
- ## three
1426
+ # three
1446
1427
  a, b, c = 3.of{C::Int.new}
1447
1428
  list = _List[a, b, c]
1448
1429
  assert_same(list, list.push)
@@ -1450,25 +1431,25 @@ module NodeListModifierTests
1450
1431
  end
1451
1432
 
1452
1433
  def test_push_one
1453
- ## empty
1434
+ # empty
1454
1435
  a = C::Int.new
1455
1436
  list = _List[]
1456
1437
  assert_same(list, list.push(a))
1457
1438
  assert_same_list([a], list)
1458
1439
 
1459
- ## one
1440
+ # one
1460
1441
  a, b = 2.of{C::Int.new}
1461
1442
  list = _List[a]
1462
1443
  assert_same(list, list.push(b))
1463
1444
  assert_same_list([a, b], list)
1464
1445
 
1465
- ## two
1446
+ # two
1466
1447
  a, b, c = 3.of{C::Int.new}
1467
1448
  list = _List[a, b]
1468
1449
  assert_same(list, list.push(c))
1469
1450
  assert_same_list([a, b, c], list)
1470
1451
 
1471
- ## three
1452
+ # three
1472
1453
  a, b, c, d = 4.of{C::Int.new}
1473
1454
  list = _List[a, b, c]
1474
1455
  assert_same(list, list.push(d))
@@ -1476,25 +1457,25 @@ module NodeListModifierTests
1476
1457
  end
1477
1458
 
1478
1459
  def test_push_two
1479
- ## empty
1460
+ # empty
1480
1461
  a, b = 2.of{C::Int.new}
1481
1462
  list = _List[]
1482
1463
  assert_same(list, list.push(a, b))
1483
1464
  assert_same_list([a, b], list)
1484
1465
 
1485
- ## one
1466
+ # one
1486
1467
  a, b, c = 3.of{C::Int.new}
1487
1468
  list = _List[a]
1488
1469
  assert_same(list, list.push(b, c))
1489
1470
  assert_same_list([a, b, c], list)
1490
1471
 
1491
- ## two
1472
+ # two
1492
1473
  a, b, c, d = 4.of{C::Int.new}
1493
1474
  list = _List[a, b]
1494
1475
  assert_same(list, list.push(c, d))
1495
1476
  assert_same_list([a, b, c, d], list)
1496
1477
 
1497
- ## three
1478
+ # three
1498
1479
  a, b, c, d, e = 5.of{C::Int.new}
1499
1480
  list = _List[a, b, c]
1500
1481
  assert_same(list, list.push(d, e))
@@ -1502,25 +1483,25 @@ module NodeListModifierTests
1502
1483
  end
1503
1484
 
1504
1485
  def test_push_three
1505
- ## empty
1486
+ # empty
1506
1487
  a, b, c = 3.of{C::Int.new}
1507
1488
  list = _List[]
1508
1489
  assert_same(list, list.push(a, b, c))
1509
1490
  assert_same_list([a, b, c], list)
1510
1491
 
1511
- ## one
1492
+ # one
1512
1493
  a, b, c, d = 4.of{C::Int.new}
1513
1494
  list = _List[a]
1514
1495
  assert_same(list, list.push(b, c, d))
1515
1496
  assert_same_list([a, b, c, d], list)
1516
1497
 
1517
- ## two
1498
+ # two
1518
1499
  a, b, c, d, e = 5.of{C::Int.new}
1519
1500
  list = _List[a, b]
1520
1501
  assert_same(list, list.push(c, d, e))
1521
1502
  assert_same_list([a, b, c, d, e], list)
1522
1503
 
1523
- ## three
1504
+ # three
1524
1505
  a, b, c, d, e, f = 6.of{C::Int.new}
1525
1506
  list = _List[a, b, c]
1526
1507
  assert_same(list, list.push(d, e, f))
@@ -1528,7 +1509,7 @@ module NodeListModifierTests
1528
1509
  end
1529
1510
 
1530
1511
  def test_push_attached
1531
- ## one
1512
+ # one
1532
1513
  a1 = C::Int.new
1533
1514
  b1 = C::Int.new
1534
1515
  a = _List[a1]
@@ -1539,7 +1520,7 @@ module NodeListModifierTests
1539
1520
  assert_same(a1, a[0])
1540
1521
  assert_copy(b1, a[1])
1541
1522
 
1542
- ## many
1523
+ # many
1543
1524
  a1 = C::Int.new
1544
1525
  b1, b2, b3, b4 = 4.of{C::Int.new}
1545
1526
  a = _List[a1]
@@ -1555,24 +1536,24 @@ module NodeListModifierTests
1555
1536
  end
1556
1537
 
1557
1538
  def test_unshift_none
1558
- ## empty
1539
+ # empty
1559
1540
  list = _List[]
1560
1541
  assert_same(list, list.unshift)
1561
1542
  assert_same_list([], list)
1562
1543
 
1563
- ## one
1544
+ # one
1564
1545
  a = C::Int.new
1565
1546
  list = _List[a]
1566
1547
  assert_same(list, list.unshift)
1567
1548
  assert_same_list([a], list)
1568
1549
 
1569
- ## two
1550
+ # two
1570
1551
  a, b = 2.of{C::Int.new}
1571
1552
  list = _List[a, b]
1572
1553
  assert_same(list, list.unshift)
1573
1554
  assert_same_list([a, b], list)
1574
1555
 
1575
- ## three
1556
+ # three
1576
1557
  a, b, c = 3.of{C::Int.new}
1577
1558
  list = _List[a, b, c]
1578
1559
  assert_same(list, list.unshift)
@@ -1580,25 +1561,25 @@ module NodeListModifierTests
1580
1561
  end
1581
1562
 
1582
1563
  def test_unshift_one
1583
- ## empty
1564
+ # empty
1584
1565
  a = C::Int.new
1585
1566
  list = _List[]
1586
1567
  assert_same(list, list.unshift(a))
1587
1568
  assert_same_list([a], list)
1588
1569
 
1589
- ## one
1570
+ # one
1590
1571
  a, b = 2.of{C::Int.new}
1591
1572
  list = _List[a]
1592
1573
  assert_same(list, list.unshift(b))
1593
1574
  assert_same_list([b, a], list)
1594
1575
 
1595
- ## two
1576
+ # two
1596
1577
  a, b, c = 3.of{C::Int.new}
1597
1578
  list = _List[a, b]
1598
1579
  assert_same(list, list.unshift(c))
1599
1580
  assert_same_list([c, a, b], list)
1600
1581
 
1601
- ## three
1582
+ # three
1602
1583
  a, b, c, d = 4.of{C::Int.new}
1603
1584
  list = _List[a, b, c]
1604
1585
  assert_same(list, list.unshift(d))
@@ -1606,25 +1587,25 @@ module NodeListModifierTests
1606
1587
  end
1607
1588
 
1608
1589
  def test_unshift_two
1609
- ## empty
1590
+ # empty
1610
1591
  a, b = 2.of{C::Int.new}
1611
1592
  list = _List[]
1612
1593
  assert_same(list, list.unshift(a, b))
1613
1594
  assert_same_list([a, b], list)
1614
1595
 
1615
- ## one
1596
+ # one
1616
1597
  a, b, c = 3.of{C::Int.new}
1617
1598
  list = _List[a]
1618
1599
  assert_same(list, list.unshift(b, c))
1619
1600
  assert_same_list([b, c, a], list)
1620
1601
 
1621
- ## two
1602
+ # two
1622
1603
  a, b, c, d = 4.of{C::Int.new}
1623
1604
  list = _List[a, b]
1624
1605
  assert_same(list, list.unshift(c, d))
1625
1606
  assert_same_list([c, d, a, b], list)
1626
1607
 
1627
- ## three
1608
+ # three
1628
1609
  a, b, c, d, e = 5.of{C::Int.new}
1629
1610
  list = _List[a, b, c]
1630
1611
  assert_same(list, list.unshift(d, e))
@@ -1632,25 +1613,25 @@ module NodeListModifierTests
1632
1613
  end
1633
1614
 
1634
1615
  def test_unshift_three
1635
- ## empty
1616
+ # empty
1636
1617
  a, b, c = 3.of{C::Int.new}
1637
1618
  list = _List[]
1638
1619
  assert_same(list, list.unshift(a, b, c))
1639
1620
  assert_same_list([a, b, c], list)
1640
1621
 
1641
- ## one
1622
+ # one
1642
1623
  a, b, c, d = 4.of{C::Int.new}
1643
1624
  list = _List[a]
1644
1625
  assert_same(list, list.unshift(b, c, d))
1645
1626
  assert_same_list([b, c, d, a], list)
1646
1627
 
1647
- ## two
1628
+ # two
1648
1629
  a, b, c, d, e = 5.of{C::Int.new}
1649
1630
  list = _List[a, b]
1650
1631
  assert_same(list, list.unshift(c, d, e))
1651
1632
  assert_same_list([c, d, e, a, b], list)
1652
1633
 
1653
- ## three
1634
+ # three
1654
1635
  a, b, c, d, e, f = 6.of{C::Int.new}
1655
1636
  list = _List[a, b, c]
1656
1637
  assert_same(list, list.unshift(d, e, f))
@@ -1658,7 +1639,7 @@ module NodeListModifierTests
1658
1639
  end
1659
1640
 
1660
1641
  def test_unshift_attached
1661
- ## one
1642
+ # one
1662
1643
  a1 = C::Int.new
1663
1644
  b1 = C::Int.new
1664
1645
  a = _List[a1]
@@ -1669,7 +1650,7 @@ module NodeListModifierTests
1669
1650
  assert_copy(b1, a[0])
1670
1651
  assert_same(a1, a[1])
1671
1652
 
1672
- ## many
1653
+ # many
1673
1654
  a1 = C::Int.new
1674
1655
  b1, b2, b3, b4 = 4.of{C::Int.new}
1675
1656
  a = _List[a1]
@@ -1685,26 +1666,26 @@ module NodeListModifierTests
1685
1666
  end
1686
1667
 
1687
1668
  def test_pop
1688
- ## empty
1669
+ # empty
1689
1670
  list = _List[]
1690
1671
  assert_same(nil, list.pop)
1691
1672
  assert_same_list([], list)
1692
1673
 
1693
- ## one
1674
+ # one
1694
1675
  a = C::Int.new
1695
1676
  list = _List[a]
1696
1677
  assert_same(a, list.pop)
1697
1678
  assert_same_list([], list)
1698
1679
  assert_nil(a.parent)
1699
1680
 
1700
- ## two
1681
+ # two
1701
1682
  a, b = 2.of{C::Int.new}
1702
1683
  list = _List[a, b]
1703
1684
  assert_same(b, list.pop)
1704
1685
  assert_same_list([a], list)
1705
1686
  assert_nil(b.parent)
1706
1687
 
1707
- ## three
1688
+ # three
1708
1689
  a, b, c = 3.of{C::Int.new}
1709
1690
  list = _List[a, b, c]
1710
1691
  assert_same(c, list.pop)
@@ -1713,27 +1694,27 @@ module NodeListModifierTests
1713
1694
  end
1714
1695
 
1715
1696
  def test_pop_none
1716
- ## empty
1697
+ # empty
1717
1698
  list = _List[]
1718
1699
  ret = list.pop(0)
1719
1700
  assert_same_list([], ret)
1720
1701
  assert_same_list([], list)
1721
1702
 
1722
- ## one
1703
+ # one
1723
1704
  a = C::Int.new
1724
1705
  list = _List[a]
1725
1706
  ret = list.pop(0)
1726
1707
  assert_same_list([], ret)
1727
1708
  assert_same_list([a], list)
1728
1709
 
1729
- ## two
1710
+ # two
1730
1711
  a, b = 2.of{C::Int.new}
1731
1712
  list = _List[a, b]
1732
1713
  ret = list.pop(0)
1733
1714
  assert_same_list([], ret)
1734
1715
  assert_same_list([a, b], list)
1735
1716
 
1736
- ## three
1717
+ # three
1737
1718
  a, b, c = 3.of{C::Int.new}
1738
1719
  list = _List[a, b, c]
1739
1720
  ret = list.pop(0)
@@ -1742,13 +1723,13 @@ module NodeListModifierTests
1742
1723
  end
1743
1724
 
1744
1725
  def test_pop_one
1745
- ## empty
1726
+ # empty
1746
1727
  list = _List[]
1747
1728
  ret = list.pop(1)
1748
1729
  assert_same_list([], ret)
1749
1730
  assert_same_list([], list)
1750
1731
 
1751
- ## one
1732
+ # one
1752
1733
  a = C::Int.new
1753
1734
  list = _List[a]
1754
1735
  ret = list.pop(1)
@@ -1756,7 +1737,7 @@ module NodeListModifierTests
1756
1737
  assert_same_list([], list)
1757
1738
  assert_nil(a.parent)
1758
1739
 
1759
- ## two
1740
+ # two
1760
1741
  a, b = 2.of{C::Int.new}
1761
1742
  list = _List[a, b]
1762
1743
  ret = list.pop(1)
@@ -1764,7 +1745,7 @@ module NodeListModifierTests
1764
1745
  assert_same_list([a], list)
1765
1746
  assert_nil(b.parent)
1766
1747
 
1767
- ## three
1748
+ # three
1768
1749
  a, b, c = 3.of{C::Int.new}
1769
1750
  list = _List[a, b, c]
1770
1751
  ret = list.pop(1)
@@ -1774,13 +1755,13 @@ module NodeListModifierTests
1774
1755
  end
1775
1756
 
1776
1757
  def test_pop_two
1777
- ## empty
1758
+ # empty
1778
1759
  list = _List[]
1779
1760
  ret = list.pop(2)
1780
1761
  assert_same_list([], ret)
1781
1762
  assert_same_list([], list)
1782
1763
 
1783
- ## one
1764
+ # one
1784
1765
  a = C::Int.new
1785
1766
  list = _List[a]
1786
1767
  ret = list.pop(2)
@@ -1788,7 +1769,7 @@ module NodeListModifierTests
1788
1769
  assert_same_list([], list)
1789
1770
  assert_nil(a.parent)
1790
1771
 
1791
- ## two
1772
+ # two
1792
1773
  a, b = 2.of{C::Int.new}
1793
1774
  list = _List[a, b]
1794
1775
  ret = list.pop(2)
@@ -1797,7 +1778,7 @@ module NodeListModifierTests
1797
1778
  assert_nil(a.parent)
1798
1779
  assert_nil(b.parent)
1799
1780
 
1800
- ## three
1781
+ # three
1801
1782
  a, b, c = 3.of{C::Int.new}
1802
1783
  list = _List[a, b, c]
1803
1784
  ret = list.pop(2)
@@ -1808,7 +1789,7 @@ module NodeListModifierTests
1808
1789
  end
1809
1790
 
1810
1791
  def test_pop_bad
1811
- ## too many args
1792
+ # too many args
1812
1793
  a, b = 2.of{C::Int.new}
1813
1794
  list = _List[a, b]
1814
1795
  assert_raise(ArgumentError){list.pop(1, 2)}
@@ -1818,13 +1799,13 @@ module NodeListModifierTests
1818
1799
  end
1819
1800
 
1820
1801
  def test_shift
1821
- ## empty
1802
+ # empty
1822
1803
  list = _List[]
1823
1804
  ret = list.shift
1824
1805
  assert_nil(ret)
1825
1806
  assert_same_list([], list)
1826
1807
 
1827
- ## one
1808
+ # one
1828
1809
  a = C::Int.new
1829
1810
  list = _List[a]
1830
1811
  ret = list.shift
@@ -1832,7 +1813,7 @@ module NodeListModifierTests
1832
1813
  assert_same_list([], list)
1833
1814
  assert_nil(a.parent)
1834
1815
 
1835
- ## two
1816
+ # two
1836
1817
  a, b = 2.of{C::Int.new}
1837
1818
  list = _List[a, b]
1838
1819
  ret = list.shift
@@ -1840,7 +1821,7 @@ module NodeListModifierTests
1840
1821
  assert_same_list([b], list)
1841
1822
  assert_nil(a.parent)
1842
1823
 
1843
- ## three
1824
+ # three
1844
1825
  a, b, c = 3.of{C::Int.new}
1845
1826
  list = _List[a, b, c]
1846
1827
  ret = list.shift
@@ -1850,27 +1831,27 @@ module NodeListModifierTests
1850
1831
  end
1851
1832
 
1852
1833
  def test_shift_none
1853
- ## empty
1834
+ # empty
1854
1835
  list = _List[]
1855
1836
  ret = list.shift(0)
1856
1837
  assert_same_list([], ret)
1857
1838
  assert_same_list([], list)
1858
1839
 
1859
- ## one
1840
+ # one
1860
1841
  a = C::Int.new
1861
1842
  list = _List[a]
1862
1843
  ret = list.shift(0)
1863
1844
  assert_same_list([], ret)
1864
1845
  assert_same_list([a], list)
1865
1846
 
1866
- ## two
1847
+ # two
1867
1848
  a, b = 2.of{C::Int.new}
1868
1849
  list = _List[a, b]
1869
1850
  ret = list.shift(0)
1870
1851
  assert_same_list([], ret)
1871
1852
  assert_same_list([a, b], list)
1872
1853
 
1873
- ## three
1854
+ # three
1874
1855
  a, b, c = 3.of{C::Int.new}
1875
1856
  list = _List[a, b, c]
1876
1857
  ret = list.shift(0)
@@ -1879,13 +1860,13 @@ module NodeListModifierTests
1879
1860
  end
1880
1861
 
1881
1862
  def test_shift_one
1882
- ## empty
1863
+ # empty
1883
1864
  list = _List[]
1884
1865
  ret = list.shift(1)
1885
1866
  assert_same_list([], ret)
1886
1867
  assert_same_list([], list)
1887
1868
 
1888
- ## one
1869
+ # one
1889
1870
  a = C::Int.new
1890
1871
  list = _List[a]
1891
1872
  ret = list.shift(1)
@@ -1893,7 +1874,7 @@ module NodeListModifierTests
1893
1874
  assert_same_list([], list)
1894
1875
  assert_nil(a.parent)
1895
1876
 
1896
- ## two
1877
+ # two
1897
1878
  a, b = 2.of{C::Int.new}
1898
1879
  list = _List[a, b]
1899
1880
  ret = list.shift(1)
@@ -1901,7 +1882,7 @@ module NodeListModifierTests
1901
1882
  assert_same_list([b], list)
1902
1883
  assert_nil(a.parent)
1903
1884
 
1904
- ## three
1885
+ # three
1905
1886
  a, b, c = 3.of{C::Int.new}
1906
1887
  list = _List[a, b, c]
1907
1888
  ret = list.shift(1)
@@ -1911,13 +1892,13 @@ module NodeListModifierTests
1911
1892
  end
1912
1893
 
1913
1894
  def test_shift_two
1914
- ## empty
1895
+ # empty
1915
1896
  list = _List[]
1916
1897
  ret = list.shift(2)
1917
1898
  assert_same_list([], ret)
1918
1899
  assert_same_list([], list)
1919
1900
 
1920
- ## one
1901
+ # one
1921
1902
  a = C::Int.new
1922
1903
  list = _List[a]
1923
1904
  ret = list.shift(2)
@@ -1925,7 +1906,7 @@ module NodeListModifierTests
1925
1906
  assert_same_list([], list)
1926
1907
  assert_nil(a.parent)
1927
1908
 
1928
- ## two
1909
+ # two
1929
1910
  a, b = 2.of{C::Int.new}
1930
1911
  list = _List[a, b]
1931
1912
  ret = list.shift(2)
@@ -1934,7 +1915,7 @@ module NodeListModifierTests
1934
1915
  assert_nil(a.parent)
1935
1916
  assert_nil(b.parent)
1936
1917
 
1937
- ## three
1918
+ # three
1938
1919
  a, b, c = 3.of{C::Int.new}
1939
1920
  list = _List[a, b, c]
1940
1921
  ret = list.shift(2)
@@ -1945,7 +1926,7 @@ module NodeListModifierTests
1945
1926
  end
1946
1927
 
1947
1928
  def test_shift_bad
1948
- ## too many args
1929
+ # too many args
1949
1930
  a, b = 2.of{C::Int.new}
1950
1931
  list = _List[a, b]
1951
1932
  assert_raise(ArgumentError){list.shift(1, 2)}
@@ -1954,11 +1935,9 @@ module NodeListModifierTests
1954
1935
  assert_same(list, b.parent)
1955
1936
  end
1956
1937
 
1957
- ###
1958
- ### ----------------------------------------------------------------
1959
- ### insert
1960
- ### ----------------------------------------------------------------
1961
- ###
1938
+ # ------------------------------------------------------------------
1939
+ # insert
1940
+ # ------------------------------------------------------------------
1962
1941
 
1963
1942
  def test_insert_one_into_one
1964
1943
  a1, a2 = 2.of{C::Int.new}
@@ -1966,11 +1945,11 @@ module NodeListModifierTests
1966
1945
  a = _List[a1]
1967
1946
  b = _List[b1]
1968
1947
 
1969
- ## beginning
1948
+ # beginning
1970
1949
  a.insert(0, a2)
1971
1950
  assert_same_list([a2, a1], a)
1972
1951
 
1973
- ## end
1952
+ # end
1974
1953
  b.insert(1, b2)
1975
1954
  assert_same_list([b1, b2], b)
1976
1955
  end
@@ -1981,11 +1960,11 @@ module NodeListModifierTests
1981
1960
  a = _List[a1]
1982
1961
  b = _List[b1]
1983
1962
 
1984
- ## beginning
1963
+ # beginning
1985
1964
  a.insert(0, a2, a3)
1986
1965
  assert_same_list([a2, a3, a1], a)
1987
1966
 
1988
- ## end
1967
+ # end
1989
1968
  b.insert(1, b2, b3)
1990
1969
  assert_same_list([b1, b2, b3], b)
1991
1970
  end
@@ -1996,11 +1975,11 @@ module NodeListModifierTests
1996
1975
  a = _List[a1]
1997
1976
  b = _List[b1]
1998
1977
 
1999
- ## beginning
1978
+ # beginning
2000
1979
  a.insert(0, a2, a3, a4)
2001
1980
  assert_same_list([a2, a3, a4, a1], a)
2002
1981
 
2003
- ## end
1982
+ # end
2004
1983
  b.insert(1, b2, b3, b4)
2005
1984
  assert_same_list([b1, b2, b3, b4], b)
2006
1985
  end
@@ -2011,16 +1990,16 @@ module NodeListModifierTests
2011
1990
  a = _List[a1]
2012
1991
  b = _List[b1]
2013
1992
 
2014
- ## beginning
1993
+ # beginning
2015
1994
  a.insert(0, a2, a3, a4, a5)
2016
1995
  assert_same_list([a2, a3, a4, a5, a1], a)
2017
1996
 
2018
- ## end
1997
+ # end
2019
1998
  b.insert(1, b2, b3, b4, b5)
2020
1999
  assert_same_list([b1, b2, b3, b4, b5], b)
2021
2000
  end
2022
2001
 
2023
- def insert_one_into_two
2002
+ def test_insert_one_into_two
2024
2003
  a1, a2, a3 = 3.of{C::Int.new}
2025
2004
  b1, b2, b3 = 3.of{C::Int.new}
2026
2005
  c1, c2, c3 = 3.of{C::Int.new}
@@ -2028,16 +2007,16 @@ module NodeListModifierTests
2028
2007
  b = _List[b1, b2]
2029
2008
  c = _List[c1, c2]
2030
2009
 
2031
- ## beginning
2010
+ # beginning
2032
2011
  a.insert(0, a3)
2033
2012
  assert_same_list([a3, a1, a2], a)
2034
2013
 
2035
- ## end
2014
+ # end
2036
2015
  b.insert(2, b3)
2037
2016
  assert_same_list([b1, b2, b3], b)
2038
2017
 
2039
- ## middle
2040
- c.insert1(c1, c3)
2018
+ # middle
2019
+ c.insert(1, c3)
2041
2020
  assert_same_list([c1, c3, c2], c)
2042
2021
  end
2043
2022
 
@@ -2050,15 +2029,15 @@ module NodeListModifierTests
2050
2029
  b = _List[b1, b2]
2051
2030
  c = _List[c1, c2]
2052
2031
 
2053
- ## beginning
2032
+ # beginning
2054
2033
  a.insert(0, a3, a4)
2055
2034
  assert_same_list([a3, a4, a1, a2], a)
2056
2035
 
2057
- ## end
2036
+ # end
2058
2037
  b.insert(2, b3, b4)
2059
2038
  assert_same_list([b1, b2, b3, b4], b)
2060
2039
 
2061
- ## middle
2040
+ # middle
2062
2041
  c.insert(1, c3, c4)
2063
2042
  assert_same_list([c1, c3, c4, c2], c)
2064
2043
  end
@@ -2071,15 +2050,15 @@ module NodeListModifierTests
2071
2050
  b = _List[b1, b2]
2072
2051
  c = _List[c1, c2]
2073
2052
 
2074
- ## beginning
2053
+ # beginning
2075
2054
  a.insert(0, a3, a4, a5)
2076
2055
  assert_same_list([a3, a4, a5, a1, a2], a)
2077
2056
 
2078
- ## end
2057
+ # end
2079
2058
  b.insert(2, b3, b4, b5)
2080
2059
  assert_same_list([b1, b2, b3, b4, b5], b)
2081
2060
 
2082
- ## middle
2061
+ # middle
2083
2062
  c.insert(1, c3, c4, c5)
2084
2063
  assert_same_list([c1, c3, c4, c5, c2], c)
2085
2064
  end
@@ -2092,21 +2071,21 @@ module NodeListModifierTests
2092
2071
  b = _List[b1, b2]
2093
2072
  c = _List[c1, c2]
2094
2073
 
2095
- ## beginning
2074
+ # beginning
2096
2075
  a.insert(0, a3, a4, a5, a6)
2097
2076
  assert_same_list([a3, a4, a5, a6, a1, a2], a)
2098
2077
 
2099
- ## end
2078
+ # end
2100
2079
  b.insert(2, b3, b4, b5, b6)
2101
2080
  assert_same_list([b1, b2, b3, b4, b5, b6], b)
2102
2081
 
2103
- ## middle (after)
2082
+ # middle (after)
2104
2083
  c.insert(1, c3, c4, c5, c6)
2105
2084
  assert_same_list([c1, c3, c4, c5, c6, c2], c)
2106
2085
  end
2107
2086
 
2108
2087
  def test_insert_attached
2109
- ## one
2088
+ # one
2110
2089
  a1 = C::Int.new
2111
2090
  b1 = C::Int.new
2112
2091
  a = _List[a1]
@@ -2116,7 +2095,7 @@ module NodeListModifierTests
2116
2095
  assert_same(a1, a[0])
2117
2096
  assert_copy(b1, a[1])
2118
2097
 
2119
- ## many
2098
+ # many
2120
2099
  a1 = C::Int.new
2121
2100
  b1, b2, b3, b4 = 4.of{C::Int.new}
2122
2101
  a = _List[a1]
@@ -2130,11 +2109,9 @@ module NodeListModifierTests
2130
2109
  assert_same(a1, a[4])
2131
2110
  end
2132
2111
 
2133
- ###
2134
- ### ----------------------------------------------------------------
2135
- ### concat
2136
- ### ----------------------------------------------------------------
2137
- ###
2112
+ # ------------------------------------------------------------------
2113
+ # concat
2114
+ # ------------------------------------------------------------------
2138
2115
 
2139
2116
  def test_concat_zero_on_zero
2140
2117
  a = _List[]
@@ -2173,7 +2150,7 @@ module NodeListModifierTests
2173
2150
 
2174
2151
  assert_same(a, a.concat(b))
2175
2152
  assert_same_list([b1], b)
2176
- ##
2153
+ #
2177
2154
  assert_equal(1, a.length)
2178
2155
  assert_copy(b1, a[0])
2179
2156
  end
@@ -2186,7 +2163,7 @@ module NodeListModifierTests
2186
2163
 
2187
2164
  assert_same(a, a.concat(b))
2188
2165
  assert_same_list([b1], b)
2189
- ##
2166
+ #
2190
2167
  assert_equal(2, a.length)
2191
2168
  assert_same(a1, a[0])
2192
2169
  assert_copy(b1, a[1])
@@ -2200,7 +2177,7 @@ module NodeListModifierTests
2200
2177
 
2201
2178
  assert_same(a, a.concat(b))
2202
2179
  assert_same_list([b1], b)
2203
- ##
2180
+ #
2204
2181
  assert_equal(3, a.length)
2205
2182
  assert_same(a1, a[0])
2206
2183
  assert_same(a2, a[1])
@@ -2214,7 +2191,7 @@ module NodeListModifierTests
2214
2191
 
2215
2192
  assert_same(a, a.concat(b))
2216
2193
  assert_same_list([b1, b2], b)
2217
- ##
2194
+ #
2218
2195
  assert_equal(2, a.length)
2219
2196
  assert_copy(b1, a[0])
2220
2197
  assert_copy(b2, a[1])
@@ -2228,7 +2205,7 @@ module NodeListModifierTests
2228
2205
 
2229
2206
  assert_same(a, a.concat(b))
2230
2207
  assert_same_list([b1, b2], b)
2231
- ##
2208
+ #
2232
2209
  assert_equal(3, a.length)
2233
2210
  assert_same(a1, a[0])
2234
2211
  assert_copy(b1, a[1])
@@ -2243,7 +2220,7 @@ module NodeListModifierTests
2243
2220
 
2244
2221
  assert_same(a, a.concat(b))
2245
2222
  assert_same_list([b1, b2], b)
2246
- ##
2223
+ #
2247
2224
  assert_equal(4, a.length)
2248
2225
  assert_same(a1, a[0])
2249
2226
  assert_same(a2, a[1])
@@ -2251,11 +2228,9 @@ module NodeListModifierTests
2251
2228
  assert_copy(b2, a[3])
2252
2229
  end
2253
2230
 
2254
- ###
2255
- ### ----------------------------------------------------------------
2256
- ### delete_at
2257
- ### ----------------------------------------------------------------
2258
- ###
2231
+ # ------------------------------------------------------------------
2232
+ # delete_at
2233
+ # ------------------------------------------------------------------
2259
2234
 
2260
2235
  def test_delete_at_one
2261
2236
  a1 = C::Int.new
@@ -2267,14 +2242,14 @@ module NodeListModifierTests
2267
2242
  end
2268
2243
 
2269
2244
  def test_delete_at_two
2270
- ## delete_at 0
2245
+ # delete_at 0
2271
2246
  a1, a2 = 2.of{C::Int.new}
2272
2247
  a = _List[a1, a2]
2273
2248
  assert_same(a1, a.delete_at(0))
2274
2249
  assert_nil(a1.parent)
2275
2250
  assert_same_list([a2], a)
2276
2251
 
2277
- ## delete_at 1
2252
+ # delete_at 1
2278
2253
  a1, a2 = 2.of{C::Int.new}
2279
2254
  a = _List[a1, a2]
2280
2255
  assert_same(a2, a.delete_at(1))
@@ -2283,21 +2258,21 @@ module NodeListModifierTests
2283
2258
  end
2284
2259
 
2285
2260
  def test_delete_at_three
2286
- ## delete at 0
2261
+ # delete at 0
2287
2262
  a1, a2, a3 = 3.of{C::Int.new}
2288
2263
  a = _List[a1, a2, a3]
2289
2264
  assert_same(a1, a.delete_at(0))
2290
2265
  assert_nil(a1.parent)
2291
2266
  assert_same_list([a2, a3], a)
2292
2267
 
2293
- ## delete at 1
2268
+ # delete at 1
2294
2269
  a1, a2, a3 = 3.of{C::Int.new}
2295
2270
  a = _List[a1, a2, a3]
2296
2271
  assert_same(a2, a.delete_at(1))
2297
2272
  assert_nil(a2.parent)
2298
2273
  assert_same_list([a1, a3], a)
2299
2274
 
2300
- ## delete at 2
2275
+ # delete at 2
2301
2276
  a1, a2, a3 = 3.of{C::Int.new}
2302
2277
  a = _List[a1, a2, a3]
2303
2278
  assert_same(a3, a.delete_at(2))
@@ -2306,7 +2281,7 @@ module NodeListModifierTests
2306
2281
  end
2307
2282
 
2308
2283
  def test_delete_at_four
2309
- ## delete at 1
2284
+ # delete at 1
2310
2285
  a1, a2, a3, a4 = 4.of{C::Int.new}
2311
2286
  a = _List[a1, a2, a3, a4]
2312
2287
  assert_same(a2, a.delete_at(1))
@@ -2314,11 +2289,9 @@ module NodeListModifierTests
2314
2289
  assert_same_list([a1, a3, a4], a)
2315
2290
  end
2316
2291
 
2317
- ###
2318
- ### ----------------------------------------------------------------
2319
- ### clear
2320
- ### ----------------------------------------------------------------
2321
- ###
2292
+ # ------------------------------------------------------------------
2293
+ # clear
2294
+ # ------------------------------------------------------------------
2322
2295
 
2323
2296
  def test_clear_empty
2324
2297
  assert_same(empty, empty.clear)
@@ -2358,11 +2331,9 @@ module NodeListModifierTests
2358
2331
  assert_nil(l2.parent)
2359
2332
  end
2360
2333
 
2361
- ###
2362
- ### ----------------------------------------------------------------
2363
- ### replace
2364
- ### ----------------------------------------------------------------
2365
- ###
2334
+ # ------------------------------------------------------------------
2335
+ # replace
2336
+ # ------------------------------------------------------------------
2366
2337
 
2367
2338
  def test_replace_none_with_none
2368
2339
  a = _List[]
@@ -2458,7 +2429,7 @@ module NodeListModifierTests
2458
2429
  end
2459
2430
 
2460
2431
  def test_replace_with_attached
2461
- ## one
2432
+ # one
2462
2433
  a1 = C::Int.new
2463
2434
  a = _List[a1]
2464
2435
  b1 = C::Int.new
@@ -2468,7 +2439,7 @@ module NodeListModifierTests
2468
2439
  assert_equal(1, a.length)
2469
2440
  assert_copy(b1, a[0])
2470
2441
 
2471
- ## many
2442
+ # many
2472
2443
  a1 = C::Int.new
2473
2444
  a = _List[a1]
2474
2445
  b1, b2, b3, b4 = 4.of{C::Int.new}
@@ -2483,7 +2454,7 @@ module NodeListModifierTests
2483
2454
  end
2484
2455
  end
2485
2456
 
2486
- ## Make concrete test classes.
2457
+ # Make concrete test classes.
2487
2458
  NodeListTest.submodules.each do |test_module|
2488
2459
  test_module.name =~ /^NodeList/ or
2489
2460
  raise "NodeListTest submodule name does not start with 'NodeList': #{test_module.name}"