← Back to branch summary

~ubuntu-branches/debian/sid/pgadmin3/sid

« back to all changes in this revision

Viewing changes to xtra/pgscript/test/pgsTestObjectGenerator.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Gerfried Fuchs
  • Date: 2009-07-30 12:27:16 UTC
  • mfrom: (1.1.6 upstream)
  • Revision ID: james.westby@ubuntu.com-20090730122716-fddbh42on721bbs2
Tags: 1.10.0-1
* New upstream release.
* Adjusted watch file to match release candidates.
* Updated to Standards-Version 3.8.2:
  - Moved to Section: database.
  - Add DEB_BUILD_OPTIONS support for parallel building.
  - Move from findstring to filter suggestion for DEB_BUILD_OPTIONS parsing.
* pgagent got split into its own separate source package by upstream.
* Exclude Docs.vcproj from installation.
* Move doc-base.enus from pgadmin3 to pgadmin3-data package, the files are
  in there too.

Show diffs side-by-side

added added

removed removed

Lines of Context:
xtra/pgscript/test/pgsTestObjectGenerator.cpp
 
1
//////////////////////////////////////////////////////////////////////////
 
2
//
 
3
// pgScript - PostgreSQL Tools
 
4
// RCS-ID:      $Id: pgsTestObjectGenerator.cpp 7758 2009-03-26 20:49:59Z dpage $
 
5
// Copyright (C) 2002 - 2009, The pgAdmin Development Team
 
6
// This software is released under the BSD Licence
 
7
//
 
8
//////////////////////////////////////////////////////////////////////////
 
9
 
 
10
 
 
11
#include "pgsTestSuite.h"
 
12
 
 
13
#include <wx/file.h>
 
14
#include "pgscript/exceptions/pgsParameterException.h"
 
15
#include "pgscript/expressions/pgsGenDateTime.h"
 
16
#include "pgscript/expressions/pgsGenDate.h"
 
17
#include "pgscript/expressions/pgsGenDictionary.h"
 
18
#include "pgscript/expressions/pgsGenInt.h"
 
19
#include "pgscript/expressions/pgsGenReal.h"
 
20
#include "pgscript/expressions/pgsGenReference.h"
 
21
#include "pgscript/expressions/pgsGenRegex.h"
 
22
#include "pgscript/expressions/pgsGenString.h"
 
23
#include "pgscript/expressions/pgsGenTime.h"
 
24
#include "pgscript/generators/pgsStringGen.h"
 
25
#include "pgscript/objects/pgsNumber.h"
 
26
#include "pgscript/objects/pgsString.h"
 
27
 
 
28
void pgsTestSuite::test_object_generator(void)
 
29
{
 
30
        const int nb_iterations = 20;
 
31
        pgsVarMap vars;
 
32
        
 
33
        ///////////////////////
 
34
        // INTEGER GENERATOR //
 
35
        ///////////////////////
 
36
 
 
37
        // With an integer generator integer(1, 2, false, wxDateTime::GetTimeNow())
 
38
        {
 
39
                // [1] Create the generator
 
40
                pgsExpression * min = pnew pgsNumber(wxT("1"));
 
41
                pgsExpression * max = pnew pgsNumber(wxT("2"));
 
42
                pgsExpression * sequence = pnew pgsNumber(wxT("0"));
 
43
                pgsExpression * seed = pnew pgsNumber(wxString()
 
44
                                << wxDateTime::GetTimeNow());
 
45
                pgsGenInt * gen = 0;
 
46
                gen = pnew pgsGenInt(min, max, sequence, seed);
 
47
                
 
48
                // [2] Check type properties
 
49
                
 
50
                // [3] Check result
 
51
                wxString result;
 
52
                pgsOperand rnd = gen->eval(vars);
 
53
                for (int i = 0; i < nb_iterations; i++)
 
54
                {
 
55
                        result = rnd->eval(vars)->value();
 
56
                        TS_ASSERT(result == wxT("1") || result == wxT("2"));
 
57
                }
 
58
                
 
59
                // [4] Test copy constructor
 
60
                pgsGenInt * copy = pnew pgsGenInt(*gen);
 
61
                TS_ASSERT(copy->value() = gen->value());
 
62
                TS_ASSERT(copy->value() = gen->value());
 
63
                pdelete(copy);
 
64
                
 
65
                // [5] Test assignment operator
 
66
                pgsGenInt * assignment = pnew pgsGenInt(min->clone(), max->clone(),
 
67
                                sequence->clone(), seed->clone());
 
68
                *gen = *assignment;
 
69
                TS_ASSERT(assignment->value() = gen->value());
 
70
                TS_ASSERT(assignment->value() = gen->value());
 
71
                pdelete(assignment);
 
72
                
 
73
                // [6] Delete the generator
 
74
                pdelete(gen);
 
75
        }
 
76
        
 
77
        // With an integer generator integer(-nb_iterations, nb_iterations, true, wxDateTime::GetTimeNow())
 
78
        {
 
79
                // [1] Create the generator
 
80
                pgsExpression * min = pnew pgsNumber(wxString() << -nb_iterations);
 
81
                pgsExpression * max = pnew pgsNumber(wxString() << nb_iterations);
 
82
                pgsExpression * sequence = pnew pgsNumber(wxT("1"));
 
83
                pgsExpression * seed = pnew pgsNumber(wxString()
 
84
                                << wxDateTime::GetTimeNow());
 
85
                pgsGenInt * gen = 0;
 
86
                gen = pnew pgsGenInt(min, max, sequence, seed);
 
87
                
 
88
                // [2] Check type properties
 
89
                
 
90
                // [3] Check result is unique
 
91
                wxString result;
 
92
                wxArrayString sav;
 
93
                pgsOperand rnd = gen->eval(vars);
 
94
                for (int i = 0; i < nb_iterations * 2 + 1; i++)
 
95
                {
 
96
                        result = rnd->eval(vars)->value();
 
97
                        TS_ASSERT(sav.Index(result) == wxNOT_FOUND);
 
98
                        sav.push_back(result);
 
99
                }
 
100
                
 
101
                // [4] Test copy constructor
 
102
                pgsGenInt * copy = pnew pgsGenInt(*gen);
 
103
                TS_ASSERT(copy->value() = gen->value());
 
104
                TS_ASSERT(copy->value() = gen->value());
 
105
                pdelete(copy);
 
106
                
 
107
                // [5] Test assignment operator
 
108
                pgsGenInt * assignment = pnew pgsGenInt(min->clone(), max->clone(),
 
109
                                sequence->clone(), seed->clone());
 
110
                *gen = *assignment;
 
111
                TS_ASSERT(assignment->value() = gen->value());
 
112
                TS_ASSERT(assignment->value() = gen->value());
 
113
                pdelete(assignment);
 
114
                
 
115
                // [6] Delete the generator
 
116
                pdelete(gen);
 
117
        }
 
118
        
 
119
        // With an invalid integer generator integer(1, 2.0, false, wxDateTime::GetTimeNow())
 
120
        {
 
121
                // [1] Create the generator
 
122
                pgsExpression * min = pnew pgsNumber(wxT("1"));
 
123
                pgsExpression * max = pnew pgsNumber(wxT("2.0"), pgsReal);
 
124
                pgsExpression * sequence = pnew pgsNumber(wxT("0"));
 
125
                pgsExpression * seed = pnew pgsNumber(wxString()
 
126
                                << wxDateTime::GetTimeNow());
 
127
                pgsGenInt * gen = 0;
 
128
                gen = pnew pgsGenInt(min, max, sequence, seed);
 
129
                
 
130
                // [2] Check type properties
 
131
                
 
132
                // [3] Check that the result is invalid
 
133
                try
 
134
                {
 
135
                        gen->eval(vars);
 
136
                        TS_ASSERT(false);
 
137
                }
 
138
                catch (const pgsParameterException &)
 
139
                {
 
140
                        // Parameters are not correct: exception expected
 
141
                }
 
142
                
 
143
                // [4] Delete the generator
 
144
                pdelete(gen);
 
145
        }
 
146
        
 
147
        ////////////////////
 
148
        // REAL GENERATOR //
 
149
        ////////////////////
 
150
 
 
151
        // With a real generator real(80, 118.123456789, 6, false, wxDateTime::GetTimeNow())
 
152
        {
 
153
                // [1] Create the generator
 
154
                pgsExpression * min = pnew pgsNumber(wxT("80"));
 
155
                pgsExpression * max = pnew pgsNumber(wxT("118.123456789"), pgsReal);
 
156
                pgsExpression * precision = pnew pgsNumber(wxT("6"));
 
157
                pgsExpression * sequence = pnew pgsNumber(wxT("0"));
 
158
                pgsExpression * seed = pnew pgsNumber(wxString()
 
159
                                << wxDateTime::GetTimeNow());
 
160
                pgsGenReal * gen = 0;
 
161
                gen = pnew pgsGenReal(min, max, precision, sequence, seed);
 
162
                
 
163
                // [2] Check type properties
 
164
                
 
165
                // [3] Check result
 
166
                wxString result;
 
167
                pgsOperand rnd = gen->eval(vars);
 
168
                for (int i = 0; i < nb_iterations; i++)
 
169
                {
 
170
                        result = rnd->eval(vars)->value();
 
171
                        TS_ASSERT(MAPM(result.mb_str()) >= "80");
 
172
                        TS_ASSERT(MAPM(result.mb_str()) <= "118.123456");
 
173
                }
 
174
                
 
175
                // [4] Test copy constructor
 
176
                pgsGenReal * copy = pnew pgsGenReal(*gen);
 
177
                TS_ASSERT(copy->value() = gen->value());
 
178
                TS_ASSERT(copy->value() = gen->value());
 
179
                pdelete(copy);
 
180
                
 
181
                // [5] Test assignment operator
 
182
                pgsGenReal * assignment = pnew pgsGenReal(min->clone(), max->clone(),
 
183
                                precision->clone(), sequence->clone(), seed->clone());
 
184
                *gen = *assignment;
 
185
                TS_ASSERT(assignment->value() = gen->value());
 
186
                TS_ASSERT(assignment->value() = gen->value());
 
187
                pdelete(assignment);
 
188
                
 
189
                // [6] Delete the generator
 
190
                pdelete(gen);
 
191
        }
 
192
 
 
193
        // With a real generator (invalid precision) real(80, 90, 6.3, false, wxDateTime::GetTimeNow())
 
194
        {
 
195
                // [1] Create the generator
 
196
                pgsExpression * min = pnew pgsNumber(wxT("80"));
 
197
                pgsExpression * max = pnew pgsNumber(wxT("90"));
 
198
                pgsExpression * precision = pnew pgsNumber(wxT("6.3"), pgsReal);
 
199
                pgsExpression * sequence = pnew pgsNumber(wxT("0"));
 
200
                pgsExpression * seed = pnew pgsNumber(wxString()
 
201
                                << wxDateTime::GetTimeNow());
 
202
                pgsGenReal * gen = 0;
 
203
                gen = pnew pgsGenReal(min, max, precision, sequence, seed);
 
204
                
 
205
                // [2] Check type properties
 
206
                
 
207
                // [3] Check that the result is invalid
 
208
                try
 
209
                {
 
210
                        gen->eval(vars);
 
211
                        TS_ASSERT(false);
 
212
                }
 
213
                catch (const pgsParameterException &)
 
214
                {
 
215
                        // Parameters are not correct: exception expected
 
216
                }
 
217
                
 
218
                // [4] Delete the generator
 
219
                pdelete(gen);
 
220
        }
 
221
 
 
222
        // With a real generator (invalid sequence identifier) real(80, 90, 5, 5.0, wxDateTime::GetTimeNow())
 
223
        {
 
224
                // [1] Create the generator
 
225
                pgsExpression * min = pnew pgsNumber(wxT("80"));
 
226
                pgsExpression * max = pnew pgsNumber(wxT("90"));
 
227
                pgsExpression * precision = pnew pgsNumber(wxT("5"));
 
228
                pgsExpression * sequence = pnew pgsNumber(wxT("5.0"), pgsReal);
 
229
                pgsExpression * seed = pnew pgsNumber(wxString()
 
230
                                << wxDateTime::GetTimeNow());
 
231
                pgsGenReal * gen = 0;
 
232
                gen = pnew pgsGenReal(min, max, precision, sequence, seed);
 
233
                
 
234
                // [2] Check type properties
 
235
                
 
236
                // [3] Check that the result is invalid
 
237
                try
 
238
                {
 
239
                        gen->eval(vars);
 
240
                        TS_ASSERT(false);
 
241
                }
 
242
                catch (const pgsParameterException &)
 
243
                {
 
244
                        // Parameters are not correct: exception expected
 
245
                }
 
246
                
 
247
                // [4] Delete the generator
 
248
                pdelete(gen);
 
249
        }
 
250
        
 
251
        //////////////////////
 
252
        // STRING GENERATOR //
 
253
        //////////////////////
 
254
 
 
255
        // With a string generator string(5, 40, 5, 123456789L)
 
256
        {
 
257
                // [1] Create the generator
 
258
                pgsExpression * min = pnew pgsNumber(wxT("5"));
 
259
                pgsExpression * max = pnew pgsNumber(wxT("40"));
 
260
                pgsExpression * nb_words = pnew pgsNumber(wxT("5"));
 
261
                pgsExpression * seed = pnew pgsNumber(wxT("123456789"));
 
262
                pgsGenString * gen = pnew pgsGenString(min, max, nb_words, seed);
 
263
                
 
264
                // [2] Check type properties
 
265
                
 
266
                // [3] Check result
 
267
                pgsStringGen comparator(5, 40, 5, 123456789L);
 
268
                wxString result;
 
269
                pgsOperand rnd = gen->eval(vars);
 
270
                for (int i = 0; i < nb_iterations; i++)
 
271
                {
 
272
                        result = rnd->eval(vars)->value();
 
273
                        TS_ASSERT(result == comparator.random());
 
274
                }
 
275
                
 
276
                // [4] Test copy constructor
 
277
                pgsGenString * copy = pnew pgsGenString(*gen);
 
278
                TS_ASSERT(copy->value() = gen->value());
 
279
                TS_ASSERT(copy->value() = gen->value());
 
280
                pdelete(copy);
 
281
                
 
282
                // [5] Test assignment operator
 
283
                pgsGenString * assignment = pnew pgsGenString(min->clone(),
 
284
                                max->clone(), nb_words->clone(), seed->clone());
 
285
                *gen = *assignment;
 
286
                TS_ASSERT(assignment->value() = gen->value());
 
287
                TS_ASSERT(assignment->value() = gen->value());
 
288
                pdelete(assignment);
 
289
                
 
290
                // [6] Delete the generator
 
291
                pdelete(gen);
 
292
        }
 
293
 
 
294
        // With a string generator (invalid number of words) string(5, 40, 5.5, 123456789L)
 
295
        {
 
296
                // [1] Create the generator
 
297
                pgsExpression * min = pnew pgsNumber(wxT("5"));
 
298
                pgsExpression * max = pnew pgsNumber(wxT("40"));
 
299
                pgsExpression * nb_words = pnew pgsNumber(wxT("5.5"),
 
300
                                pgsReal);
 
301
                pgsExpression * seed = pnew pgsNumber(wxT("123456789"));
 
302
                pgsGenString * gen = 0;
 
303
                gen = pnew pgsGenString(min, max, nb_words, seed);
 
304
                
 
305
                // [2] Check type properties
 
306
                
 
307
                // [2] Check that the result is invalid
 
308
                try
 
309
                {
 
310
                        gen->eval(vars);
 
311
                        TS_ASSERT(false);
 
312
                }
 
313
                catch (const pgsParameterException &)
 
314
                {
 
315
                        // Parameters are not correct: exception expected
 
316
                }
 
317
                
 
318
                // [4] Delete the generator
 
319
                pdelete(gen);
 
320
        }
 
321
        
 
322
        /////////////////////////
 
323
        // DATE_TIME GENERATOR //
 
324
        /////////////////////////
 
325
        
 
326
        // With a date_time generator date_time(2008-01-01 00:00:00,
 
327
        //                                      2008-01-01 05:00:00, false, wxDateTime::GetTimeNow())
 
328
        {
 
329
                // [1] Create the generator
 
330
                pgsExpression * min = pnew pgsString(wxT("2008-01-01 00:00:00"));
 
331
                pgsExpression * max = pnew pgsString(wxT("2008-01-01 05:00:00"));
 
332
                pgsExpression * sequence = pnew pgsNumber(wxT("0"));
 
333
                pgsExpression * seed = pnew pgsNumber(wxString()
 
334
                                << wxDateTime::GetTimeNow());
 
335
                pgsGenDateTime * gen = 0;
 
336
                gen = pnew pgsGenDateTime(min, max, sequence, seed);
 
337
                
 
338
                // [2] Check type properties
 
339
                
 
340
                // [3] Check result
 
341
                wxString result;
 
342
                pgsOperand rnd = gen->eval(vars);
 
343
                for (int i = 0; i < nb_iterations; i++)
 
344
                {
 
345
                        result = rnd->eval(vars)->value();
 
346
                        TS_ASSERT(result.StartsWith(wxT("2008-01-01 0")));
 
347
                }
 
348
                
 
349
                // [4] Test copy constructor
 
350
                pgsGenDateTime * copy = pnew pgsGenDateTime(*gen);
 
351
                TS_ASSERT(copy->value() = gen->value());
 
352
                TS_ASSERT(copy->value() = gen->value());
 
353
                pdelete(copy);
 
354
                
 
355
                // [5] Test assignment operator
 
356
                pgsGenDateTime * assignment = pnew pgsGenDateTime(min->clone(),
 
357
                                max->clone(), sequence->clone(), seed->clone());
 
358
                *gen = *assignment;
 
359
                TS_ASSERT(assignment->value() = gen->value());
 
360
                TS_ASSERT(assignment->value() = gen->value());
 
361
                pdelete(assignment);
 
362
                
 
363
                // [6] Delete the generator
 
364
                pdelete(gen);
 
365
        }
 
366
        
 
367
        // With an invalid date_time generator date_time(20080101,
 
368
        //                                      20080101, false, wxDateTime::GetTimeNow())
 
369
        // DateTime parameters are numbers
 
370
        {
 
371
                // [1] Create the generator
 
372
                pgsExpression * min = pnew pgsNumber(wxT("20080101"));
 
373
                pgsExpression * max = pnew pgsString(wxT("20080101"));
 
374
                pgsExpression * sequence = pnew pgsNumber(wxT("0"));
 
375
                pgsExpression * seed = pnew pgsNumber(wxString()
 
376
                                << wxDateTime::GetTimeNow());
 
377
                pgsGenDateTime * gen = 0;
 
378
                gen = pnew pgsGenDateTime(min, max, sequence, seed);
 
379
                
 
380
                // [2] Check type properties
 
381
                
 
382
                // [3] Check that the result is invalid
 
383
                try
 
384
                {
 
385
                        gen->eval(vars);
 
386
                        TS_ASSERT(false);
 
387
                }
 
388
                catch (const pgsParameterException &)
 
389
                {
 
390
                        // Parameters are not correct: exception expected
 
391
                }
 
392
                
 
393
                // [4] Delete the generator
 
394
                pdelete(gen);
 
395
        }
 
396
        
 
397
        // With an invalid date_time generator date_time(20080101,
 
398
        //                                      20080101, false, wxDateTime::GetTimeNow())
 
399
        // DateTime parameters are numbers
 
400
        {
 
401
                // [1] Create the generator
 
402
                pgsExpression * min = pnew pgsString(wxT("20080101"));
 
403
                pgsExpression * max = pnew pgsNumber(wxT("20080101"));
 
404
                pgsExpression * sequence = pnew pgsNumber(wxT("0"));
 
405
                pgsExpression * seed = pnew pgsNumber(wxString()
 
406
                                << wxDateTime::GetTimeNow());
 
407
                pgsGenDateTime * gen = 0;
 
408
                gen = pnew pgsGenDateTime(min, max, sequence, seed);
 
409
                
 
410
                // [2] Check type properties
 
411
                
 
412
                // [3] Check that the result is invalid
 
413
                try
 
414
                {
 
415
                        gen->eval(vars);
 
416
                        TS_ASSERT(false);
 
417
                }
 
418
                catch (const pgsParameterException &)
 
419
                {
 
420
                        // Parameters are not correct: exception expected
 
421
                }
 
422
                
 
423
                // [4] Delete the generator
 
424
                pdelete(gen);
 
425
        }
 
426
        
 
427
        // With an invalid date_time generator date_time(2008-01-01 00:00:00,
 
428
        //                                      2008-2008-2008 05:00:00, false, wxDateTime::GetTimeNow())
 
429
        {
 
430
                // [1] Create the generator
 
431
                pgsExpression * min = pnew pgsString(wxT("2008-01-01 00:00:00"));
 
432
                pgsExpression * max = pnew pgsString(wxT("2008-2008-2008 05:00:00"));
 
433
                pgsExpression * sequence = pnew pgsNumber(wxT("0"));
 
434
                pgsExpression * seed = pnew pgsNumber(wxString()
 
435
                                << wxDateTime::GetTimeNow());
 
436
                pgsGenDateTime * gen = 0;
 
437
                gen = pnew pgsGenDateTime(min, max, sequence, seed);
 
438
                
 
439
                // [2] Check type properties
 
440
                
 
441
                // [3] Check that the result is invalid
 
442
                try
 
443
                {
 
444
                        gen->eval(vars);
 
445
                        TS_ASSERT(false);
 
446
                }
 
447
                catch (const pgsParameterException &)
 
448
                {
 
449
                        // Parameters are not correct: exception expected
 
450
                }
 
451
                
 
452
                // [4] Delete the generator
 
453
                pdelete(gen);
 
454
        }
 
455
        
 
456
        ////////////////////
 
457
        // DATE GENERATOR //
 
458
        ////////////////////
 
459
        
 
460
        // With a date generator date(2008-01-01, 2008-01-02, false, wxDateTime::GetTimeNow())
 
461
        {
 
462
                // [1] Create the generator
 
463
                pgsExpression * min = pnew pgsString(wxT("2008-01-01"));
 
464
                pgsExpression * max = pnew pgsString(wxT("2008-01-02"));
 
465
                pgsExpression * sequence = pnew pgsNumber(wxT("0"));
 
466
                pgsExpression * seed = pnew pgsNumber(wxString()
 
467
                                << wxDateTime::GetTimeNow());
 
468
                pgsGenDate * gen = 0;
 
469
                gen = pnew pgsGenDate(min, max, sequence, seed);
 
470
                
 
471
                // [2] Check type properties
 
472
                
 
473
                // [3] Check result
 
474
                wxString result;
 
475
                pgsOperand rnd = gen->eval(vars);
 
476
                for (int i = 0; i < nb_iterations; i++)
 
477
                {
 
478
                        result = rnd->eval(vars)->value();
 
479
                        TS_ASSERT(result == wxT("2008-01-01") || result == wxT("2008-01-02"));
 
480
                }
 
481
                
 
482
                // [4] Test copy constructor
 
483
                pgsGenDate * copy = pnew pgsGenDate(*gen);
 
484
                TS_ASSERT(copy->value() = gen->value());
 
485
                TS_ASSERT(copy->value() = gen->value());
 
486
                pdelete(copy);
 
487
                
 
488
                // [5] Test assignment operator
 
489
                pgsGenDate * assignment = pnew pgsGenDate(min->clone(), max->clone(),
 
490
                                sequence->clone(), seed->clone());
 
491
                *gen = *assignment;
 
492
                TS_ASSERT(assignment->value() = gen->value());
 
493
                TS_ASSERT(assignment->value() = gen->value());
 
494
                pdelete(assignment);
 
495
                
 
496
                // [6] Delete the generator
 
497
                pdelete(gen);
 
498
        }
 
499
        
 
500
        // With an invalid date generator date(20080101, 20080101, false, wxDateTime::GetTimeNow())
 
501
        // Date parameters are numbers
 
502
        {
 
503
                // [1] Create the generator
 
504
                pgsExpression * min = pnew pgsNumber(wxT("20080101"));
 
505
                pgsExpression * max = pnew pgsString(wxT("20080101"));
 
506
                pgsExpression * sequence = pnew pgsNumber(wxT("0"));
 
507
                pgsExpression * seed = pnew pgsNumber(wxString()
 
508
                                << wxDateTime::GetTimeNow());
 
509
                pgsGenDate * gen = 0;
 
510
                gen = pnew pgsGenDate(min, max, sequence, seed);
 
511
                
 
512
                // [2] Check type properties
 
513
                
 
514
                // [3] Check that the result is invalid
 
515
                try
 
516
                {
 
517
                        gen->eval(vars);
 
518
                        TS_ASSERT(false);
 
519
                }
 
520
                catch (const pgsParameterException &)
 
521
                {
 
522
                        // Parameters are not correct: exception expected
 
523
                }
 
524
                
 
525
                // [4] Delete the generator
 
526
                pdelete(gen);
 
527
        }
 
528
        
 
529
        // With an invalid date generator date(20080101, 20080101, false, wxDateTime::GetTimeNow())
 
530
        // Date parameters are numbers
 
531
        {
 
532
                // [1] Create the generator
 
533
                pgsExpression * min = pnew pgsString(wxT("20080101"));
 
534
                pgsExpression * max = pnew pgsNumber(wxT("20080101"));
 
535
                pgsExpression * sequence = pnew pgsNumber(wxT("0"));
 
536
                pgsExpression * seed = pnew pgsNumber(wxString()
 
537
                                << wxDateTime::GetTimeNow());
 
538
                pgsGenDate * gen = 0;
 
539
                gen = pnew pgsGenDate(min, max, sequence, seed);
 
540
                
 
541
                // [2] Check type properties
 
542
                
 
543
                // [3] Check that the result is invalid
 
544
                try
 
545
                {
 
546
                        gen->eval(vars);
 
547
                        TS_ASSERT(false);
 
548
                }
 
549
                catch (const pgsParameterException &)
 
550
                {
 
551
                        // Parameters are not correct: exception expected
 
552
                }
 
553
                
 
554
                // [4] Delete the generator
 
555
                pdelete(gen);
 
556
        }
 
557
        
 
558
        // With an invalid date generator date(2008-01-01, 2008-2008-2008, false, wxDateTime::GetTimeNow())
 
559
        {
 
560
                // [1] Create the generator
 
561
                pgsExpression * min = pnew pgsString(wxT("2008-01-01"));
 
562
                pgsExpression * max = pnew pgsString(wxT("2008-2008-2008"));
 
563
                pgsExpression * sequence = pnew pgsNumber(wxT("0"));
 
564
                pgsExpression * seed = pnew pgsNumber(wxString()
 
565
                                << wxDateTime::GetTimeNow());
 
566
                pgsGenDate * gen = 0;
 
567
                gen = pnew pgsGenDate(min, max, sequence, seed);
 
568
                
 
569
                // [2] Check type properties
 
570
                
 
571
                // [3] Check that the result is invalid
 
572
                try
 
573
                {
 
574
                        gen->eval(vars);
 
575
                        TS_ASSERT(false);
 
576
                }
 
577
                catch (const pgsParameterException &)
 
578
                {
 
579
                        // Parameters are not correct: exception expected
 
580
                }
 
581
                
 
582
                // [4] Delete the generator
 
583
                pdelete(gen);
 
584
        }
 
585
        
 
586
        ////////////////////
 
587
        // TIME GENERATOR //
 
588
        ////////////////////
 
589
        
 
590
        // With a time generator time(05:30:00, 05:30:10, false, wxDateTime::GetTimeNow())
 
591
        {
 
592
                // [1] Create the generator
 
593
                pgsExpression * min = pnew pgsString(wxT("05:30:00"));
 
594
                pgsExpression * max = pnew pgsString(wxT("05:30:10"));
 
595
                pgsExpression * sequence = pnew pgsNumber(wxT("0"));
 
596
                pgsExpression * seed = pnew pgsNumber(wxString()
 
597
                                << wxDateTime::GetTimeNow());
 
598
                pgsGenTime * gen = 0;
 
599
                gen = pnew pgsGenTime(min, max, sequence, seed);
 
600
                
 
601
                // [2] Check type properties
 
602
                
 
603
                // [3] Check result
 
604
                wxString result;
 
605
                pgsOperand rnd = gen->eval(vars);
 
606
                for (int i = 0; i < nb_iterations; i++)
 
607
                {
 
608
                        result = rnd->eval(vars)->value();
 
609
                        TS_ASSERT(result.StartsWith(wxT("05:30:")));
 
610
                }
 
611
                
 
612
                // [4] Test copy constructor
 
613
                pgsGenTime * copy = pnew pgsGenTime(*gen);
 
614
                TS_ASSERT(copy->value() = gen->value());
 
615
                TS_ASSERT(copy->value() = gen->value());
 
616
                pdelete(copy);
 
617
                
 
618
                // [5] Test assignment operator
 
619
                pgsGenTime * assignment = pnew pgsGenTime(min->clone(), max->clone(),
 
620
                                sequence->clone(), seed->clone());
 
621
                *gen = *assignment;
 
622
                TS_ASSERT(assignment->value() = gen->value());
 
623
                TS_ASSERT(assignment->value() = gen->value());
 
624
                pdelete(assignment);
 
625
                
 
626
                // [6] Delete the generator
 
627
                pdelete(gen);
 
628
        }
 
629
        
 
630
        // With an invalid time generator time(120000, 120000, false, wxDateTime::GetTimeNow())
 
631
        // DateTime parameters are numbers
 
632
        {
 
633
                // [1] Create the generator
 
634
                pgsExpression * min = pnew pgsNumber(wxT("120000"));
 
635
                pgsExpression * max = pnew pgsString(wxT("120000"));
 
636
                pgsExpression * sequence = pnew pgsNumber(wxT("0"));
 
637
                pgsExpression * seed = pnew pgsNumber(wxString()
 
638
                                << wxDateTime::GetTimeNow());
 
639
                pgsGenTime * gen = 0;
 
640
                gen = pnew pgsGenTime(min, max, sequence, seed);
 
641
                
 
642
                // [2] Check type properties
 
643
                
 
644
                // [3] Check that the result is invalid
 
645
                try
 
646
                {
 
647
                        gen->eval(vars);
 
648
                        TS_ASSERT(false);
 
649
                }
 
650
                catch (const pgsParameterException &)
 
651
                {
 
652
                        // Parameters are not correct: exception expected
 
653
                }
 
654
                
 
655
                // [4] Delete the generator
 
656
                pdelete(gen);
 
657
        }
 
658
        
 
659
        // With an invalid time generator time(120000, 120000, false, wxDateTime::GetTimeNow())
 
660
        // DateTime parameters are numbers
 
661
        {
 
662
                // [1] Create the generator
 
663
                pgsExpression * min = pnew pgsString(wxT("120000"));
 
664
                pgsExpression * max = pnew pgsNumber(wxT("120000"));
 
665
                pgsExpression * sequence = pnew pgsNumber(wxT("0"));
 
666
                pgsExpression * seed = pnew pgsNumber(wxString()
 
667
                                << wxDateTime::GetTimeNow());
 
668
                pgsGenTime * gen = 0;
 
669
                gen = pnew pgsGenTime(min, max, sequence, seed);
 
670
                
 
671
                // [2] Check type properties
 
672
                
 
673
                // [3] Check that the result is invalid
 
674
                try
 
675
                {
 
676
                        gen->eval(vars);
 
677
                        TS_ASSERT(false);
 
678
                }
 
679
                catch (const pgsParameterException &)
 
680
                {
 
681
                        // Parameters are not correct: exception expected
 
682
                }
 
683
                
 
684
                // [4] Delete the generator
 
685
                pdelete(gen);
 
686
        }
 
687
        
 
688
        // With an invalid time generator time(80:80:80, 85:85:85, false, wxDateTime::GetTimeNow())
 
689
        {
 
690
                // [1] Create the generator
 
691
                pgsExpression * min = pnew pgsString(wxT("80:80:80"));
 
692
                pgsExpression * max = pnew pgsString(wxT("85:85:85"));
 
693
                pgsExpression * sequence = pnew pgsNumber(wxT("0"));
 
694
                pgsExpression * seed = pnew pgsNumber(wxString()
 
695
                                << wxDateTime::GetTimeNow());
 
696
                pgsGenTime * gen = 0;
 
697
                gen = pnew pgsGenTime(min, max, sequence, seed);
 
698
                
 
699
                // [2] Check type properties
 
700
                
 
701
                // [3] Check that the result is invalid
 
702
                try
 
703
                {
 
704
                        gen->eval(vars);
 
705
                        TS_ASSERT(false);
 
706
                }
 
707
                catch (const pgsParameterException &)
 
708
                {
 
709
                        // Parameters are not correct: exception expected
 
710
                }
 
711
                
 
712
                // [4] Delete the generator
 
713
                pdelete(gen);
 
714
        }
 
715
        
 
716
        /////////////////////////
 
717
        // REFERENCE GENERATOR //
 
718
        /////////////////////////
 
719
        
 
720
        // Nothing can work because there is no valid connection provided to
 
721
        // the pgsGenReference
 
722
        {
 
723
                // [1] Create the generator
 
724
                pgsExpression * table = 0;
 
725
                table = pnew pgsString(wxT("table"));
 
726
                pgsExpression * column = 0;
 
727
                column = pnew pgsString(wxT("column"));
 
728
                pgsExpression * sequence = 0;
 
729
                sequence = pnew pgsNumber(wxT("0"));
 
730
                pgsExpression * seed = 0;
 
731
                seed = pnew pgsNumber(wxString() << wxDateTime::GetTimeNow());
 
732
                pgsGenReference * gen = 0;
 
733
                gen = pnew pgsGenReference(table, column, sequence, seed);
 
734
                
 
735
                // [2] Check type properties
 
736
                
 
737
                // [3] Check result
 
738
                try
 
739
                {
 
740
                        gen->eval(vars);
 
741
                        TS_ASSERT(false);
 
742
                }
 
743
                catch (const pgsParameterException &)
 
744
                {
 
745
                        
 
746
                }
 
747
                
 
748
                // [4] Test copy constructor
 
749
                pgsGenReference * copy = 0;
 
750
                copy = pnew pgsGenReference(*gen);
 
751
                TS_ASSERT(copy->value() = gen->value());
 
752
                TS_ASSERT(copy->value() = gen->value());
 
753
                try
 
754
                {
 
755
                        copy->eval(vars);
 
756
                        TS_ASSERT(false);
 
757
                }
 
758
                catch (const pgsParameterException &)
 
759
                {
 
760
                        
 
761
                }
 
762
                pdelete(copy);
 
763
                
 
764
                // [5] Test assignment operator
 
765
                pgsGenReference * assignment = 0;
 
766
                assignment = pnew pgsGenReference(table->clone(),
 
767
                                column->clone(), sequence->clone(), seed->clone());
 
768
                *gen = *assignment;
 
769
                TS_ASSERT(assignment->value() = gen->value());
 
770
                TS_ASSERT(assignment->value() = gen->value());
 
771
                try
 
772
                {
 
773
                        assignment->eval(vars);
 
774
                        TS_ASSERT(false);
 
775
                }
 
776
                catch (const pgsParameterException &)
 
777
                {
 
778
                        
 
779
                }
 
780
                pdelete(assignment);
 
781
                
 
782
                // [6] Delete the generator
 
783
                pdelete(gen);
 
784
        }
 
785
        
 
786
        // Use an empty string for the table
 
787
        {
 
788
                // [1] Create the generator
 
789
                pgsExpression * table = pnew pgsString(wxT(""));
 
790
                pgsExpression * column = pnew pgsString(wxT("column"));
 
791
                pgsExpression * sequence = pnew pgsNumber(wxT("0"));
 
792
                pgsExpression * seed = pnew pgsNumber(wxString()
 
793
                                << wxDateTime::GetTimeNow());
 
794
                pgsGenReference * gen = 0;
 
795
                gen = pnew pgsGenReference(table, column, sequence, seed);
 
796
                
 
797
                // [2] Check type properties
 
798
                
 
799
                // [3] Check result
 
800
                try
 
801
                {
 
802
                        gen->eval(vars);
 
803
                        TS_ASSERT(false);
 
804
                }
 
805
                catch (const pgsParameterException &)
 
806
                {
 
807
                        
 
808
                }
 
809
                
 
810
                // ...
 
811
                
 
812
                // [6] Delete the generator
 
813
                pdelete(gen);
 
814
        }
 
815
        
 
816
        // Use an empty string for the column
 
817
        {
 
818
                // [1] Create the generator
 
819
                pgsExpression * table = pnew pgsString(wxT("table"));
 
820
                pgsExpression * column = pnew pgsString(wxT(""));
 
821
                pgsExpression * sequence = pnew pgsNumber(wxT("0"));
 
822
                pgsExpression * seed = pnew pgsNumber(wxString()
 
823
                                << wxDateTime::GetTimeNow());
 
824
                pgsGenReference * gen = 0;
 
825
                gen = pnew pgsGenReference(table, column, sequence, seed);
 
826
                
 
827
                // [2] Check type properties
 
828
                
 
829
                // [3] Check result
 
830
                try
 
831
                {
 
832
                        gen->eval(vars);
 
833
                        TS_ASSERT(false);
 
834
                }
 
835
                catch (const pgsParameterException &)
 
836
                {
 
837
                        
 
838
                }
 
839
                
 
840
                // ...
 
841
                
 
842
                // [6] Delete the generator
 
843
                pdelete(gen);
 
844
        }
 
845
        
 
846
        // Use a number for the table
 
847
        {
 
848
                // [1] Create the generator
 
849
                pgsExpression * table = pnew pgsNumber(wxT("123"));
 
850
                pgsExpression * column = pnew pgsString(wxT("column"));
 
851
                pgsExpression * sequence = pnew pgsNumber(wxT("0"));
 
852
                pgsExpression * seed = pnew pgsNumber(wxString()
 
853
                                << wxDateTime::GetTimeNow());
 
854
                pgsGenReference * gen = 0;
 
855
                gen = pnew pgsGenReference(table, column, sequence, seed);
 
856
                
 
857
                // [2] Check type properties
 
858
                
 
859
                // [3] Check result
 
860
                try
 
861
                {
 
862
                        gen->eval(vars);
 
863
                        TS_ASSERT(false);
 
864
                }
 
865
                catch (const pgsParameterException &)
 
866
                {
 
867
                        
 
868
                }
 
869
                
 
870
                // ...
 
871
                
 
872
                // [6] Delete the generator
 
873
                pdelete(gen);
 
874
        }
 
875
        
 
876
        // Use a number for the column
 
877
        {
 
878
                // [1] Create the generator
 
879
                pgsExpression * table = pnew pgsString(wxT("table"));
 
880
                pgsExpression * column = pnew pgsNumber(wxT("123"));
 
881
                pgsExpression * sequence = pnew pgsNumber(wxT("0"));
 
882
                pgsExpression * seed = pnew pgsNumber(wxString()
 
883
                                << wxDateTime::GetTimeNow());
 
884
                pgsGenReference * gen = 0;
 
885
                gen = pnew pgsGenReference(table, column, sequence, seed);
 
886
                
 
887
                // [2] Check type properties
 
888
                
 
889
                // [3] Check result
 
890
                try
 
891
                {
 
892
                        gen->eval(vars);
 
893
                        TS_ASSERT(false);
 
894
                }
 
895
                catch (const pgsParameterException &)
 
896
                {
 
897
                        
 
898
                }
 
899
                
 
900
                // ...
 
901
                
 
902
                // [6] Delete the generator
 
903
                pdelete(gen);
 
904
        }
 
905
        
 
906
        /////////////////////
 
907
        // REGEX GENERATOR //
 
908
        /////////////////////
 
909
        
 
910
        // With a regex generator regex(abc{2}[a-z]{1,50}, wxDateTime::GetTimeNow())
 
911
        {
 
912
                // [1] Create the generator
 
913
                pgsExpression * regex = pnew pgsString(wxT("abc{2}[a-z]{1,50}"));
 
914
                pgsExpression * seed = pnew pgsNumber(wxString()
 
915
                                << wxDateTime::GetTimeNow());
 
916
                pgsGenRegex * gen = 0;
 
917
                gen = pnew pgsGenRegex(regex, seed);
 
918
                
 
919
                // [2] Check type properties
 
920
                
 
921
                // [3] Check result
 
922
                wxString result;
 
923
                pgsOperand rnd = gen->eval(vars);
 
924
                for (int i = 0; i < nb_iterations; i++)
 
925
                {
 
926
                        result = rnd->eval(vars)->value();
 
927
                        TS_ASSERT(result.StartsWith(wxT("abcc")));
 
928
                }
 
929
                
 
930
                // [4] Test copy constructor
 
931
                pgsGenRegex * copy = pnew pgsGenRegex(*gen);
 
932
                TS_ASSERT(copy->value() = gen->value());
 
933
                TS_ASSERT(copy->value() = gen->value());
 
934
                pdelete(copy);
 
935
                
 
936
                // [5] Test assignment operator
 
937
                pgsGenRegex * assignment = pnew pgsGenRegex(regex->clone(),
 
938
                                seed->clone());
 
939
                *gen = *assignment;
 
940
                TS_ASSERT(assignment->value() = gen->value());
 
941
                TS_ASSERT(assignment->value() = gen->value());
 
942
                pdelete(assignment);
 
943
                
 
944
                // [6] Delete the generator
 
945
                pdelete(gen);
 
946
        }
 
947
        
 
948
        // With an invalid regex generator regex(123, wxDateTime::GetTimeNow())
 
949
        // The regex is a number
 
950
        {
 
951
                // [1] Create the generator
 
952
                pgsExpression * regex = pnew pgsNumber(wxT("123"));
 
953
                pgsExpression * seed = pnew pgsNumber(wxString()
 
954
                                << wxDateTime::GetTimeNow());
 
955
                pgsGenRegex * gen = 0;
 
956
                gen = pnew pgsGenRegex(regex, seed);
 
957
                
 
958
                // [2] Check type properties
 
959
                
 
960
                // [3] Check that the result is invalid
 
961
                try
 
962
                {
 
963
                        gen->eval(vars);
 
964
                        TS_ASSERT(false);
 
965
                }
 
966
                catch (const pgsParameterException &)
 
967
                {
 
968
                        // Parameters are not correct: exception expected
 
969
                }
 
970
                
 
971
                // [4] Delete the generator
 
972
                pdelete(gen);
 
973
        }
 
974
        
 
975
        // With an invalid regex generator regex([ab{], wxDateTime::GetTimeNow())
 
976
        // The regex is a number
 
977
        {
 
978
                // [1] Create the generator
 
979
                pgsExpression * regex = pnew pgsString(wxT("[ab{]"));
 
980
                pgsExpression * seed = pnew pgsNumber(wxString()
 
981
                                << wxDateTime::GetTimeNow());
 
982
                pgsGenRegex * gen = 0;
 
983
                gen = pnew pgsGenRegex(regex, seed);
 
984
                
 
985
                // [2] Check type properties
 
986
                
 
987
                // [3] Check that the result is invalid
 
988
                try
 
989
                {
 
990
                        gen->eval(vars);
 
991
                        TS_ASSERT(false);
 
992
                }
 
993
                catch (const pgsParameterException &)
 
994
                {
 
995
                        // Parameters are not correct: exception expected
 
996
                }
 
997
                
 
998
                // [4] Delete the generator
 
999
                pdelete(gen);
 
1000
        }
 
1001
        
 
1002
        //////////////////////////
 
1003
        // DICTIONARY GENERATOR //
 
1004
        //////////////////////////
 
1005
        
 
1006
        const wxString dictionary = wxT("cities.txt"); // More than 2 lines
 
1007
        wxCSConv conv(wxT("utf-8")); // Encoding used for creating the dictionary
 
1008
        
 
1009
        // Content of the dictionary
 
1010
        wxString example =      wxT("DixieWorld\n")
 
1011
                                                wxT("SnoRite\n")
 
1012
                                                wxT("SunGlo\n")
 
1013
                                                wxT("Ozark Park\n")
 
1014
                                                wxT("Like\n")
 
1015
                                                wxT("Healthy Heights\n")
 
1016
                                                wxT("Insure\n")
 
1017
                                                wxT("First National State\n")
 
1018
                                                wxT("AmeriBeach\n")
 
1019
                                                wxT("Peaches N' More\n")
 
1020
                                                wxT("Isle B Seaing U\n")
 
1021
                                                wxT("Perpetua\n")
 
1022
                                                wxT("Chi+\n")
 
1023
                                                wxT("Town and Country\n")
 
1024
                                                wxT("Sunny Farms\n")
 
1025
                                                wxT("Midstate\n")
 
1026
                                                wxT("Equus\n")
 
1027
                                                wxT("Hot N' Humid\n")
 
1028
                                                wxT("@lantia\n")
 
1029
                                                wxT("Heritage Home\n")
 
1030
                                                wxT("Bay Way\n")
 
1031
                                                wxT("Aqua-rama\n")
 
1032
                                                wxT("Lakes-a-plenty\n")
 
1033
                                                wxT("Magnolia\n")
 
1034
                                                wxT("Riverview\n")
 
1035
                                                wxT("Skyview\n")
 
1036
                                                wxT("Korn-O-copia\n")
 
1037
                                                wxT("WinALot\n")
 
1038
                                                wxT("Hard Rock State\n")
 
1039
                                                wxT("Consolidated Peoples\n")
 
1040
                                                wxT("I Can't Believe It's Not Mexico\n")
 
1041
                                                wxT("DollarDaze\n")
 
1042
                                                wxT("Phatlantic\n")
 
1043
                                                wxT("Northland\n")
 
1044
                                                wxT("South Lake Shores\n")
 
1045
                                                wxT("Indiana\n")
 
1046
                                                wxT("Ocean View\n")
 
1047
                                                wxT("Gettysburg Estates\n")
 
1048
                                                wxT("MicroState\n")
 
1049
                                                wxT("Charlie\n")
 
1050
                                                wxT("South Northland\n")
 
1051
                                                wxT("Opry-Tune-Itee\n")
 
1052
                                                wxT("Superultramax\n")
 
1053
                                                wxT("Salterra\n")
 
1054
                                                wxT("Ethan Allendale\n")
 
1055
                                                wxT("Washington\n")
 
1056
                                                wxT("Kountry Korner\n")
 
1057
                                                wxT("Friendly Folks\n")
 
1058
                                                wxT("DairyKween\n")
 
1059
                                                wxT("Fin and Fur\n");
 
1060
        
 
1061
        // Create the dictionary
 
1062
        wxFile dict_file;
 
1063
        dict_file.Create(dictionary, true);
 
1064
        TS_ASSERT(dict_file.IsOpened());
 
1065
        dict_file.Write(example, conv);
 
1066
        dict_file.Close();
 
1067
        
 
1068
        // With a dictionary generator file(dictionary, false, wxDateTime::GetTimeNow(), utf-8)
 
1069
        {
 
1070
                // [1] Create the generator
 
1071
                pgsExpression * file_path = pnew pgsString(dictionary);
 
1072
                pgsExpression * sequence = pnew pgsNumber(wxT("0"));
 
1073
                pgsExpression * seed = pnew pgsNumber(wxString()
 
1074
                                << wxDateTime::GetTimeNow());
 
1075
                pgsExpression * encoding = pnew pgsString(wxT("utf-8"));
 
1076
                pgsGenDictionary * gen = 0;
 
1077
                gen = pnew pgsGenDictionary(file_path, sequence, seed, encoding);
 
1078
                
 
1079
                // [2] Check type properties
 
1080
                
 
1081
                // [3] Check result
 
1082
                wxString result;
 
1083
                pgsOperand rnd = gen->eval(vars);
 
1084
                for (int i = 0; i < nb_iterations; i++)
 
1085
                {
 
1086
                        result = rnd->eval(vars)->value();
 
1087
                        TS_ASSERT(result.Length() >= 4); // The shortest city name in the dictionary
 
1088
                }
 
1089
                
 
1090
                // [4] Test copy constructor
 
1091
                pgsGenDictionary * copy = pnew pgsGenDictionary(*gen);
 
1092
                TS_ASSERT(copy->value() = gen->value());
 
1093
                TS_ASSERT(copy->value() = gen->value());
 
1094
                pdelete(copy);
 
1095
                
 
1096
                // [5] Test assignment operator
 
1097
                pgsGenDictionary * assignment = pnew pgsGenDictionary(file_path->clone(),
 
1098
                                sequence->clone(), seed->clone(), encoding->clone());
 
1099
                *gen = *assignment;
 
1100
                TS_ASSERT(assignment->value() = gen->value());
 
1101
                TS_ASSERT(assignment->value() = gen->value());
 
1102
                pdelete(assignment);
 
1103
                
 
1104
                // [6] Delete the generator
 
1105
                pdelete(gen);
 
1106
        }
 
1107
        
 
1108
        // With an invalid dictionary generator file(dictionary, false, wxDateTime::GetTimeNow(), utf-8)
 
1109
        // Sequence is a string
 
1110
        {
 
1111
                // [1] Create the generator
 
1112
                pgsExpression * file_path = pnew pgsString(dictionary);
 
1113
                pgsExpression * sequence = pnew pgsString(wxT("0"));
 
1114
                pgsExpression * seed = pnew pgsNumber(wxString()
 
1115
                                << wxDateTime::GetTimeNow());
 
1116
                pgsExpression * encoding = pnew pgsString(wxT("utf-8"));
 
1117
                pgsGenDictionary * gen = 0;
 
1118
                gen = pnew pgsGenDictionary(file_path, sequence, seed, encoding);
 
1119
                
 
1120
                // [2] Check type properties
 
1121
                
 
1122
                // [3] Check that the result is invalid
 
1123
                try
 
1124
                {
 
1125
                        gen->eval(vars);
 
1126
                        TS_ASSERT(false);
 
1127
                }
 
1128
                catch (const pgsParameterException &)
 
1129
                {
 
1130
                        // Parameters are not correct: exception expected
 
1131
                }
 
1132
                
 
1133
                // [4] Delete the generator
 
1134
                pdelete(gen);
 
1135
        }
 
1136
        
 
1137
        // With an invalid dictionary generator file(dictionary, false, wxDateTime::GetTimeNow(), utf-8)
 
1138
        // Seed is a string
 
1139
        {
 
1140
                // [1] Create the generator
 
1141
                pgsExpression * file_path = pnew pgsString(dictionary);
 
1142
                pgsExpression * sequence = pnew pgsNumber(wxT("0"));
 
1143
                pgsExpression * seed = pnew pgsString(wxString()
 
1144
                                << wxDateTime::GetTimeNow());
 
1145
                pgsExpression * encoding = pnew pgsString(wxT("utf-8"));
 
1146
                pgsGenDictionary * gen = 0;
 
1147
                gen = pnew pgsGenDictionary(file_path, sequence, seed, encoding);
 
1148
                
 
1149
                // [2] Check type properties
 
1150
                
 
1151
                // [3] Check that the result is invalid
 
1152
                try
 
1153
                {
 
1154
                        gen->eval(vars);
 
1155
                        TS_ASSERT(false);
 
1156
                }
 
1157
                catch (const pgsParameterException &)
 
1158
                {
 
1159
                        // Parameters are not correct: exception expected
 
1160
                }
 
1161
                
 
1162
                // [4] Delete the generator
 
1163
                pdelete(gen);
 
1164
        }
 
1165
        
 
1166
        // With an invalid dictionary generator file(123, false, wxDateTime::GetTimeNow(), utf-8)
 
1167
        // Seed is a string
 
1168
        {
 
1169
                // [1] Create the generator
 
1170
                pgsExpression * file_path = pnew pgsNumber(wxT("123"));
 
1171
                pgsExpression * sequence = pnew pgsNumber(wxT("0"));
 
1172
                pgsExpression * seed = pnew pgsNumber(wxString()
 
1173
                                << wxDateTime::GetTimeNow());
 
1174
                pgsExpression * encoding = pnew pgsString(wxT("utf-8"));
 
1175
                pgsGenDictionary * gen = 0;
 
1176
                gen = pnew pgsGenDictionary(file_path, sequence, seed, encoding);
 
1177
                
 
1178
                // [2] Check type properties
 
1179
                
 
1180
                // [3] Check that the result is invalid
 
1181
                try
 
1182
                {
 
1183
                        gen->eval(vars);
 
1184
                        TS_ASSERT(false);
 
1185
                }
 
1186
                catch (const pgsParameterException &)
 
1187
                {
 
1188
                        // Parameters are not correct: exception expected
 
1189
                }
 
1190
                
 
1191
                // [4] Delete the generator
 
1192
                pdelete(gen);
 
1193
        }
 
1194
        
 
1195
        // Remove the dictionary
 
1196
        ::wxRemoveFile(dictionary);
 
1197
}