← Back to branch summary

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

« back to all changes in this revision

Viewing changes to xtra/pgscript/test/pgsTestOperatorString.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/pgsTestOperatorString.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 "pgscript/exceptions/pgsException.h"
14
 
#include "pgscript/generators/pgsIntegerGen.h"
15
 
#include "pgscript/generators/pgsStringGen.h"
16
 
#include "pgscript/objects/pgsGenerator.h"
17
 
#include "pgscript/objects/pgsNumber.h"
18
 
#include "pgscript/objects/pgsRecord.h"
19
 
#include "pgscript/objects/pgsString.h"
20
 
 
21
 
void pgsTestSuite::test_operator_string(void)
22
 
{
23
 
        // From a string with a string
24
 
        {
25
 
                // [1] Create variables
26
 
                pgsVariable * var0 = 0;
27
 
                var0 = pnew pgsString(wxT("abc"));
28
 
                pgsVariable * var1 = 0;
29
 
                var1 = pnew pgsString(wxT("ABC"));
30
 
                
31
 
                // [2] Addition
32
 
                TS_ASSERT((*var0 + *var1)->value() == wxT("abcABC"));
33
 
                
34
 
                // [3] Subtraction
35
 
                try
36
 
                {
37
 
                        (*var0 - *var1);
38
 
                        TS_ASSERT(false);
39
 
                }
40
 
                catch (const pgsException &)
41
 
                {
42
 
                        
43
 
                }
44
 
                
45
 
                // [4] Multiplication
46
 
                try
47
 
                {
48
 
                        (*var0 * *var1);
49
 
                        TS_ASSERT(false);
50
 
                }
51
 
                catch (const pgsException &)
52
 
                {
53
 
                        
54
 
                }
55
 
                
56
 
                // [5] Division
57
 
                try
58
 
                {
59
 
                        (*var0 / *var1);
60
 
                        TS_ASSERT(false);
61
 
                }
62
 
                catch (const pgsException &)
63
 
                {
64
 
                        
65
 
                }
66
 
                
67
 
                // [6] Modulo
68
 
                try
69
 
                {
70
 
                        (*var0 % *var1);
71
 
                        TS_ASSERT(false);
72
 
                }
73
 
                catch (const pgsException &)
74
 
                {
75
 
                        
76
 
                }
77
 
                
78
 
                // [9] Equal
79
 
                TS_ASSERT((*var0 == *var1)->value() == wxT("0"));
80
 
                
81
 
                // [10] Different
82
 
                TS_ASSERT((*var0 != *var1)->value() == wxT("1"));
83
 
                
84
 
                // [11] Lower
85
 
                TS_ASSERT((*var0 < *var1)->value() == wxT("0"));
86
 
                
87
 
                // [12] Greater
88
 
                TS_ASSERT((*var0 > *var1)->value() == wxT("1"));
89
 
                
90
 
                // [13] Lower or equal
91
 
                TS_ASSERT((*var0 <= *var1)->value() == wxT("0"));
92
 
                
93
 
                // [14] Greater or equal
94
 
                TS_ASSERT((*var0 >= *var1)->value() == wxT("1"));
95
 
                
96
 
                // [15] Not
97
 
                TS_ASSERT((!(*var0))->value() == wxT(""));
98
 
                pgsOperand op(pnew pgsString(wxT("")));
99
 
                TS_ASSERT((!(*op))->value() == wxT("1"));
100
 
                
101
 
                // [16] Almost equal
102
 
                TS_ASSERT((*var0 &= *var1)->value() == wxT("1"));
103
 
                
104
 
                // [17] Is true?
105
 
                TS_ASSERT(var0->pgs_is_true() == true);
106
 
                TS_ASSERT((!(*var0))->pgs_is_true() == false);
107
 
                
108
 
                // [18] Delete variables
109
 
                pdelete(var0);
110
 
                pdelete(var1);
111
 
        }
112
 
        
113
 
        // From a string with a number
114
 
        {
115
 
                // [1] Create variables
116
 
                pgsVariable * var0 = 0;
117
 
                var0 = pnew pgsString(wxT("abc"));
118
 
                pgsVariable * var1 = 0;
119
 
                var1 = pnew pgsNumber(wxT("123"));
120
 
                
121
 
                // [2] Addition
122
 
                try
123
 
                {
124
 
                        (*var0 + *var1);
125
 
                        TS_ASSERT(false);
126
 
                }
127
 
                catch (const pgsException &)
128
 
                {
129
 
                        
130
 
                }
131
 
                
132
 
                // [3] Subtraction
133
 
                try
134
 
                {
135
 
                        (*var0 - *var1);
136
 
                        TS_ASSERT(false);
137
 
                }
138
 
                catch (const pgsException &)
139
 
                {
140
 
                        
141
 
                }
142
 
                
143
 
                // [4] Multiplication
144
 
                try
145
 
                {
146
 
                        (*var0 * *var1);
147
 
                        TS_ASSERT(false);
148
 
                }
149
 
                catch (const pgsException &)
150
 
                {
151
 
                        
152
 
                }
153
 
                
154
 
                // [5] Division
155
 
                try
156
 
                {
157
 
                        (*var0 / *var1);
158
 
                        TS_ASSERT(false);
159
 
                }
160
 
                catch (const pgsException &)
161
 
                {
162
 
                        
163
 
                }
164
 
                
165
 
                // [6] Modulo
166
 
                try
167
 
                {
168
 
                        (*var0 % *var1);
169
 
                        TS_ASSERT(false);
170
 
                }
171
 
                catch (const pgsException &)
172
 
                {
173
 
                        
174
 
                }
175
 
                
176
 
                // [9] Equal
177
 
                try
178
 
                {
179
 
                        (*var0 == *var1);
180
 
                        TS_ASSERT(false);
181
 
                }
182
 
                catch (const pgsException &)
183
 
                {
184
 
                        
185
 
                }
186
 
                
187
 
                // [10] Different
188
 
                try
189
 
                {
190
 
                        (*var0 != *var1);
191
 
                        TS_ASSERT(false);
192
 
                }
193
 
                catch (const pgsException &)
194
 
                {
195
 
                        
196
 
                }
197
 
                
198
 
                // [11] Lower
199
 
                try
200
 
                {
201
 
                        (*var0 < *var1);
202
 
                        TS_ASSERT(false);
203
 
                }
204
 
                catch (const pgsException &)
205
 
                {
206
 
                        
207
 
                }
208
 
                
209
 
                // [12] Greater
210
 
                try
211
 
                {
212
 
                        (*var0 > *var1);
213
 
                        TS_ASSERT(false);
214
 
                }
215
 
                catch (const pgsException &)
216
 
                {
217
 
                        
218
 
                }
219
 
                
220
 
                // [13] Lower or equal
221
 
                try
222
 
                {
223
 
                        (*var0 <= *var1);
224
 
                        TS_ASSERT(false);
225
 
                }
226
 
                catch (const pgsException &)
227
 
                {
228
 
                        
229
 
                }
230
 
                
231
 
                // [14] Greater or equal
232
 
                try
233
 
                {
234
 
                        (*var0 >= *var1);
235
 
                        TS_ASSERT(false);
236
 
                }
237
 
                catch (const pgsException &)
238
 
                {
239
 
                        
240
 
                }
241
 
                
242
 
                // [15] Not
243
 
                TS_ASSERT((!(*var0))->value() == wxT(""));
244
 
                
245
 
                // [16] Almost equal
246
 
                try
247
 
                {
248
 
                        (*var0 &= *var1);
249
 
                        TS_ASSERT(false);
250
 
                }
251
 
                catch (const pgsException &)
252
 
                {
253
 
                        
254
 
                }
255
 
                
256
 
                // [17] Is true?
257
 
                TS_ASSERT(var0->pgs_is_true() == true);
258
 
                TS_ASSERT((!(*var0))->pgs_is_true() == false);
259
 
                
260
 
                // [18] Delete variables
261
 
                pdelete(var0);
262
 
                pdelete(var1);
263
 
        }
264
 
        
265
 
        // From a string with a record
266
 
        {
267
 
                // [1] Create variables
268
 
                pgsVariable * var0 = 0;
269
 
                var0 = pnew pgsString(wxT("abc"));
270
 
                pgsRecord * rec = 0;
271
 
                rec = pnew pgsRecord(1);
272
 
                rec->insert(0, 0, pnew pgsString(wxT("ABC")));
273
 
                pgsVariable * var1 = 0;
274
 
                var1 = rec;
275
 
                
276
 
                // [2] Addition
277
 
                try
278
 
                {
279
 
                        (*var0 + *var1);
280
 
                        TS_ASSERT(false);
281
 
                }
282
 
                catch (const pgsException &)
283
 
                {
284
 
                        
285
 
                }
286
 
                
287
 
                // [3] Subtraction
288
 
                try
289
 
                {
290
 
                        (*var0 - *var1);
291
 
                        TS_ASSERT(false);
292
 
                }
293
 
                catch (const pgsException &)
294
 
                {
295
 
                        
296
 
                }
297
 
                
298
 
                // [4] Multiplication
299
 
                try
300
 
                {
301
 
                        (*var0 * *var1);
302
 
                        TS_ASSERT(false);
303
 
                }
304
 
                catch (const pgsException &)
305
 
                {
306
 
                        
307
 
                }
308
 
                
309
 
                // [5] Division
310
 
                try
311
 
                {
312
 
                        (*var0 / *var1);
313
 
                        TS_ASSERT(false);
314
 
                }
315
 
                catch (const pgsException &)
316
 
                {
317
 
                        
318
 
                }
319
 
                
320
 
                // [6] Modulo
321
 
                try
322
 
                {
323
 
                        (*var0 % *var1);
324
 
                        TS_ASSERT(false);
325
 
                }
326
 
                catch (const pgsException &)
327
 
                {
328
 
                        
329
 
                }
330
 
                
331
 
                // [9] Equal
332
 
                try
333
 
                {
334
 
                        (*var0 == *var1);
335
 
                        TS_ASSERT(false);
336
 
                }
337
 
                catch (const pgsException &)
338
 
                {
339
 
                        
340
 
                }
341
 
                
342
 
                // [10] Different
343
 
                try
344
 
                {
345
 
                        (*var0 != *var1);
346
 
                        TS_ASSERT(false);
347
 
                }
348
 
                catch (const pgsException &)
349
 
                {
350
 
                        
351
 
                }
352
 
                
353
 
                // [11] Lower
354
 
                try
355
 
                {
356
 
                        (*var0 < *var1);
357
 
                        TS_ASSERT(false);
358
 
                }
359
 
                catch (const pgsException &)
360
 
                {
361
 
                        
362
 
                }
363
 
                
364
 
                // [12] Greater
365
 
                try
366
 
                {
367
 
                        (*var0 > *var1);
368
 
                        TS_ASSERT(false);
369
 
                }
370
 
                catch (const pgsException &)
371
 
                {
372
 
                        
373
 
                }
374
 
                
375
 
                // [13] Lower or equal
376
 
                try
377
 
                {
378
 
                        (*var0 <= *var1);
379
 
                        TS_ASSERT(false);
380
 
                }
381
 
                catch (const pgsException &)
382
 
                {
383
 
                        
384
 
                }
385
 
                
386
 
                // [14] Greater or equal
387
 
                try
388
 
                {
389
 
                        (*var0 >= *var1);
390
 
                        TS_ASSERT(false);
391
 
                }
392
 
                catch (const pgsException &)
393
 
                {
394
 
                        
395
 
                }
396
 
                
397
 
                // [15] Not
398
 
                TS_ASSERT((!(*var0))->value() == wxT(""));
399
 
                
400
 
                // [16] Almost equal
401
 
                try
402
 
                {
403
 
                        (*var0 &= *var1);
404
 
                        TS_ASSERT(false);
405
 
                }
406
 
                catch (const pgsException &)
407
 
                {
408
 
                        
409
 
                }
410
 
                
411
 
                // [17] Is true?
412
 
                TS_ASSERT(var0->pgs_is_true() == true);
413
 
                TS_ASSERT((!(*var0))->pgs_is_true() == false);
414
 
                
415
 
                // [18] Delete variables
416
 
                pdelete(var0);
417
 
                pdelete(var1);
418
 
        }
419
 
        
420
 
        // From a string with a string generator
421
 
        {
422
 
                // [1] Create variables
423
 
                pgsVariable * var0 = 0;
424
 
                var0 = pnew pgsString(wxT("abc"));
425
 
                pgsStringGen * gen = 0;
426
 
                gen = pnew pgsStringGen(10, 20);
427
 
                pgsVariable * var1 = 0;
428
 
                var1 = pnew pgsGenerator(pgsVariable::pgsTString, gen);
429
 
                
430
 
                // [2] Addition
431
 
                TS_ASSERT((*var0 + *var1)->value().StartsWith(wxT("abc")));
432
 
                
433
 
                // [3] Subtraction
434
 
                try
435
 
                {
436
 
                        (*var0 - *var1);
437
 
                        TS_ASSERT(false);
438
 
                }
439
 
                catch (const pgsException &)
440
 
                {
441
 
                        
442
 
                }
443
 
                
444
 
                // [4] Multiplication
445
 
                try
446
 
                {
447
 
                        (*var0 * *var1);
448
 
                        TS_ASSERT(false);
449
 
                }
450
 
                catch (const pgsException &)
451
 
                {
452
 
                        
453
 
                }
454
 
                
455
 
                // [5] Division
456
 
                try
457
 
                {
458
 
                        (*var0 / *var1);
459
 
                        TS_ASSERT(false);
460
 
                }
461
 
                catch (const pgsException &)
462
 
                {
463
 
                        
464
 
                }
465
 
                
466
 
                // [6] Modulo
467
 
                try
468
 
                {
469
 
                        (*var0 % *var1);
470
 
                        TS_ASSERT(false);
471
 
                }
472
 
                catch (const pgsException &)
473
 
                {
474
 
                        
475
 
                }
476
 
                
477
 
                // [9] Equal
478
 
                TS_ASSERT((*var0 == *var1)->value() == wxT("0"));
479
 
                
480
 
                // [10] Different
481
 
                TS_ASSERT((*var0 != *var1)->value() == wxT("1"));
482
 
                
483
 
                // [11] Lower
484
 
                try
485
 
                {
486
 
                        (*var0 < *var1);
487
 
                }
488
 
                catch (const pgsException &)
489
 
                {
490
 
                        TS_ASSERT(false);
491
 
                }
492
 
                
493
 
                // [12] Greater
494
 
                try
495
 
                {
496
 
                        (*var0 > *var1);
497
 
                }
498
 
                catch (const pgsException &)
499
 
                {
500
 
                        TS_ASSERT(false);
501
 
                }
502
 
                
503
 
                // [13] Lower or equal
504
 
                try
505
 
                {
506
 
                        (*var0 <= *var1);
507
 
                }
508
 
                catch (const pgsException &)
509
 
                {
510
 
                        TS_ASSERT(false);
511
 
                }
512
 
                
513
 
                // [14] Greater or equal
514
 
                try
515
 
                {
516
 
                        (*var0 >= *var1);
517
 
                }
518
 
                catch (const pgsException &)
519
 
                {
520
 
                        TS_ASSERT(false);
521
 
                }
522
 
                
523
 
                // [15] Not
524
 
                TS_ASSERT((!(*var0))->value() == wxT(""));
525
 
                
526
 
                // [16] Almost equal
527
 
                TS_ASSERT((*var0 &= *var1)->value() == wxT("0"));
528
 
                
529
 
                // [17] Is true?
530
 
                TS_ASSERT(var0->pgs_is_true() == true);
531
 
                TS_ASSERT((!(*var0))->pgs_is_true() == false);
532
 
                
533
 
                // [18] Delete variables
534
 
                pdelete(var0);
535
 
                pdelete(var1);
536
 
        }
537
 
        
538
 
        // From a string with an integer generator
539
 
        {
540
 
                // [1] Create variables
541
 
                pgsVariable * var0 = 0;
542
 
                var0 = pnew pgsString(wxT("abc"));
543
 
                pgsIntegerGen * gen = 0;
544
 
                gen = pnew pgsIntegerGen(10, 10);
545
 
                pgsVariable * var1 = 0;
546
 
                var1 = pnew pgsGenerator(pgsVariable::pgsTInt, gen);
547
 
                
548
 
                // [2] Addition
549
 
                try
550
 
                {
551
 
                        (*var0 + *var1);
552
 
                        TS_ASSERT(false);
553
 
                }
554
 
                catch (const pgsException &)
555
 
                {
556
 
                        
557
 
                }
558
 
                
559
 
                // [3] Subtraction
560
 
                try
561
 
                {
562
 
                        (*var0 - *var1);
563
 
                        TS_ASSERT(false);
564
 
                }
565
 
                catch (const pgsException &)
566
 
                {
567
 
                        
568
 
                }
569
 
                
570
 
                // [4] Multiplication
571
 
                try
572
 
                {
573
 
                        (*var0 * *var1);
574
 
                        TS_ASSERT(false);
575
 
                }
576
 
                catch (const pgsException &)
577
 
                {
578
 
                        
579
 
                }
580
 
                
581
 
                // [5] Division
582
 
                try
583
 
                {
584
 
                        (*var0 / *var1);
585
 
                        TS_ASSERT(false);
586
 
                }
587
 
                catch (const pgsException &)
588
 
                {
589
 
                        
590
 
                }
591
 
                
592
 
                // [6] Modulo
593
 
                try
594
 
                {
595
 
                        (*var0 % *var1);
596
 
                        TS_ASSERT(false);
597
 
                }
598
 
                catch (const pgsException &)
599
 
                {
600
 
                        
601
 
                }
602
 
                
603
 
                // [9] Equal
604
 
                try
605
 
                {
606
 
                        (*var0 == *var1);
607
 
                        TS_ASSERT(false);
608
 
                }
609
 
                catch (const pgsException &)
610
 
                {
611
 
                        
612
 
                }
613
 
                
614
 
                // [10] Different
615
 
                try
616
 
                {
617
 
                        (*var0 != *var1);
618
 
                        TS_ASSERT(false);
619
 
                }
620
 
                catch (const pgsException &)
621
 
                {
622
 
                        
623
 
                }
624
 
                
625
 
                // [11] Lower
626
 
                try
627
 
                {
628
 
                        (*var0 < *var1);
629
 
                        TS_ASSERT(false);
630
 
                }
631
 
                catch (const pgsException &)
632
 
                {
633
 
                        
634
 
                }
635
 
                
636
 
                // [12] Greater
637
 
                try
638
 
                {
639
 
                        (*var0 > *var1);
640
 
                        TS_ASSERT(false);
641
 
                }
642
 
                catch (const pgsException &)
643
 
                {
644
 
                        
645
 
                }
646
 
                
647
 
                // [13] Lower or equal
648
 
                try
649
 
                {
650
 
                        (*var0 <= *var1);
651
 
                        TS_ASSERT(false);
652
 
                }
653
 
                catch (const pgsException &)
654
 
                {
655
 
                        
656
 
                }
657
 
                
658
 
                // [14] Greater or equal
659
 
                try
660
 
                {
661
 
                        (*var0 >= *var1);
662
 
                        TS_ASSERT(false);
663
 
                }
664
 
                catch (const pgsException &)
665
 
                {
666
 
                        
667
 
                }
668
 
                
669
 
                // [15] Not
670
 
                TS_ASSERT((!(*var0))->value() == wxT(""));
671
 
                
672
 
                // [16] Almost equal
673
 
                try
674
 
                {
675
 
                        (*var0 &= *var1);
676
 
                        TS_ASSERT(false);
677
 
                }
678
 
                catch (const pgsException &)
679
 
                {
680
 
                        
681
 
                }
682
 
                
683
 
                // [17] Is true?
684
 
                TS_ASSERT(var0->pgs_is_true() == true);
685
 
                TS_ASSERT((!(*var0))->pgs_is_true() == false);
686
 
                
687
 
                // [18] Delete variables
688
 
                pdelete(var0);
689
 
                pdelete(var1);
690
 
        }
691
 
}