Catching up after the holidays.
[kakapo:kakapo.git] / t / Pmc / Array.nqp
1 # Copyright (C) 2009, Austin Hastings. See accompanying LICENSE file, or 
2 # http://www.opensource.org/licenses/artistic-license-2.0.php for license.
3
4 INIT {
5         pir::load_bytecode('P6object.pir');
6 }
7
8 sub main() {
9
10         P6metaclass::dump_class(Kakapo::Test::Array);
11         my $tc := Kakapo::Test::Array.new();
12         $tc.run();
13         Program::exit(0);
14 }
15
16 module Kakapo {
17         # Tell the Kakapo runtime which library file to load.   
18         sub library_name()              { 'kakapo_test.pbc' }
19 }
20
21 class Kakapo::Test::Array
22         is Testcase {
23 }
24
25 module NOT_BEING_USED;
26
27 INIT {
28         Global::use('P6object');
29         Global::use('Matcher::Factory');
30 }
31
32 method test_bsearch() {
33         
34         self.note("Testing Array::bsearch() function");
35         
36         my @dense := (3, 4, 5, 6, 7, 8, 9);
37         
38         self.assert_that('Bsearching 3', Array::bsearch(@dense, 3), returns(0));
39         self.assert_that('Bsearching 4', Array::bsearch(@dense, 4), returns(1));
40         self.assert_that('Bsearching 5', Array::bsearch(@dense, 5), returns(2));
41         self.assert_that('Bsearching 6', Array::bsearch(@dense, 6), returns(3));
42         self.assert_that('Bsearching 7', Array::bsearch(@dense, 7), returns(4));
43         self.assert_that('Bsearching 8', Array::bsearch(@dense, 8), returns(5));
44         self.assert_that('Bsearching 9', Array::bsearch(@dense, 9), returns(6));
45         
46         my @sparse := (11, 13, 15, 17, 19, 21, 23, 25);
47         self.assert_that('Bsearching 10', Array::bsearch(@sparse, 10), returns(-1));
48         self.assert_that('Bsearching 12', Array::bsearch(@sparse, 12), returns(-2));
49         self.assert_that('Bsearching 14', Array::bsearch(@sparse, 14), returns(-3));
50         self.assert_that('Bsearching 16', Array::bsearch(@sparse, 16), returns(-4));
51         self.assert_that('Bsearching 18', Array::bsearch(@sparse, 18), returns(-5));
52         self.assert_that('Bsearching 20', Array::bsearch(@sparse, 20), returns(-6));
53         self.assert_that('Bsearching 22', Array::bsearch(@sparse, 22), returns(-7));
54         self.assert_that('Bsearching 24', Array::bsearch(@sparse, 24), returns(-8));
55         self.assert_that('Bsearching 26', Array::bsearch(@sparse, 26), returns(-9));
56 }
57
58 method test_concat() {
59         
60         self.note("Testing Array::concat() function");
61
62         my @test := Array::concat();
63         self.assert_that('No args concat', @test, is(instance_of('ResizablePMCArray')));
64         self.assert_that('No args concat', @test, has(elements(0)));
65         
66         my @empty := Array::empty();
67         my @t2 := Array::concat(@empty);
68         self.assert_that('1 Empty concat', @t2, is(instance_of('ResizablePMCArray')));
69         self.assert_that('1 Empty concat', @t2, has(elements(@empty.elements)));
70         
71         my @a := (1, 2);
72
73         my @t3 := Array::concat(@a);
74         self.assert_that('1 full concat', @t3, is(instance_of('ResizablePMCArray')));
75         self.assert_that('1 full concat', @t3, has(elements(@a.elements)));
76         self.assert_that('original array', @a, has(elements(2)));
77         
78         my @t4 := Array::concat(@empty, @a);
79         self.assert_that('empty + full concat', @t4, is(instance_of('ResizablePMCArray')));
80         self.assert_that('empty + full concat', @t4, has(elements(@empty.elements + @a.elements)));
81         
82         my @t5 := Array::concat(@a, @empty);
83         self.assert_that('full + empty concat', @t5, is(instance_of('ResizablePMCArray')));
84         self.assert_that('full + empty concat', @t5, has(elements(@a.elements + @empty.elements)));
85         
86         my @b := ('a', 'b');
87
88         my @t9 := Array::concat(@a, @b);
89         self.assert_that('a + b concat', @t9, is(instance_of('ResizablePMCArray')));
90         self.assert_that('a + b concat', @t9, has(elements(@a.elements + @b.elements)));
91         
92         my @t6 := Array::concat(@b, @a);
93         self.assert_that('b + a concat', @t6, is(instance_of('ResizablePMCArray')));
94         self.assert_that('b + a concat', @t6, has(elements(@a.elements + @b.elements)));
95         
96         my @t7 := Array::concat(@a, @a);
97         self.assert_that('a + a concat', @t7, is(instance_of('ResizablePMCArray')));
98         self.assert_that('a + a concat', @t7, has(elements(@a.elements + @a.elements)));
99
100         my $undef;
101         my @c := ('', 0, $undef, No::such::symbol);
102         my $desc := 'a+b+c concat';
103         
104         my @t8 := Array::concat(@a, @b, @c);
105         self.assert_that($desc, @t8, is(instance_of('ResizablePMCArray')));
106         self.assert_that($desc, @t8, has(elements(@a.elements + @b.elements + @c.elements)));
107
108         self.assert_that($desc ~ ' element[0]', @t8[0], is(1));
109         self.assert_that($desc ~ ' element[1]', @t8[1], is(2));
110         self.assert_that($desc ~ ' element[2]', @t8[2], is('a'));
111         self.assert_that($desc ~ ' element[3]', @t8[3], is('b'));
112         self.assert_that($desc ~ ' element[4]', @t8[4], is(''));
113         self.assert_that($desc ~ ' element[5]', @t8[5], is(0));
114         self.assert_that($desc ~ ' element[6]', @t8[6], is(not(defined())));
115         
116         # This last test has to be not-defined, because NQP 'fixes' nulls in expression temps, 
117         # so I can't pass in a single-value null and have it stay null.
118         self.assert_that($desc ~ ' element[7]', @t8[7], is(not(defined())));
119 }
120
121 method test_contains() {
122         self.note("**NOT** testing Array::contains - it gets called from RPA and RSA, and tested by them");
123 }
124
125 method test_elements() {
126         
127         self.note("Testing Array::elements function");
128         
129         my @array := Array::empty();
130         self.assert_that('New array', @array, is(instance_of('ResizablePMCArray')));
131         self.assert_that('The elements count', @array.elements, is(0));
132         self.assert_that('The Array::elements count', Array::elements(@array), is(0));
133         
134         Array::elements(@array, 4);
135         self.assert_that('The elements count', @array.elements, is(4));
136         self.assert_that('The Array::elements count', Array::elements(@array), is(4));
137 }
138         
139 method test_empty() {
140         
141         self.note("Testing Array::empty() factory");
142         
143         my @array := Array::empty();
144         self.assert_that('New array', @array, is(instance_of('ResizablePMCArray')));
145         self.assert_that('The elements count', @array.elements, is(0));
146         
147         @array := Array::empty(1, 2, 3);
148         self.assert_that('New array', @array, is(instance_of('ResizablePMCArray')));
149         self.assert_that('The elements count', @array.elements, is(0));
150         
151 }
152
153 method test_new() {
154         
155         self.note("Testing Array::new() factory");
156         
157         my @array := Array::new();      
158         self.assert_that('New array', @array, is(instance_of('ResizablePMCArray')));
159         self.assert_that('The elements count', @array.elements, is(0));
160         
161         @array := Array::new(1, 2, 3);
162         self.assert_that('New array', @array, is(instance_of('ResizablePMCArray')));
163         self.assert_that('The elements count', @array.elements, is(3));
164 }
165
166 method test_reverse() {
167         
168         self.note("Testing Array::reverse() function");
169         
170         my @forwards := Array::new(1, 2, 3, 4, 5);
171         my @backwards := Array::new(5, 4, 3, 2, 1);
172         
173         self.assert_that('Forwards array, reversed', Array::reverse(@forwards), equals(@backwards));
174 }
175
176 method test_unique() {
177         
178         self.note("Testing Array::unique");
179
180         my @array := Array::new('foo', 'bar');
181         my @uniq := Array::unique(@array);
182         self.assert_that('Unique array', @uniq, equals(@array));
183         
184         @array.push('foo');
185         @uniq := Array::unique(@array);
186         self.assert_that('Unique array', @uniq, not(equals(@array)));
187 }