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,16 +1,16 @@
1
- ###
2
- ### ##################################################################
3
- ###
4
- ### Tests for Node core functionality.
5
- ###
6
- ### ##################################################################
7
- ###
1
+ ######################################################################
2
+ #
3
+ # Tests for Node core functionality.
4
+ #
5
+ ######################################################################
6
+
7
+ require 'test/test_helper'
8
8
 
9
9
  Chain = C::NodeChain
10
10
 
11
- ###
12
- ### Some Node classes.
13
- ###
11
+ #
12
+ # Some Node classes.
13
+ #
14
14
  class X < C::Node
15
15
  child :a
16
16
  initializer :a
@@ -39,11 +39,10 @@ class V < C::Node
39
39
  end
40
40
 
41
41
  class NodeInitializeTest < Test::Unit::TestCase
42
- ###
43
- ### ----------------------------------------------------------------
44
- ### initialize
45
- ### ----------------------------------------------------------------
46
- ###
42
+
43
+ # ------------------------------------------------------------------
44
+ # initialize
45
+ # ------------------------------------------------------------------
47
46
 
48
47
  def test_initialize_w
49
48
  w = W.new
@@ -82,11 +81,10 @@ class NodeInitializeTest < Test::Unit::TestCase
82
81
  assert_same(x2, z.b)
83
82
  end
84
83
 
85
- ###
86
- ### ----------------------------------------------------------------
87
- ### Node.new_at
88
- ### ----------------------------------------------------------------
89
- ###
84
+ # ------------------------------------------------------------------
85
+ # Node.new_at
86
+ # ------------------------------------------------------------------
87
+
90
88
  def test_new_at
91
89
  pos = C::Node::Pos.new('somefile', 5, 10)
92
90
  xa = X.new
@@ -124,17 +122,16 @@ class NodeEqualTest < Test::Unit::TestCase
124
122
  return c
125
123
  end
126
124
 
127
- ###
128
- ### ----------------------------------------------------------------
129
- ### ==, eql?
130
- ### ----------------------------------------------------------------
131
- ###
125
+ # ------------------------------------------------------------------
126
+ # ==, eql?
127
+ # ------------------------------------------------------------------
128
+
132
129
  def test_eq
133
- ## copy should be equal
130
+ # copy should be equal
134
131
  assert_equal(node, node)
135
132
  assert(node.eql?(node))
136
133
 
137
- ## change any one field and it should be not_equal
134
+ # change any one field and it should be not_equal
138
135
  n = node
139
136
  n.type = nil
140
137
  assert_not_equal(node, n)
@@ -151,32 +148,32 @@ class NodeEqualTest < Test::Unit::TestCase
151
148
  assert_not_equal(node, n)
152
149
  assert(!node.eql?(n))
153
150
 
154
- ## add a member's init and it should be not_equal
151
+ # add a member's init and it should be not_equal
155
152
  n = node
156
153
  n.member_inits[3].init = C::IntLiteral.new(9)
157
154
  assert_not_equal(node, n)
158
155
  assert(!node.eql?(n))
159
156
 
160
- ## change a member's init and it should be not_equal
157
+ # change a member's init and it should be not_equal
161
158
  n = node
162
159
  n.member_inits[0].init = C::IntLiteral.new(10)
163
160
  assert_not_equal(node, n)
164
161
  assert(!node.eql?(n))
165
162
 
166
- ## add a member specifier and it should be not_equal
163
+ # add a member specifier and it should be not_equal
167
164
  n = node
168
165
  n.member_inits[3].member = Chain[C::Member.new('d')]
169
166
  assert_not_equal(node, n)
170
167
  assert(!node.eql?(n))
171
168
 
172
- ## pop a member and it should be not_equal
169
+ # pop a member and it should be not_equal
173
170
  n = node
174
171
  n.member_inits.pop
175
172
  assert_not_equal(node, n)
176
173
  assert(!node.eql?(n))
177
174
 
178
- ## assign a field a copy of what's there and it should still be
179
- ## equal
175
+ # assign a field a copy of what's there and it should still be
176
+ # equal
180
177
  n = node
181
178
  n.member_inits[0].member[0] = C::Member.new('a')
182
179
  assert_equal(node, n)
@@ -188,17 +185,16 @@ class NodeEqualTest < Test::Unit::TestCase
188
185
  assert(node.eql?(n))
189
186
  end
190
187
 
191
- ###
192
- ### ----------------------------------------------------------------
193
- ### hash
194
- ### ----------------------------------------------------------------
195
- ###
188
+ # ------------------------------------------------------------------
189
+ # hash
190
+ # ------------------------------------------------------------------
191
+
196
192
  def test_hash
197
- ## copy should be equal
193
+ # copy should be equal
198
194
  assert_equal(node.hash, node.hash)
199
195
 
200
- ## should be equal after assigning to a field a copy of what's
201
- ## there
196
+ # should be equal after assigning to a field a copy of what's
197
+ # there
202
198
  n = node
203
199
  n.member_inits[0].member[0] = C::Member.new('a')
204
200
  assert_equal(node.hash, n.hash)
@@ -211,9 +207,7 @@ end
211
207
 
212
208
  class NodeCopyTest < Test::Unit::TestCase
213
209
  def setup
214
- ## (struct s){.a = 1, [2] = {3, 4}, .b [5] = 6, 7}
215
-
216
-
210
+ # (struct s){.a = 1, [2] = {3, 4}, .b [5] = 6, 7}
217
211
 
218
212
  @c_t_n = 's'
219
213
  @c_t = C::Struct.new(@c_t_n)
@@ -263,11 +257,10 @@ class NodeCopyTest < Test::Unit::TestCase
263
257
  end
264
258
  attr_accessor :c, :d, :e
265
259
 
266
- ###
267
- ### ----------------------------------------------------------------
268
- ### dup, clone
269
- ### ----------------------------------------------------------------
270
- ###
260
+ # ------------------------------------------------------------------
261
+ # dup, clone
262
+ # ------------------------------------------------------------------
263
+
271
264
  def check_node value
272
265
  cres = yield(c)
273
266
  dres = yield(d)
@@ -290,10 +283,10 @@ class NodeCopyTest < Test::Unit::TestCase
290
283
  end
291
284
 
292
285
  def test_copy
293
- ## each element should be equal, but not the same, except for
294
- ## immediate values
295
- ##
296
- ## (struct s){.a = 1, [2] = {3, 4}, .b [5] = 6, 7}
286
+ # each element should be equal, but not the same, except for
287
+ # immediate values
288
+ #
289
+ # (struct s){.a = 1, [2] = {3, 4}, .b [5] = 6, 7}
297
290
  assert_tree(c)
298
291
  assert_tree(d)
299
292
  assert_tree(e)
@@ -339,13 +332,13 @@ class NodeCopyTest < Test::Unit::TestCase
339
332
  end
340
333
 
341
334
  class NodeWalkTest < Test::Unit::TestCase
342
- ###
343
- ### Collect and return the args yielded to `node.send(method)' as an
344
- ### Array, each element of which is an array of args yielded.
345
- ###
346
- ### Also, assert that the return value of the method is `exp'.
347
- ###
348
- def yields method, node, exp
335
+ #
336
+ # Collect and return the args yielded to `node.send(method)' as an
337
+ # Array, each element of which is an array of args yielded.
338
+ #
339
+ # Also, assert that the return value of the method is `exp'.
340
+ #
341
+ def yields(method, node, exp)
349
342
  ret = []
350
343
  out = node.send(method) do |*args|
351
344
  ret << args
@@ -355,18 +348,18 @@ class NodeWalkTest < Test::Unit::TestCase
355
348
  return ret
356
349
  end
357
350
 
358
- ###
359
- ### Assert exp and out are equal, where elements are compared with
360
- ### Array#same_list?. That is, exp[i].same_list?(out[i]) for all i.
361
- ###
362
- def assert_equal_yields exp, out
351
+ #
352
+ # Assert exp and out are equal, where elements are compared with
353
+ # Array#same_list?. That is, exp[i].same_list?(out[i]) for all i.
354
+ #
355
+ def assert_equal_yields(exp, out)
363
356
  if exp.zip(out).all?{|a,b| a.same_list?(b)}
364
357
  assert(true)
365
358
  else
366
359
  flunk("walk not equal: #{walk_str(out)} (expected #{walk_str(exp)})")
367
360
  end
368
361
  end
369
- def walk_str walk
362
+ def walk_str(walk)
370
363
  walk.is_a? ::Array or
371
364
  raise "walk_str: expected ::Array"
372
365
  if walk.empty?
@@ -394,17 +387,16 @@ class NodeWalkTest < Test::Unit::TestCase
394
387
  end
395
388
  end
396
389
 
397
- ###
398
- ### ----------------------------------------------------------------
399
- ### depth_first, reverse_depth_first
400
- ### ----------------------------------------------------------------
401
- ###
402
- def check_depth_firsts node, exp
403
- ## depth_first
390
+ # ------------------------------------------------------------------
391
+ # depth_first, reverse_depth_first
392
+ # ------------------------------------------------------------------
393
+
394
+ def check_depth_firsts(node, exp)
395
+ # depth_first
404
396
  out = yields(:depth_first, node, node)
405
397
  assert_equal_yields exp, out
406
398
 
407
- ## reverse_depth_first
399
+ # reverse_depth_first
408
400
  exp = exp.reverse.map! do |ev, node|
409
401
  if ev == :ascending
410
402
  [:descending, node]
@@ -417,13 +409,13 @@ class NodeWalkTest < Test::Unit::TestCase
417
409
  end
418
410
 
419
411
  def test_depth_first
420
- ## empty node
412
+ # empty node
421
413
  d = C::Int.new
422
414
  d.longness = 1
423
415
  check_depth_firsts(d,
424
416
  [[:descending, d], [:ascending, d]])
425
417
 
426
- ## one-storey -- populate both the list child and nonlist child
418
+ # one-storey -- populate both the list child and nonlist child
427
419
  d = C::Declaration.new(C::Int.new)
428
420
  d.declarators << C::Declarator.new
429
421
  d.declarators[0].name = 'one'
@@ -440,7 +432,7 @@ class NodeWalkTest < Test::Unit::TestCase
440
432
  [:ascending, d]
441
433
  ])
442
434
 
443
- ## multi-layer
435
+ # multi-layer
444
436
  d.declarators[0].indirect_type = C::Function.new
445
437
  d.declarators[0].indirect_type.params = Chain[]
446
438
  d.declarators[0].indirect_type.params << C::Parameter.new(C::Int.new, 'i')
@@ -468,8 +460,8 @@ class NodeWalkTest < Test::Unit::TestCase
468
460
  ])
469
461
  end
470
462
 
471
- def check_depth_first_prunes pruned_nodes, node, exp
472
- ## depth_first
463
+ def check_depth_first_prunes(pruned_nodes, node, exp)
464
+ # depth_first
473
465
  out = yields(:depth_first, node, node) do |ev, node|
474
466
  if ev.equal? :descending
475
467
  if pruned_nodes.any?{|n| n.equal? node}
@@ -478,7 +470,7 @@ class NodeWalkTest < Test::Unit::TestCase
478
470
  end
479
471
  end
480
472
  assert_equal_yields exp, out
481
- ##
473
+ #
482
474
  ret = catch :prune do
483
475
  node.depth_first do |ev, node|
484
476
  throw :prune, :x if ev.equal? :ascending
@@ -487,7 +479,7 @@ class NodeWalkTest < Test::Unit::TestCase
487
479
  end
488
480
  assert_same(:x, ret)
489
481
 
490
- ## reverse_depth_first
482
+ # reverse_depth_first
491
483
  exp = exp.reverse.map! do |ev, node|
492
484
  if ev.equal? :ascending
493
485
  [:descending, node]
@@ -503,7 +495,7 @@ class NodeWalkTest < Test::Unit::TestCase
503
495
  end
504
496
  end
505
497
  assert_equal_yields exp, out
506
- ##
498
+ #
507
499
  ret = catch :prune do
508
500
  node.reverse_depth_first do |ev, node|
509
501
  throw :prune, :x if ev.equal? :ascending
@@ -514,13 +506,13 @@ class NodeWalkTest < Test::Unit::TestCase
514
506
  end
515
507
 
516
508
  def test_depth_first_prune
517
- ## empty node
509
+ # empty node
518
510
  d = C::Int.new
519
511
  d.longness = 1
520
512
  check_depth_first_prunes([d], d,
521
513
  [[:descending, d], [:ascending, d]])
522
514
 
523
- ## one-storey -- populate both the list child and nonlist child
515
+ # one-storey -- populate both the list child and nonlist child
524
516
  d = C::Declaration.new(C::Int.new)
525
517
  d.declarators << C::Declarator.new
526
518
  d.declarators[0].name = 'one'
@@ -534,7 +526,7 @@ class NodeWalkTest < Test::Unit::TestCase
534
526
  [:ascending, d]
535
527
  ])
536
528
 
537
- ## multi-layer
529
+ # multi-layer
538
530
  d.type = C::Struct.new('S')
539
531
  d.type.members = Chain[]
540
532
  d.type.members << C::Declaration.new(C::Int.new)
@@ -557,13 +549,11 @@ class NodeWalkTest < Test::Unit::TestCase
557
549
  ])
558
550
  end
559
551
 
560
- ###
561
- ### ----------------------------------------------------------------
562
- ### each, reverse_each
563
- ### ----------------------------------------------------------------
564
- ###
552
+ # ------------------------------------------------------------------
553
+ # each, reverse_each
554
+ # ------------------------------------------------------------------
565
555
 
566
- def iter_str iter
556
+ def iter_str(iter)
567
557
  iter.is_a? ::Array or
568
558
  raise "iter_str: expected ::Array"
569
559
  if iter.empty?
@@ -582,7 +572,7 @@ class NodeWalkTest < Test::Unit::TestCase
582
572
  return s.string
583
573
  end
584
574
  end
585
- def check_each node, exp
575
+ def check_each(node, exp)
586
576
  exp.map!{|n| [n]}
587
577
 
588
578
  out = yields(:each, node, node)
@@ -593,34 +583,31 @@ class NodeWalkTest < Test::Unit::TestCase
593
583
  assert_equal_yields exp, out
594
584
  end
595
585
  def test_each
596
- ## empty
586
+ # empty
597
587
  parent = X.new
598
588
  check_each(parent, [])
599
589
 
600
- ## one child
590
+ # one child
601
591
  x1 = X.new
602
592
  parent = X.new(x1)
603
593
  check_each(parent, [x1])
604
594
 
605
- ## two children
595
+ # two children
606
596
  x1, x2 = 2.of{X.new}
607
597
  parent = Y.new(x1, x2)
608
598
  check_each(parent, [x1, x2])
609
599
 
610
- ## three with some nil and some fields
600
+ # three with some nil and some fields
611
601
  x1, x2, x3, x4, x5 = 5.of{X.new}
612
602
  parent = Z.new(x1, x2, nil, x4, x5)
613
603
  check_each(parent, [x1, x5])
614
604
  end
615
605
 
616
- ###
617
- ### ----------------------------------------------------------------
618
- ### preorder, reverse_preorder
619
- ### postorder, reverse_postorder
620
- ### ----------------------------------------------------------------
621
- ###
606
+ # ------------------------------------------------------------------
607
+ # preorder, reverse_preorder, postorder, reverse_postorder
608
+ # ------------------------------------------------------------------
622
609
 
623
- def check_preorder node, exp
610
+ def check_preorder(node, exp)
624
611
  exp.map!{|n| [n]}
625
612
 
626
613
  out = yields(:preorder, node, node)
@@ -630,7 +617,7 @@ class NodeWalkTest < Test::Unit::TestCase
630
617
  exp.reverse!
631
618
  assert_equal_yields exp, out
632
619
  end
633
- def check_postorder node, exp
620
+ def check_postorder(node, exp)
634
621
  exp.map!{|n| [n]}
635
622
 
636
623
  out = yields(:postorder, node, node)
@@ -641,12 +628,12 @@ class NodeWalkTest < Test::Unit::TestCase
641
628
  assert_equal_yields exp, out
642
629
  end
643
630
  def test_preorder
644
- ## empty node
631
+ # empty node
645
632
  d = C::Int.new
646
633
  d.longness = 1
647
634
  check_preorder(d, [d])
648
635
 
649
- ## one-storey -- populate both the list child and nonlist child
636
+ # one-storey -- populate both the list child and nonlist child
650
637
  d = C::Declaration.new(C::Int.new)
651
638
  d.declarators << C::Declarator.new
652
639
  d.declarators[0].name = 'one'
@@ -661,7 +648,7 @@ class NodeWalkTest < Test::Unit::TestCase
661
648
  d.declarators[1]
662
649
  ])
663
650
 
664
- ## multi-layer
651
+ # multi-layer
665
652
  d.declarators[0].indirect_type = C::Function.new
666
653
  d.declarators[0].indirect_type.params = Chain[]
667
654
  d.declarators[0].indirect_type.params << C::Parameter.new(C::Int.new, 'i')
@@ -682,12 +669,12 @@ class NodeWalkTest < Test::Unit::TestCase
682
669
  ])
683
670
  end
684
671
  def test_postorder
685
- ## empty node
672
+ # empty node
686
673
  d = C::Int.new
687
674
  d.longness = 1
688
675
  check_preorder(d, [d])
689
676
 
690
- ## one-storey -- populate both the list child and nonlist child
677
+ # one-storey -- populate both the list child and nonlist child
691
678
  d = C::Declaration.new(C::Int.new)
692
679
  d.declarators << C::Declarator.new
693
680
  d.declarators[0].name = 'one'
@@ -702,7 +689,7 @@ class NodeWalkTest < Test::Unit::TestCase
702
689
  d
703
690
  ])
704
691
 
705
- ## multi-layer
692
+ # multi-layer
706
693
  d.declarators[0].indirect_type = C::Function.new
707
694
  d.declarators[0].indirect_type.params = Chain[]
708
695
  d.declarators[0].indirect_type.params << C::Parameter.new(C::Int.new, 'i')
@@ -722,7 +709,7 @@ class NodeWalkTest < Test::Unit::TestCase
722
709
  d
723
710
  ])
724
711
  end
725
- def check_preorder_prune method, pruned_nodes, root, exp
712
+ def check_preorder_prune(method, pruned_nodes, root, exp)
726
713
  exp.map!{|n| [n]}
727
714
 
728
715
  out = yields(method, root, root) do |node|
@@ -734,13 +721,13 @@ class NodeWalkTest < Test::Unit::TestCase
734
721
  end
735
722
 
736
723
  def test_preorder_prune
737
- ## empty node
724
+ # empty node
738
725
  d = C::Int.new
739
726
  d.longness = 1
740
727
  check_preorder_prune(:preorder, [d], d, [d])
741
728
  check_preorder_prune(:reverse_preorder, [d], d, [d])
742
729
 
743
- ## one-storey -- populate both the list child and nonlist child
730
+ # one-storey -- populate both the list child and nonlist child
744
731
  d = C::Declaration.new(C::Int.new)
745
732
  d.declarators << C::Declarator.new
746
733
  d.declarators[0].name = 'one'
@@ -759,7 +746,7 @@ class NodeWalkTest < Test::Unit::TestCase
759
746
  d.type,
760
747
  ])
761
748
 
762
- ## multi-layer
749
+ # multi-layer
763
750
  d.type = C::Struct.new('S')
764
751
  d.type.members = Chain[]
765
752
  d.type.members << C::Declaration.new(C::Int.new)
@@ -788,14 +775,12 @@ class NodeWalkTest < Test::Unit::TestCase
788
775
  ])
789
776
  end
790
777
 
791
- ###
792
- ### ----------------------------------------------------------------
793
- ### next, prev, list_next, list_prev
794
- ### ----------------------------------------------------------------
795
- ###
778
+ # ------------------------------------------------------------------
779
+ # next, prev, list_next, list_prev
780
+ # ------------------------------------------------------------------
796
781
 
797
782
  def test_next_prev
798
- ## list parent
783
+ # list parent
799
784
  i1 = C::Int.new
800
785
  i2 = C::Int.new
801
786
  list = Chain[i1, i2]
@@ -804,7 +789,7 @@ class NodeWalkTest < Test::Unit::TestCase
804
789
  assert_same(i1, i2.prev)
805
790
  assert_nil(i1.prev)
806
791
 
807
- ## node parent
792
+ # node parent
808
793
  i1 = C::IntLiteral.new(1)
809
794
  i2 = C::IntLiteral.new(2)
810
795
  a = C::Add.new(i1, i2)
@@ -813,14 +798,14 @@ class NodeWalkTest < Test::Unit::TestCase
813
798
  assert_same(i1, i2.prev)
814
799
  assert_nil(i1.prev)
815
800
 
816
- ## no parent
801
+ # no parent
817
802
  i = C::Int.new
818
803
  assert_raise(C::Node::NoParent){i.next}
819
804
  assert_raise(C::Node::NoParent){i.prev}
820
805
  end
821
806
 
822
807
  def test_list_next_prev
823
- ## list parent
808
+ # list parent
824
809
  i1 = C::Int.new
825
810
  i2 = C::Int.new
826
811
  list = Chain[i1, i2]
@@ -829,7 +814,7 @@ class NodeWalkTest < Test::Unit::TestCase
829
814
  assert_same(i1, i2.list_prev)
830
815
  assert_nil(i1.list_prev)
831
816
 
832
- ## node parent
817
+ # node parent
833
818
  i1 = C::IntLiteral.new(1)
834
819
  i2 = C::IntLiteral.new(2)
835
820
  a = C::Add.new(i1, i2)
@@ -838,7 +823,7 @@ class NodeWalkTest < Test::Unit::TestCase
838
823
  assert_raise(C::Node::BadParent){i1.list_prev}
839
824
  assert_raise(C::Node::BadParent){i2.list_prev}
840
825
 
841
- ## no parent
826
+ # no parent
842
827
  i = C::Int.new
843
828
  assert_raise(C::Node::NoParent){i.list_next}
844
829
  assert_raise(C::Node::NoParent){i.list_prev}
@@ -847,10 +832,10 @@ end
847
832
 
848
833
  class NodeTreeTest < Test::Unit::TestCase
849
834
  def setup
850
- ## @c = "(int){[1] = 10,
851
- ## .x = 20,
852
- ## [2] .y = 30
853
- ## }
835
+ # @c = "(int){[1] = 10,
836
+ # .x = 20,
837
+ # [2] .y = 30
838
+ # }
854
839
  @c = C::CompoundLiteral.new
855
840
  c.type = C::Int.new
856
841
  c.member_inits << C::MemberInit.new
@@ -975,19 +960,19 @@ class NodeTreeTest < Test::Unit::TestCase
975
960
  end
976
961
 
977
962
  def test_node_swap_with
978
- ## swap with itself -- attached
963
+ # swap with itself -- attached
979
964
  x = X.new
980
965
  parent = X.new(x)
981
966
  assert_same(x, x.swap_with(x))
982
967
  assert_same(parent, x.parent)
983
968
  assert_same(x, parent.a)
984
969
 
985
- ## swap with itself -- detached
970
+ # swap with itself -- detached
986
971
  x = X.new
987
972
  assert_same(x, x.swap_with(x))
988
973
  assert_nil(x.parent)
989
974
 
990
- ## both attached
975
+ # both attached
991
976
  x = X.new
992
977
  y = X.new
993
978
  xp = X.new(x)
@@ -998,7 +983,7 @@ class NodeTreeTest < Test::Unit::TestCase
998
983
  assert_same(yp, x.parent)
999
984
  assert_same(y, xp.a)
1000
985
 
1001
- ## only receiver attached
986
+ # only receiver attached
1002
987
  x = X.new
1003
988
  y = X.new
1004
989
  xp = X.new(x)
@@ -1007,7 +992,7 @@ class NodeTreeTest < Test::Unit::TestCase
1007
992
  assert_same(xp, y.parent)
1008
993
  assert_same(y, xp.a)
1009
994
 
1010
- ## only arg attached
995
+ # only arg attached
1011
996
  x = X.new
1012
997
  y = X.new
1013
998
  yp = X.new(y)
@@ -1016,7 +1001,7 @@ class NodeTreeTest < Test::Unit::TestCase
1016
1001
  assert_same(x, yp.a)
1017
1002
  assert_nil(y.parent)
1018
1003
 
1019
- ## neither attached
1004
+ # neither attached
1020
1005
  x = X.new
1021
1006
  y = X.new
1022
1007
  assert_same(x, x.swap_with(y))
@@ -1024,11 +1009,10 @@ class NodeTreeTest < Test::Unit::TestCase
1024
1009
  assert_nil(y.parent)
1025
1010
  end
1026
1011
 
1027
- ###
1028
- ### ----------------------------------------------------------------
1029
- ### insert_next, insert_prev
1030
- ### ----------------------------------------------------------------
1031
- ###
1012
+ # ------------------------------------------------------------------
1013
+ # insert_next, insert_prev
1014
+ # ------------------------------------------------------------------
1015
+
1032
1016
  def test_node_insert_next_detached
1033
1017
  x1, x2 = 2.of{X.new}
1034
1018
  assert_raise(C::Node::NoParent){x1.insert_next}
@@ -1091,14 +1075,12 @@ class NodeTreeTest < Test::Unit::TestCase
1091
1075
  assert_same_list([x2, x3, x4, x1], parent)
1092
1076
  end
1093
1077
 
1094
- ###
1095
- ### ----------------------------------------------------------------
1096
- ### node_after, node_before
1097
- ### ----------------------------------------------------------------
1098
- ###
1078
+ # ------------------------------------------------------------------
1079
+ # node_after, node_before
1080
+ # ------------------------------------------------------------------
1099
1081
 
1100
1082
  def test_node_after_before
1101
- ## node not a child
1083
+ # node not a child
1102
1084
  x1, x2 = 2.of{X.new}
1103
1085
  parent = X.new(x1)
1104
1086
  assert_raise(ArgumentError){parent.node_after(x2)}
@@ -1111,13 +1093,13 @@ class NodeTreeTest < Test::Unit::TestCase
1111
1093
  assert_raise(ArgumentError){parent.node_before(x1)}
1112
1094
  assert_raise(ArgumentError){parent.node_before(x2)}
1113
1095
 
1114
- ## one child
1096
+ # one child
1115
1097
  x = X.new
1116
1098
  parent = X.new(x)
1117
1099
  assert_nil(parent.node_after(x))
1118
1100
  assert_nil(parent.node_before(x))
1119
1101
 
1120
- ## two children
1102
+ # two children
1121
1103
  x1 = X.new
1122
1104
  x2 = X.new
1123
1105
  parent = Y.new(x1, x2)
@@ -1126,7 +1108,7 @@ class NodeTreeTest < Test::Unit::TestCase
1126
1108
  assert_same(x1, parent.node_before(x2))
1127
1109
  assert_nil(parent.node_before(x1))
1128
1110
 
1129
- ## skip over stuff in the middle
1111
+ # skip over stuff in the middle
1130
1112
  x1, x2, x3, x4, x5 = 5.of{X.new}
1131
1113
  parent = Z.new(x1, x2, nil, x4, x5)
1132
1114
  assert_same(x5, parent.node_after(x1))
@@ -1134,7 +1116,7 @@ class NodeTreeTest < Test::Unit::TestCase
1134
1116
  assert_same(x1, parent.node_before(x5))
1135
1117
  assert_nil(parent.node_before(x1))
1136
1118
 
1137
- ## skip over stuff at the end
1119
+ # skip over stuff at the end
1138
1120
  x1, x2, x3, x4, x5 = 5.of{X.new}
1139
1121
  parent = Z.new(nil, x2, x3, x4, nil)
1140
1122
  assert_nil(parent.node_after(x3))
@@ -1142,20 +1124,20 @@ class NodeTreeTest < Test::Unit::TestCase
1142
1124
  end
1143
1125
 
1144
1126
  def test_remove_node
1145
- ## node not a child
1127
+ # node not a child
1146
1128
  x1, x2, x3 = 3.of{X.new}
1147
1129
  parent = Z.new(x1, x2)
1148
1130
  assert_raise(ArgumentError){parent.remove_node(x2)}
1149
1131
  assert_raise(ArgumentError){parent.remove_node(x3)}
1150
1132
 
1151
- ## one child
1133
+ # one child
1152
1134
  x = X.new
1153
1135
  parent = X.new(x)
1154
1136
  assert_same(parent, parent.remove_node(x))
1155
1137
  assert_tree(parent)
1156
1138
  assert_tree(x)
1157
1139
 
1158
- ## two children
1140
+ # two children
1159
1141
  x1, x2 = 2.of{X.new}
1160
1142
  parent = Y.new(x1, x2)
1161
1143
  assert_same(parent, parent.remove_node(x2))
@@ -1166,13 +1148,13 @@ class NodeTreeTest < Test::Unit::TestCase
1166
1148
  end
1167
1149
 
1168
1150
  def test_replace_node
1169
- ## node not a child
1151
+ # node not a child
1170
1152
  x1, x2, x3, x4 = 3.of{X.new}
1171
1153
  parent = Z.new(x1, x2)
1172
1154
  assert_raise(ArgumentError){parent.replace_node(x2, x4)}
1173
1155
  assert_raise(ArgumentError){parent.replace_node(x3, x4)}
1174
1156
 
1175
- ## no newnode
1157
+ # no newnode
1176
1158
  x = X.new
1177
1159
  parent = X.new(x)
1178
1160
  assert_same(parent, parent.replace_node(x))
@@ -1180,32 +1162,32 @@ class NodeTreeTest < Test::Unit::TestCase
1180
1162
  assert_tree(x)
1181
1163
  assert_nil(parent.a)
1182
1164
 
1183
- ## >1 newnode
1165
+ # >1 newnode
1184
1166
  x1, x2, x3 = 3.of{X.new}
1185
1167
  parent = X.new(x1)
1186
1168
  assert_raise(ArgumentError){parent.replace_node(x1, x2, x3)}
1187
1169
 
1188
- ## one child
1170
+ # one child
1189
1171
  x1, x2 = 2.of{X.new}
1190
1172
  parent = X.new(x1)
1191
1173
  assert_same(parent, parent.replace_node(x1, x2))
1192
1174
  assert_tree(parent)
1193
1175
  assert_tree(x1)
1194
1176
  assert_same(x2, parent.a)
1195
- ##
1177
+ #
1196
1178
  assert_same(parent, parent.replace_node(x2, nil))
1197
1179
  assert_tree(parent)
1198
1180
  assert_tree(x2)
1199
1181
  assert_nil(parent.a)
1200
1182
 
1201
- ## two children
1183
+ # two children
1202
1184
  x1, x2, x3 = 3.of{X.new}
1203
1185
  parent = Y.new(x1, x2)
1204
1186
  assert_same(parent, parent.replace_node(x2, x3))
1205
1187
  assert_tree(parent)
1206
1188
  assert_tree(x2)
1207
1189
  assert_same(x3, parent.b)
1208
- ##
1190
+ #
1209
1191
  assert_same(parent, parent.replace_node(x3, nil))
1210
1192
  assert_tree(parent)
1211
1193
  assert_tree(x3)