← Back to branch summary

~ubuntu-branches/ubuntu/utopic/pgadmin3/utopic-proposed

« back to all changes in this revision

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

  • Committer: Package Import Robot
  • Author(s): Christoph Berg
  • Date: 2013-09-10 16:16:38 UTC
  • mfrom: (1.3.4)
  • Revision ID: package-import@ubuntu.com-20130910161638-wwup1q553ylww7dr
Tags: 1.18.0-1
* New upstream release.
* Don't install /usr/bin/png2c anymore.

Show diffs side-by-side

added added

removed removed

Lines of Context:
xtra/pgscript/test/pgsTestObjectGenerator.cpp
1
 
//////////////////////////////////////////////////////////////////////////
2
 
//
3
 
// pgScript - PostgreSQL Tools
4
 
// 
5
 
// Copyright (C) 2002 - 2009, The pgAdmin Development Team
6
 
// This software is released under the PostgreSQL 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
 
}