this repo has no description
dekker.one
1/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */
2/*
3 * Main authors:
4 * Christian Schulte <schulte@gecode.org>
5 *
6 * Copyright:
7 * Christian Schulte, 2005
8 *
9 * This file is part of Gecode, the generic constraint
10 * development environment:
11 * http://www.gecode.org
12 *
13 * Permission is hereby granted, free of charge, to any person obtaining
14 * a copy of this software and associated documentation files (the
15 * "Software"), to deal in the Software without restriction, including
16 * without limitation the rights to use, copy, modify, merge, publish,
17 * distribute, sublicense, and/or sell copies of the Software, and to
18 * permit persons to whom the Software is furnished to do so, subject to
19 * the following conditions:
20 *
21 * The above copyright notice and this permission notice shall be
22 * included in all copies or substantial portions of the Software.
23 *
24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
27 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
28 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
29 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
30 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
31 *
32 */
33
34#include "test/int.hh"
35
36#include <gecode/minimodel.hh>
37#include <climits>
38
39namespace Test { namespace Int {
40
41 /// %Tests for element constraints
42 namespace Element {
43
44 /**
45 * \defgroup TaskTestIntElement Element constraints
46 * \ingroup TaskTestInt
47 */
48 //@{
49 /// %Test for element with integer array and integer variables
50 class IntIntVar : public Test {
51 protected:
52 /// Array of integers
53 Gecode::IntArgs c;
54 public:
55 /// Create and register test
56 IntIntVar(const std::string& s, const Gecode::IntArgs& c0,
57 int min, int max)
58 : Test("Element::Int::Int::Var::"+s,2,min,max),
59 c(c0) {}
60 /// %Test whether \a x is solution
61 virtual bool solution(const Assignment& x) const {
62 return (x[0]>= 0) && (x[0]<c.size()) && c[x[0]]==x[1];
63 }
64 /// Post constraint on \a x
65 virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
66 Gecode::element(home, c, x[0], x[1]);
67 }
68 };
69
70 /// %Test for element with integer array and integer variables
71 class IntIntInt : public Test {
72 protected:
73 /// Array of integers
74 Gecode::IntArgs c;
75 /// Integer result
76 int r;
77 public:
78 /// Create and register test
79 IntIntInt(const std::string& s, const Gecode::IntArgs& c0, int r0)
80 : Test("Element::Int::Int::Int::"+s+"::"+str(r0),1,-4,8),
81 c(c0), r(r0) {}
82 /// %Test whether \a x is solution
83 virtual bool solution(const Assignment& x) const {
84 return (x[0]>= 0) && (x[0]<c.size()) && c[x[0]]==r;
85 }
86 /// Post constraint on \a x
87 virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
88 Gecode::element(home, c, x[0], r);
89 }
90 };
91
92 /// %Test for element with integer array and single shared integer variable
93 class IntIntShared : public Test {
94 protected:
95 /// Array of integers
96 Gecode::IntArgs c;
97 public:
98 /// Create and register test
99 IntIntShared(const std::string& s, const Gecode::IntArgs& c0,
100 int minDomain=-4)
101 : Test("Element::Int::Int::Shared::"+s,1,minDomain,8), c(c0) {}
102 /// %Test whether \a x is solution
103 virtual bool solution(const Assignment& x) const {
104 return (x[0]>= 0) && (x[0]<c.size()) && c[x[0]]==x[0];
105 }
106 /// Post constraint on \a x
107 virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
108 Gecode::element(home, c, x[0], x[0]);
109 }
110 };
111
112 /// %Test for element with integer array and integer and Boolean variable
113 class IntBoolVar : public Test {
114 protected:
115 /// Array of integers
116 Gecode::IntArgs c;
117 public:
118 /// Create and register test
119 IntBoolVar(const std::string& s, const Gecode::IntArgs& c0)
120 : Test("Element::Int::Bool::Var::"+s,2,-4,8), c(c0) {}
121 /// %Test whether \a x is solution
122 virtual bool solution(const Assignment& x) const {
123 return (x[0]>= 0) && (x[0]<c.size()) && c[x[0]]==x[1];
124 }
125 /// Post constraint on \a x
126 virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
127 Gecode::element(home, c, x[0], Gecode::channel(home,x[1]));
128 }
129 };
130
131 /// %Test for element with integer array and integer and Boolean variable
132 class IntBoolInt : public Test {
133 protected:
134 /// Array of integers
135 Gecode::IntArgs c;
136 /// Integer result
137 int r;
138 public:
139 /// Create and register test
140 IntBoolInt(const std::string& s, const Gecode::IntArgs& c0, int r0)
141 : Test("Element::Int::Bool::Int::"+s+"::"+str(r0),1,-4,8),
142 c(c0), r(r0) {}
143 /// %Test whether \a x is solution
144 virtual bool solution(const Assignment& x) const {
145 return (x[0]>= 0) && (x[0]<c.size()) && c[x[0]]==r;
146 }
147 /// Post constraint on \a x
148 virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
149 Gecode::element(home, c, x[0], r);
150 }
151 };
152
153 /// %Test for element with variable array and integer variables
154 class VarIntVar : public Test {
155 public:
156 /// Create and register test
157 VarIntVar(Gecode::IntPropLevel ipl)
158 : Test("Element::Var::Int::Var::"+str(ipl),6,-1,3,false,ipl) {}
159 /// %Test whether \a x is solution
160 virtual bool solution(const Assignment& x) const {
161 return (x[0]>= 0) && (x[0]<x.size()-2) && x[2+x[0]]==x[1];
162 }
163 /// Post constraint on \a x
164 virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
165 Gecode::IntVarArgs c(x.size()-2);
166 for (int i=0; i<x.size()-2; i++)
167 c[i]=x[2+i];
168 Gecode::element(home, c, x[0], x[1], ipl);
169 }
170 };
171
172 /// %Test for element with variable array and integer variables
173 class VarIntInt : public Test {
174 protected:
175 /// Integer result
176 int r;
177 public:
178 /// Create and register test
179 VarIntInt(Gecode::IntPropLevel ipl, int r0)
180 : Test("Element::Var::Int::Int::"+str(ipl)+"::"+str(r0),
181 5,-1,3,false,ipl), r(r0) {
182 contest = CTL_NONE;
183 }
184 /// %Test whether \a x is solution
185 virtual bool solution(const Assignment& x) const {
186 return (x[0]>= 0) && (x[0]<x.size()-1) && x[1+x[0]]==r;
187 }
188 /// Post constraint on \a x
189 virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
190 Gecode::IntVarArgs c(x.size()-1);
191 for (int i=0; i<x.size()-1; i++)
192 c[i]=x[1+i];
193 Gecode::element(home, c, x[0], r, ipl);
194 }
195 };
196
197 /// %Test for element with variable array and shared integer variable
198 class VarIntShared : public Test {
199 public:
200 /// Create and register test
201 VarIntShared(Gecode::IntPropLevel ipl)
202 : Test("Element::Var::Int::Shared::"+str(ipl),5,-1,3,false,ipl) {
203 contest = CTL_NONE;
204 }
205 /// %Test whether \a x is solution
206 virtual bool solution(const Assignment& x) const {
207 return (x[0]>= 0) && (x[0]<x.size()-1) && x[1+x[0]]==x[0];
208 }
209 /// Post constraint on \a x
210 virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
211 Gecode::IntVarArgs c(x.size()-1);
212 for (int i=0; i<x.size()-1; i++)
213 c[i]=x[1+i];
214 Gecode::element(home, c, x[0], x[0], ipl);
215 }
216 };
217
218 /// %Test for element with Boolean variable array and integer variable
219 class VarBoolVar : public Test {
220 public:
221 /// Create and register test
222 VarBoolVar(void) : Test("Element::Var::Bool::Var",6,-1,3,false) {}
223 /// %Test whether \a x is solution
224 virtual bool solution(const Assignment& x) const {
225 for (int i=0; i<x.size()-2; i++)
226 if ((x[2+i] < 0) || (x[2+i]>1))
227 return false;
228 return ((x[0]>= 0) && (x[0]<x.size()-2) && x[2+x[0]]==x[1]
229 && (x[1]>=0) && (x[1]<=1));
230 }
231 /// Post constraint on \a x
232 virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
233 using namespace Gecode;
234 BoolVarArgs c(x.size()-2);
235 for (int i=0; i<x.size()-2; i++)
236 c[i]=channel(home,x[2+i]);
237 element(home, c, x[0], channel(home,x[1]));
238 }
239 };
240
241 /// %Test for element with Boolean variable array and integer variable
242 class VarBoolInt : public Test {
243 protected:
244 /// Integer result
245 int r;
246 public:
247 /// Create and register test
248 VarBoolInt(int r0)
249 : Test("Element::Var::Bool::Int::"+str(r0),5,-1,3,false), r(r0) {}
250 /// %Test whether \a x is solution
251 virtual bool solution(const Assignment& x) const {
252 for (int i=0; i<x.size()-1; i++)
253 if ((x[1+i] < 0) || (x[1+i]>1))
254 return false;
255 return ((x[0]>= 0) && (x[0]<x.size()-1) && x[1+x[0]]==r);
256 }
257 /// Post constraint on \a x
258 virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
259 using namespace Gecode;
260 BoolVarArgs c(x.size()-1);
261 for (int i=0; i<x.size()-1; i++)
262 c[i]=channel(home,x[1+i]);
263 if (r == 1) {
264 switch (_rand(3)) {
265 case 0:
266 element(home, c, x[0], 1);
267 break;
268 case 1:
269 {
270 BoolVar one(home,1,1);
271 rel(home, element(c,x[0]) == one);
272 }
273 break;
274 case 2:
275 rel(home, element(c,x[0]));
276 break;
277 default: GECODE_NEVER;
278 }
279 } else {
280 element(home, c, x[0], r);
281 }
282 }
283 };
284
285
286 /// %Test for matrix element with integer array and integer variable
287 class MatrixIntIntVarXY : public Test {
288 protected:
289 /// Array for test matrix
290 Gecode::IntArgs tm;
291 public:
292 /// Create and register test
293 MatrixIntIntVarXY(void)
294 : Test("Element::Matrix::Int::IntVar::XY",3,0,5,false),
295 tm({0,1,2,3,4,5}) {}
296 /// %Test whether \a x is solution
297 virtual bool solution(const Assignment& x) const {
298 // x-coordinate: x[0], y-coordinate: x[1], result: x[2]
299 using namespace Gecode;
300 if ((x[0] > 2) || (x[1] > 1))
301 return false;
302 Matrix<IntArgs> m(tm,3,2);
303 return m(x[0],x[1]) == x[2];
304 }
305 /// Post constraint on \a x
306 virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
307 // x-coordinate: x[0], y-coordinate: x[1], result: x[2]
308 using namespace Gecode;
309 Matrix<IntArgs> m(tm,3,2);
310 element(home, m, x[0], x[1], x[2]);
311 }
312 };
313
314 /// %Test for matrix element with integer array and integer variable
315 class MatrixIntIntVarXX : public Test {
316 protected:
317 /// Array for test matrix
318 Gecode::IntArgs tm;
319 public:
320 /// Create and register test
321 MatrixIntIntVarXX(void)
322 : Test("Element::Matrix::Int::IntVar::XX",2,0,3,false),
323 tm({0,1,2,3}) {}
324 /// %Test whether \a x is solution
325 virtual bool solution(const Assignment& x) const {
326 // x-coordinate: x[0], y-coordinate: x[0], result: x[1]
327 using namespace Gecode;
328 if (x[0] > 1)
329 return false;
330 Matrix<IntArgs> m(tm,2,2);
331 return m(x[0],x[0]) == x[1];
332 }
333 /// Post constraint on \a x
334 virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
335 // x-coordinate: x[0], y-coordinate: x[0], result: x[1]
336 using namespace Gecode;
337 Matrix<IntArgs> m(tm,2,2);
338 element(home, m, x[0], x[0], x[1]);
339 }
340 };
341
342 /// %Test for matrix element with integer array and Boolean variable
343 class MatrixIntBoolVarXY : public Test {
344 protected:
345 /// Array for test matrix
346 Gecode::IntArgs tm;
347 public:
348 /// Create and register test
349 MatrixIntBoolVarXY(void)
350 : Test("Element::Matrix::Int::BoolVar::XY",3,0,3,false),
351 tm({0,1,1,0}) {}
352 /// %Test whether \a x is solution
353 virtual bool solution(const Assignment& x) const {
354 // x-coordinate: x[0], y-coordinate: x[1], result: x[2]
355 using namespace Gecode;
356 if ((x[0] > 1) || (x[1] > 1))
357 return false;
358 Matrix<IntArgs> m(tm,2,2);
359 return m(x[0],x[1]) == x[2];
360 }
361 /// Post constraint on \a x
362 virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
363 // x-coordinate: x[0], y-coordinate: x[1], result: x[2]
364 using namespace Gecode;
365 Matrix<IntArgs> m(tm,2,2);
366 element(home, m, x[0], x[1], channel(home,x[2]));
367 }
368 };
369
370 /// %Test for matrix element with integer array and Boolean variable
371 class MatrixIntBoolVarXX : public Test {
372 protected:
373 /// Array for test matrix
374 Gecode::IntArgs tm;
375 public:
376 /// Create and register test
377 MatrixIntBoolVarXX(void)
378 : Test("Element::Matrix::Int::BoolVar::XX",2,0,3,false),
379 tm({0,1,1,0}) {}
380 /// %Test whether \a x is solution
381 virtual bool solution(const Assignment& x) const {
382 // x-coordinate: x[0], y-coordinate: x[0], result: x[1]
383 using namespace Gecode;
384 if (x[0] > 1)
385 return false;
386 Matrix<IntArgs> m(tm,2,2);
387 return m(x[0],x[0]) == x[1];
388 }
389 /// Post constraint on \a x
390 virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
391 // x-coordinate: x[0], y-coordinate: x[0], result: x[1]
392 using namespace Gecode;
393 Matrix<IntArgs> m(tm,2,2);
394 element(home, m, x[0], x[0], channel(home,x[1]));
395 }
396 };
397
398 /// %Test for matrix element with integer variable array and integer variable
399 class MatrixIntVarIntVarXY : public Test {
400 public:
401 /// Create and register test
402 MatrixIntVarIntVarXY(void)
403 : Test("Element::Matrix::IntVar::IntVar::XY",3+4,0,3,false) {}
404 /// %Test whether \a x is solution
405 virtual bool solution(const Assignment& x) const {
406 // x-coordinate: x[0], y-coordinate: x[1], result: x[2]
407 // remaining: matrix
408 using namespace Gecode;
409 if ((x[0] > 1) || (x[1] > 1))
410 return false;
411 IntArgs tm(4);
412 tm[0]=x[3]; tm[1]=x[4]; tm[2]=x[5]; tm[3]=x[6];
413 Matrix<IntArgs> m(tm,2,2);
414 return m(x[0],x[1]) == x[2];
415 }
416 /// Post constraint on \a x
417 virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
418 // x-coordinate: x[0], y-coordinate: x[1], result: x[2]
419 using namespace Gecode;
420 IntVarArgs tm(4);
421 tm[0]=x[3]; tm[1]=x[4]; tm[2]=x[5]; tm[3]=x[6];
422 Matrix<IntVarArgs> m(tm,2,2);
423 element(home, m, x[0], x[1], x[2]);
424 }
425 };
426
427 /// %Test for matrix element with integer variable array and integer variable
428 class MatrixIntVarIntVarXX : public Test {
429 public:
430 /// Create and register test
431 MatrixIntVarIntVarXX(void)
432 : Test("Element::Matrix::IntVar::IntVar::XX",2+4,0,3,false) {}
433 /// %Test whether \a x is solution
434 virtual bool solution(const Assignment& x) const {
435 // x-coordinate: x[0], y-coordinate: x[0], result: x[1]
436 // remaining: matrix
437 using namespace Gecode;
438 if (x[0] > 1)
439 return false;
440 IntArgs tm(4);
441 tm[0]=x[2]; tm[1]=x[3]; tm[2]=x[4]; tm[3]=x[5];
442 Matrix<IntArgs> m(tm,2,2);
443 return m(x[0],x[0]) == x[1];
444 }
445 /// Post constraint on \a x
446 virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
447 // x-coordinate: x[0], y-coordinate: x[1], result: x[1]
448 using namespace Gecode;
449 IntVarArgs tm(4);
450 tm[0]=x[2]; tm[1]=x[3]; tm[2]=x[4]; tm[3]=x[5];
451 Matrix<IntVarArgs> m(tm,2,2);
452 element(home, m, x[0], x[0], x[1]);
453 }
454 };
455
456 /// %Test for matrix element with Boolean variable array and Boolean variable
457 class MatrixBoolVarBoolVarXY : public Test {
458 public:
459 /// Create and register test
460 MatrixBoolVarBoolVarXY(void)
461 : Test("Element::Matrix::BoolVar::BoolVar::XY",3+4,0,1,false) {}
462 /// %Test whether \a x is solution
463 virtual bool solution(const Assignment& x) const {
464 // x-coordinate: x[0], y-coordinate: x[1], result: x[2]
465 // remaining: matrix
466 using namespace Gecode;
467 IntArgs tm(4);
468 tm[0]=x[3]; tm[1]=x[4]; tm[2]=x[5]; tm[3]=x[6];
469 Matrix<IntArgs> m(tm,2,2);
470 return m(x[0],x[1]) == x[2];
471 }
472 /// Post constraint on \a x
473 virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
474 // x-coordinate: x[0], y-coordinate: x[1], result: x[2]
475 using namespace Gecode;
476 BoolVarArgs tm(4);
477 tm[0]=channel(home,x[3]); tm[1]=channel(home,x[4]);
478 tm[2]=channel(home,x[5]); tm[3]=channel(home,x[6]);
479 Matrix<BoolVarArgs> m(tm,2,2);
480 element(home, m, x[0], x[1], channel(home,x[2]));
481 }
482 };
483
484 /// %Test for matrix element with Boolean variable array and Boolean variable
485 class MatrixBoolVarBoolVarXX : public Test {
486 public:
487 /// Create and register test
488 MatrixBoolVarBoolVarXX(void)
489 : Test("Element::Matrix::BoolVar::BoolVar::XX",2+4,0,1,false) {}
490 /// %Test whether \a x is solution
491 virtual bool solution(const Assignment& x) const {
492 // x-coordinate: x[0], y-coordinate: x[0], result: x[1]
493 // remaining: matrix
494 using namespace Gecode;
495 IntArgs tm(4);
496 tm[0]=x[2]; tm[1]=x[3]; tm[2]=x[4]; tm[3]=x[5];
497 Matrix<IntArgs> m(tm,2,2);
498 return m(x[0],x[0]) == x[1];
499 }
500 /// Post constraint on \a x
501 virtual void post(Gecode::Space& home, Gecode::IntVarArray& x) {
502 // x-coordinate: x[0], y-coordinate: x[1], result: x[1]
503 using namespace Gecode;
504 BoolVarArgs tm(4);
505 tm[0]=channel(home,x[2]); tm[1]=channel(home,x[3]);
506 tm[2]=channel(home,x[4]); tm[3]=channel(home,x[5]);
507 Matrix<BoolVarArgs> m(tm,2,2);
508 element(home, m, x[0], x[0], channel(home,x[1]));
509 }
510 };
511
512
513
514
515 /// Help class to create and register tests
516 class Create {
517 public:
518 /// %Test size-dependent optimizations
519 void optimized(int idx, int val) {
520 Gecode::IntArgs c(idx);
521 for (int i=0; i<idx; i++)
522 c[i]=std::max(val-i,0);
523 (void) new IntIntVar(Test::str(idx)+"::"+Test::str(val)+"::val",c,
524 val-8,val-1);
525 if (idx != val)
526 (void) new IntIntVar(Test::str(idx)+"::"+Test::str(val)+"::idx",c,
527 idx-8,idx-1);
528 }
529 /// Perform creation and registration
530 Create(void) {
531 using namespace Gecode;
532 IntArgs ic1({-1,1,-3,3,-4});
533 IntArgs ic2({-1,1,-1,1,-1,1,0,0});
534 IntArgs ic3({-1});
535 IntArgs ic4({0,-1,2,-2,4,-3,6});
536 IntArgs ic5({0,0,1,2,3,4});
537
538 IntArgs bc1({0,1,1,0,1});
539 IntArgs bc2({1,1,0,1,0,1,0,0});
540 IntArgs bc3({1});
541
542 (void) new IntIntVar("A",ic1,-8,8);
543 (void) new IntIntVar("B",ic2,-8,8);
544 (void) new IntIntVar("C",ic3,-8,8);
545 (void) new IntIntVar("D",ic4,-8,8);
546
547 // Test optimizations
548 {
549 int ov[] = {
550 SCHAR_MAX-1,SCHAR_MAX,
551 SHRT_MAX-1,SHRT_MAX,
552 0
553 };
554 for (int i=0; ov[i] != 0; i++)
555 for (int j=0; ov[j] != 0; j++)
556 optimized(ov[i],ov[j]);
557 }
558
559 for (int i=-4; i<=4; i++) {
560 (void) new IntIntInt("A",ic1,i);
561 (void) new IntIntInt("B",ic2,i);
562 (void) new IntIntInt("C",ic3,i);
563 (void) new IntIntInt("D",ic4,i);
564 }
565
566 (void) new IntIntShared("A",ic1);
567 (void) new IntIntShared("B",ic2);
568 (void) new IntIntShared("C",ic3);
569 (void) new IntIntShared("D",ic4);
570 (void) new IntIntShared("E",ic5,1);
571
572 (void) new IntBoolVar("A",bc1);
573 (void) new IntBoolVar("B",bc2);
574 (void) new IntBoolVar("C",bc3);
575
576 for (int i=0; i<=1; i++) {
577 (void) new IntBoolInt("A",bc1,i);
578 (void) new IntBoolInt("B",bc2,i);
579 (void) new IntBoolInt("C",bc3,i);
580 }
581
582 (void) new VarIntVar(IPL_BND);
583 (void) new VarIntVar(IPL_DOM);
584
585 for (int i=-4; i<=4; i++) {
586 (void) new VarIntInt(IPL_BND,i);
587 (void) new VarIntInt(IPL_DOM,i);
588 }
589
590 (void) new VarIntShared(IPL_BND);
591 (void) new VarIntShared(IPL_DOM);
592
593 (void) new VarBoolVar();
594 (void) new VarBoolInt(0);
595 (void) new VarBoolInt(1);
596
597 // Matrix tests
598 (void) new MatrixIntIntVarXY();
599 (void) new MatrixIntIntVarXX();
600 (void) new MatrixIntBoolVarXY();
601 (void) new MatrixIntBoolVarXX();
602
603 (void) new MatrixIntVarIntVarXY();
604 (void) new MatrixIntVarIntVarXX();
605 (void) new MatrixBoolVarBoolVarXY();
606 (void) new MatrixBoolVarBoolVarXX();
607 }
608 };
609
610 Create c;
611 //@}
612
613 }
614}}
615
616// STATISTICS: test-int