1
2 /***************************************************/
3
4 /* Test all aa properties (length, values, keys, opApply(Key, Value), opApply_r(Value),
5 * dup, byKey, byValue, rehash, opIndex, opIndexAssign, opIn_r)
6 *
7 * With all aas: literal, variable, ref parameter, rvalue
8 */
9
testLiteral()10 int testLiteral()
11 {
12 assert([5 : 4].length == 1);
13 assert([5 : 4].values == [4]);
14 assert([5 : 4].keys == [5]);
15 foreach (k, v; [5 : 4])
16 assert(k == 5 && v == 4);
17 foreach (v; [5 : 4])
18 assert(v == 4);
19 assert([5 : 4].dup == [5 : 4]);
20 assert([5 : 4].dup);
21 if (!__ctfe)
22 foreach (k; [5 : 4].byKey)
23 assert(k == 5);
24 if (!__ctfe)
25 foreach (v; [5 : 4].byValue)
26 assert(v == 4);
27 assert([5 : 4].rehash == [5 : 4]);
28 assert([5 : 4][5] == 4);
29 assert([5 : 4].get(5, 2) == 4);
30 assert([5 : 4].get(1, 2) == 2);
31 //assert(([5 : 4][3] = 7) == 7);
32 assert(*(5 in [5 : 4]) == 4);
33 return 1;
34 }
35
testVar()36 int testVar()
37 {
38 auto aa = [5 : 4];
39 assert(aa.length == 1);
40 assert(aa.values == [4]);
41 assert(aa.keys == [5]);
42 foreach (k, v; aa)
43 assert(k == 5 && v == 4);
44 foreach (v; aa)
45 assert(v == 4);
46 assert(aa.dup == aa);
47 assert(aa.dup);
48 {
49 auto bb = aa.dup();
50 assert(bb == aa);
51 //assert(aa !is bb); // issue in ctfeIdentity
52 assert(&aa[5] !is &bb[5]);
53 bb[5] = 10;
54 assert(aa[5] == 4);
55 assert(bb[5] == 10);
56 }
57 if (!__ctfe)
58 foreach (k; aa.byKey)
59 assert(k == 5);
60 if (!__ctfe)
61 foreach (v; aa.byValue)
62 assert(v == 4);
63 assert(aa.rehash == aa);
64 assert(aa[5] == 4);
65 assert(aa.get(5, 2) == 4);
66 assert(aa.get(1, 2) == 2);
67 assert(*(5 in aa) == 4);
68 assert((aa[3] = 7) == 7);
69 return 1;
70 }
71
testVarConst()72 int testVarConst()
73 {
74 const aa = [5 : 4];
75 assert(aa.length == 1);
76 assert(aa.values == [4]);
77 assert(aa.keys == [5]);
78 foreach (k, v; aa)
79 assert(k == 5 && v == 4);
80 foreach (v; aa)
81 assert(v == 4);
82 //assert(aa.dup == aa);
83 assert(aa.dup);
84 {
85 auto bb = aa.dup();
86 //assert(bb == aa);
87 //assert(aa !is bb); // issue in ctfeIdentity
88 assert(&aa[5] !is &bb[5]);
89 }
90 if (!__ctfe)
91 foreach (k; aa.byKey)
92 assert(k == 5);
93 if (!__ctfe)
94 foreach (v; aa.byValue)
95 assert(v == 4);
96 //assert(aa.rehash == aa);
97 assert(aa[5] == 4);
98 assert(aa.get(5, 2) == 4);
99 assert(aa.get(1, 2) == 2);
100 assert(*(5 in aa) == 4);
101 //assert((aa[3] = 7) == 7);
102 return 1;
103 }
104
testVarImmutable()105 int testVarImmutable()
106 {
107 immutable aa = [5 : 4];
108 assert(aa.length == 1);
109 assert(aa.values == [4]);
110 assert(aa.keys == [5]);
111 foreach (k, v; aa)
112 assert(k == 5 && v == 4);
113 foreach (v; aa)
114 assert(v == 4);
115 //assert(aa.dup == aa);
116 assert(aa.dup);
117 {
118 auto bb = aa.dup();
119 //assert(bb == aa);
120 //assert(aa !is bb); // issue in ctfeIdentity
121 assert(&aa[5] !is &bb[5]);
122 }
123 if (!__ctfe)
124 foreach (k; aa.byKey)
125 assert(k == 5);
126 if (!__ctfe)
127 foreach (v; aa.byValue)
128 assert(v == 4);
129 // assert(aa.rehash == aa);
130 assert(aa[5] == 4);
131 assert(aa.get(5, 2) == 4);
132 assert(aa.get(1, 2) == 2);
133 assert(*(5 in aa) == 4);
134 //assert((aa[3] = 7) == 7);
135 return 1;
136 }
137
testPointer()138 int testPointer()
139 {
140 auto x = [5 : 4];
141 auto aa = &x;
142 assert(aa.length == 1);
143 assert(aa.values == [4]);
144 assert(aa.keys == [5]);
145 // foreach (k, v; aa)
146 // assert(k == 5 && v == 4);
147 // foreach (v; aa)
148 // assert(v == 4);
149 assert(aa.dup == *aa);
150 assert(aa.dup);
151 {
152 auto bb = aa.dup();
153 assert(bb == *aa);
154 //assert(aa !is bb); // issue in ctfeIdentity
155 assert(&(*aa)[5] !is &bb[5]);
156 bb[5] = 10;
157 assert((*aa)[5] == 4);
158 assert(bb[5] == 10);
159 }
160 if (!__ctfe)
161 foreach (k; aa.byKey)
162 assert(k == 5);
163 if (!__ctfe)
164 foreach (v; aa.byValue)
165 assert(v == 4);
166 if (!__ctfe)
167 assert(aa.rehash == *aa);
168 assert((*aa)[5] == 4);
169 assert(aa.get(5, 2) == 4);
170 assert(aa.get(1, 2) == 2);
171 // assert(*(5 in aa) == 4);
172 if (!__ctfe)
173 assert(((*aa)[3] = 7) == 7);
174 return 1;
175 }
176
testPointerConst()177 int testPointerConst()
178 {
179 const x = [5 : 4];
180 const aa = &x;
181 assert(aa.length == 1);
182 assert(aa.values == [4]);
183 assert(aa.keys == [5]);
184 // foreach (k, v; aa)
185 // assert(k == 5 && v == 4);
186 // foreach (v; aa)
187 // assert(v == 4);
188 // assert(aa.dup == *aa);
189 assert(aa.dup);
190 {
191 auto bb = aa.dup();
192 //assert(bb == aa);
193 //assert(aa !is bb); // issue in ctfeIdentity
194 assert(&(*aa)[5] !is &bb[5]);
195 }
196 if (!__ctfe)
197 foreach (k; aa.byKey)
198 assert(k == 5);
199 if (!__ctfe)
200 foreach (v; aa.byValue)
201 assert(v == 4);
202 // assert(aa.rehash == aa);
203 assert((*aa)[5] == 4);
204 assert(aa.get(5, 2) == 4);
205 assert(aa.get(1, 2) == 2);
206 // assert(*(5 in aa) == 4);
207 // assert(((*aa)[3] = 7) == 7);
208 return 1;
209 }
210
testPointerImmutable()211 int testPointerImmutable()
212 {
213 immutable x = [5 : 4];
214 auto aa = &x;
215 assert(aa.length == 1);
216 assert(aa.values == [4]);
217 assert(aa.keys == [5]);
218 // foreach (k, v; aa)
219 // assert(k == 5 && v == 4);
220 // foreach (v; aa)
221 // assert(v == 4);
222 // assert(aa.dup == *aa);
223 assert(aa.dup);
224 {
225 auto bb = aa.dup();
226 //assert(bb == (*aa));
227 //assert(aa !is bb); // issue in ctfeIdentity
228 assert(&(*aa)[5] !is &bb[5]);
229 }
230 if (!__ctfe)
231 foreach (k; aa.byKey)
232 assert(k == 5);
233 if (!__ctfe)
234 foreach (v; aa.byValue)
235 assert(v == 4);
236 // assert(aa.rehash == aa);
237 assert((*aa)[5] == 4);
238 assert(aa.get(5, 2) == 4);
239 assert(aa.get(1, 2) == 2);
240 // assert(*(5 in aa) == 4);
241 // assert(((*aa)[3] = 7) == 7);
242 return 1;
243 }
244
testRef()245 int testRef()
246 {
247 auto aa = [5 : 4];
248 return testRefx(aa);
249 }
testRefx(ref int[int]aa)250 int testRefx(ref int[int] aa)
251 {
252 assert(aa.length == 1);
253 assert(aa.values == [4]);
254 assert(aa.keys == [5]);
255 foreach (k, v; aa)
256 assert(k == 5 && v == 4);
257 foreach (v; aa)
258 assert(v == 4);
259 assert(aa.dup == aa);
260 assert(aa.dup);
261 {
262 auto bb = aa.dup();
263 assert(bb == aa);
264 //assert(aa !is bb); // issue in ctfeIdentity
265 assert(&aa[5] !is &bb[5]);
266 bb[5] = 10;
267 assert(aa[5] == 4);
268 assert(bb[5] == 10);
269 }
270 if (!__ctfe)
271 foreach (k; aa.byKey)
272 assert(k == 5);
273 if (!__ctfe)
274 foreach (v; aa.byValue)
275 assert(v == 4);
276 assert(aa.rehash == aa);
277 assert(aa[5] == 4);
278 assert(aa.get(5, 2) == 4);
279 assert(aa.get(1, 2) == 2);
280 assert((aa[3] = 7) == 7);
281 assert(*(5 in aa) == 4);
282 return 1;
283 }
284
testRet()285 int testRet()
286 {
287 assert(testRetx().length == 1);
288 assert(testRetx().values == [4]);
289 assert(testRetx().keys == [5]);
290 foreach (k, v; testRetx())
291 assert(k == 5 && v == 4);
292 foreach (v; testRetx())
293 assert(v == 4);
294 assert(testRetx().dup == testRetx());
295 assert(testRetx().dup);
296 if (!__ctfe)
297 foreach (k; testRetx().byKey)
298 assert(k == 5);
299 if (!__ctfe)
300 foreach (v; testRetx().byValue)
301 assert(v == 4);
302 assert(testRetx().rehash == testRetx());
303 assert(testRetx()[5] == 4);
304 assert(testRetx().get(5, 2) == 4);
305 assert(testRetx().get(1, 2) == 2);
306 //assert((testRetx()[3] = 7) == 7);
307 assert(*(5 in testRetx()) == 4);
308 return 1;
309 }
testRetx()310 int[int] testRetx()
311 {
312 return [5 : 4];
313 }
314
aafunc(int[int]aa)315 void aafunc(int[int] aa) {}
316
317 /***************************************************/
318 // https://issues.dlang.org/show_bug.cgi?id=12214
319
test12214()320 void test12214() pure nothrow
321 {
322 int[int] aa;
323 auto n = aa.length;
324 }
325
326 /***************************************************/
327 // https://issues.dlang.org/show_bug.cgi?id=12220
328 // https://issues.dlang.org/show_bug.cgi?id=12221
329
test12220()330 void test12220()
331 {
332 short[short] hash;
333 short k = hash.get(1, 2);
334 assert(k == 2);
335
336 enum Key : short { a = 10 }
337 short a = hash.get(Key.a, Key.a);
338 assert(a == 10);
339 }
340
341 /***************************************************/
342 // https://issues.dlang.org/show_bug.cgi?id=12403
343
test12403()344 void test12403()
345 {
346 const(int)[int] m;
347 assert(m.get(0, 1) == 1);
348 }
349
350 /***************************************************/
351
main()352 void main()
353 {
354 assert(testLiteral());
355 static assert(testLiteral());
356 assert(testVar());
357 static assert(testVar());
358 assert(testVarConst());
359 static assert(testVarConst());
360 assert(testVarImmutable());
361 static assert(testVarImmutable());
362 assert(testPointer());
363 static assert(testPointer());
364 assert(testPointerConst());
365 static assert(testPointerConst());
366 assert(testPointerImmutable());
367 static assert(testPointerImmutable());
368 assert(testRef());
369 static assert(testRef());
370 assert(testRet());
371 static assert(testRet());
372
373 test12220();
374 test12403();
375 }
376