Subversion Repositories Applications.papyrus

Rev

Details | Last modification | View Log | RSS feed

Rev Author Line No. Line
2150 mathias 1 
if(!dojo._hasResource["tests._base.array"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
2 
dojo._hasResource["tests._base.array"] = true;
3 
dojo.provide("tests._base.array");
4 
 
5 
tests.register("tests._base.array",
6 
	[
7 
		function testIndexOf(t){
8 
			var foo = [128, 256, 512];
9 
			var bar = ["aaa", "bbb", "ccc"];
10 
 
11 
			t.assertTrue(dojo.indexOf([45, 56, 85], 56) == 1);
12 
			t.assertTrue(dojo.indexOf([Number, String, Date], String) == 1);
13 
			t.assertTrue(dojo.indexOf(foo, foo[1]) == 1);
14 
			t.assertTrue(dojo.indexOf(foo, foo[2]) == 2);
15 
			t.assertTrue(dojo.indexOf(bar, bar[1]) == 1);
16 
			t.assertTrue(dojo.indexOf(bar, bar[2]) == 2);
17 
 
18 
			foo.push(bar);
19 
			t.assertTrue(dojo.indexOf(foo, bar) == 3);
20 
		},
21 
 
22 
		function testIndexOfFromIndex(t){
23 
			var foo = [128, 256, 512];
24 
			var bar = ["aaa", "bbb", "ccc"];
25 
 
26 
			// FIXME: what happens w/ negative indexes?
27 
			t.assertEqual(-1, dojo.indexOf([45, 56, 85], 56, 2));
28 
			t.assertEqual(1, dojo.indexOf([45, 56, 85], 56, 1));
29 
		},
30 
 
31 
		function testLastIndexOf(t){
32 
			var foo = [128, 256, 512];
33 
			var bar = ["aaa", "bbb", "aaa", "ccc"];
34 
 
35 
			t.assertTrue(dojo.indexOf([45, 56, 85], 56) == 1);
36 
			t.assertTrue(dojo.indexOf([Number, String, Date], String) == 1);
37 
			t.assertTrue(dojo.lastIndexOf(foo, foo[1]) == 1);
38 
			t.assertTrue(dojo.lastIndexOf(foo, foo[2]) == 2);
39 
			t.assertTrue(dojo.lastIndexOf(bar, bar[1]) == 1);
40 
			t.assertTrue(dojo.lastIndexOf(bar, bar[2]) == 2);
41 
			t.assertTrue(dojo.lastIndexOf(bar, bar[0]) == 2);
42 
		},
43 
 
44 
		function testLastIndexOfFromIndex(t){
45 
			// FIXME: what happens w/ negative indexes?
46 
			t.assertEqual(1, dojo.lastIndexOf([45, 56, 85], 56, 1));
47 
			t.assertEqual(-1, dojo.lastIndexOf([45, 56, 85], 85, 1));
48 
		},
49 
 
50 
		function testForEach(t){
51 
			var foo = [128, "bbb", 512];
52 
			dojo.forEach(foo, function(elt, idx, array){
53 
				switch(idx){
54 
					case 0: t.assertEqual(128, elt); break;
55 
					case 1: t.assertEqual("bbb", elt); break;
56 
					case 2: t.assertEqual(512, elt); break;
57 
					default: t.assertTrue(false);
58 
				}
59 
			});
60 
 
61 
			var noException = true;
62 
			try{
63 
				dojo.forEach(undefined, function(){});
64 
			}catch(e){
65 
				noException = false;
66 
			}
67 
			t.assertTrue(noException);
68 
		},
69 
 
70 
		function testForEach_str(t){
71 
			var bar = 'abc';
72 
			dojo.forEach(bar, function(elt, idx, array){
73 
				switch(idx){
74 
					case 0: t.assertEqual("a", elt); break;
75 
					case 1: t.assertEqual("b", elt); break;
76 
					case 2: t.assertEqual("c", elt); break;
77 
					default: t.assertTrue(false);
78 
				}
79 
			});
80 
		},
81 
		// FIXME: test forEach w/ a NodeList()?
82 
 
83 
		function testEvery(t){
84 
			var foo = [128, "bbb", 512];
85 
 
86 
			t.assertTrue(
87 
				dojo.every(foo, function(elt, idx, array){
88 
					t.assertEqual(Array, array.constructor);
89 
					t.assertTrue(dojo.isArray(array));
90 
					t.assertTrue(typeof idx == "number");
91 
					if(idx == 1){ t.assertEqual("bbb" , elt); }
92 
					return true;
93 
				})
94 
			);
95 
 
96 
			t.assertTrue(
97 
				dojo.every(foo, function(elt, idx, array){
98 
					switch(idx){
99 
						case 0: t.assertEqual(128, elt); return true;
100 
						case 1: t.assertEqual("bbb", elt); return true;
101 
						case 2: t.assertEqual(512, elt); return true;
102 
						default: return false;
103 
					}
104 
				})
105 
			);
106 
 
107 
			t.assertFalse(
108 
				dojo.every(foo, function(elt, idx, array){
109 
					switch(idx){
110 
						case 0: t.assertEqual(128, elt); return true;
111 
						case 1: t.assertEqual("bbb", elt); return true;
112 
						case 2: t.assertEqual(512, elt); return false;
113 
						default: return true;
114 
					}
115 
				})
116 
			);
117 
 
118 
		},
119 
 
120 
		function testEvery_str(t){
121 
			var bar = 'abc';
122 
			t.assertTrue(
123 
				dojo.every(bar, function(elt, idx, array){
124 
					switch(idx){
125 
						case 0: t.assertEqual("a", elt); return true;
126 
						case 1: t.assertEqual("b", elt); return true;
127 
						case 2: t.assertEqual("c", elt); return true;
128 
						default: return false;
129 
					}
130 
				})
131 
			);
132 
 
133 
			t.assertFalse(
134 
				dojo.every(bar, function(elt, idx, array){
135 
					switch(idx){
136 
						case 0: t.assertEqual("a", elt); return true;
137 
						case 1: t.assertEqual("b", elt); return true;
138 
						case 2: t.assertEqual("c", elt); return false;
139 
						default: return true;
140 
					}
141 
				})
142 
			);
143 
		},
144 
		// FIXME: test NodeList for every()?
145 
 
146 
		function testSome(t){
147 
			var foo = [128, "bbb", 512];
148 
			t.assertTrue(
149 
				dojo.some(foo, function(elt, idx, array){
150 
					t.assertEqual(3, array.length);
151 
					return true;
152 
				})
153 
			);
154 
 
155 
			t.assertTrue(
156 
				dojo.some(foo, function(elt, idx, array){
157 
					if(idx < 1){ return true; }
158 
					return false;
159 
				})
160 
			);
161 
 
162 
			t.assertFalse(
163 
				dojo.some(foo, function(elt, idx, array){
164 
					return false;
165 
				})
166 
			);
167 
 
168 
			t.assertTrue(
169 
				dojo.some(foo, function(elt, idx, array){
170 
					t.assertEqual(Array, array.constructor);
171 
					t.assertTrue(dojo.isArray(array));
172 
					t.assertTrue(typeof idx == "number");
173 
					if(idx == 1){ t.assertEqual("bbb" , elt); }
174 
					return true;
175 
				})
176 
			);
177 
		},
178 
 
179 
		function testSome_str(t){
180 
			var bar = 'abc';
181 
			t.assertTrue(
182 
				dojo.some(bar, function(elt, idx, array){
183 
					t.assertEqual(3, array.length);
184 
					switch(idx){
185 
						case 0: t.assertEqual("a", elt); return true;
186 
						case 1: t.assertEqual("b", elt); return true;
187 
						case 2: t.assertEqual("c", elt); return true;
188 
						default: return false;
189 
					}
190 
				})
191 
			);
192 
 
193 
			t.assertTrue(
194 
				dojo.some(bar, function(elt, idx, array){
195 
					switch(idx){
196 
						case 0: t.assertEqual("a", elt); return true;
197 
						case 1: t.assertEqual("b", elt); return true;
198 
						case 2: t.assertEqual("c", elt); return false;
199 
						default: return true;
200 
					}
201 
				})
202 
			);
203 
 
204 
			t.assertFalse(
205 
				dojo.some(bar, function(elt, idx, array){
206 
					return false;
207 
				})
208 
			);
209 
		},
210 
		// FIXME: need to add scoping tests for all of these!!!
211 
 
212 
		function testFilter(t){
213 
			var foo = ["foo", "bar", 10];
214 
 
215 
			t.assertEqual(["foo"],
216 
				dojo.filter(foo, function(elt, idx, array){
217 
					return idx < 1;
218 
				})
219 
			);
220 
 
221 
			t.assertEqual(["foo"],
222 
				dojo.filter(foo, function(elt, idx, array){
223 
					return elt == "foo";
224 
				})
225 
			);
226 
 
227 
			t.assertEqual([],
228 
				dojo.filter(foo, function(elt, idx, array){
229 
					return false;
230 
				})
231 
			);
232 
 
233 
			t.assertEqual([10],
234 
				dojo.filter(foo, function(elt, idx, array){
235 
					return typeof elt == "number";
236 
				})
237 
			);
238 
		},
239 
 
240 
		function testFilter_str(t){
241 
			var foo = "thinger blah blah blah";
242 
			t.assertEqual(["t", "h", "i"],
243 
				dojo.filter(foo, function(elt, idx, array){
244 
					return idx < 3;
245 
				})
246 
			);
247 
 
248 
			t.assertEqual([],
249 
				dojo.filter(foo, function(elt, idx, array){
250 
					return false;
251 
				})
252 
			);
253 
		},
254 
 
255 
		function testMap(t){
256 
			t.assertEqual([],
257 
				dojo.map([], function(){ return true; })
258 
			);
259 
 
260 
			t.assertEqual([1, 2, 3],
261 
				dojo.map(["cat", "dog", "mouse"], function(elt, idx, array){
262 
					return idx+1;
263 
				})
264 
			);
265 
		}
266 
	]
267 
);
268 
 
269 
 
270 
}