← Back to branch summary

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

« back to all changes in this revision

Viewing changes to xtra/pgscript/test/pgsTestObjectRecord.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/pgsTestObjectRecord.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/expressions/pgsEqual.h"
14
 
#include "pgscript/expressions/pgsDifferent.h"
15
 
#include "pgscript/expressions/pgsGreater.h"
16
 
#include "pgscript/expressions/pgsGreaterEqual.h"
17
 
#include "pgscript/expressions/pgsLower.h"
18
 
#include "pgscript/expressions/pgsLowerEqual.h"
19
 
#include "pgscript/generators/pgsIntegerGen.h"
20
 
#include "pgscript/generators/pgsRealGen.h"
21
 
#include "pgscript/generators/pgsStringGen.h"
22
 
#include "pgscript/objects/pgsNumber.h"
23
 
#include "pgscript/objects/pgsRecord.h"
24
 
#include "pgscript/objects/pgsString.h"
25
 
 
26
 
void pgsTestSuite::test_object_record(void)
27
 
{
28
 
        const int max = +16383;
29
 
        const int min = -16384;
30
 
        const int nb_iterations = 10; // Must be greater than 3
31
 
        const USHORT nb_columns = 5; // Must be greater than 2
32
 
        
33
 
        pgsVarMap vars;
34
 
        
35
 
        // Test record with 0 column
36
 
        {
37
 
                pgsRecord rec(0);
38
 
                TS_ASSERT(!rec.insert(0, 0, pnew pgsString(wxT(""))));
39
 
                TS_ASSERT(rec.count_lines() == 1);
40
 
                TS_ASSERT(rec.count_columns() == 0);
41
 
        }
42
 
 
43
 
        // Test the string value of a record
44
 
        // Special characters must be escaped an each line must be returned
45
 
        // as a composite structure ("string val", 12345, ...)
46
 
        {
47
 
                pgsRecord rec(1);
48
 
                TS_ASSERT(rec.insert(0, 0, pnew pgsString(wxT("\"string\""))));
49
 
                TS_ASSERT(rec.value() == wxT("(\"\\\"string\\\"\")"));
50
 
                TS_ASSERT(rec.insert(1, 0, pnew pgsString(wxT("str\\i\nng"))));
51
 
                TS_ASSERT(rec.value() == wxT("(\"\\\"string\\\"\")\n(\"str\\\\i\nng\")"));
52
 
        }
53
 
 
54
 
        // Insert data and compare two records
55
 
        {
56
 
                // Prepare random generator to generate random data
57
 
                pgsIntegerGen int_gen(min, max, false);
58
 
                pgsRealGen real_gen(min, max, 3, false);
59
 
                pgsStringGen string_gen(10, 20, 1);
60
 
                
61
 
                
62
 
                for (int i = 0; i < nb_iterations; i++)
63
 
                {
64
 
                        pgsRecord rec(nb_columns);
65
 
 
66
 
                        // Basic TS_ASSERTs (no line, 'nb_columns' columns)
67
 
                        {
68
 
                                TS_ASSERT(rec.count_lines() == 0
69
 
                                                && rec.count_columns() == nb_columns);
70
 
                                TS_ASSERT(rec.is_record() && !rec.is_string()
71
 
                                                && !rec.is_number());
72
 
                        }
73
 
 
74
 
                        // Get columns and elements (but there is nothing)
75
 
                        {
76
 
                                TS_ASSERT(rec.get_column(wxT(""))  == rec.count_columns());
77
 
                                TS_ASSERT(rec.get_column(wxT("a")) == rec.count_columns());
78
 
                                TS_ASSERT(rec.get(0, 0)->value() == wxT("")); // Nothing exists
79
 
                                TS_ASSERT(rec.get(1, 0)->value() == wxT(""));
80
 
                        }
81
 
 
82
 
                        USHORT line = rand() % 9 + 1; // Index of the line (1 < line < 10)
83
 
 
84
 
                        // Give names to columns and check them
85
 
                        {
86
 
                                TS_ASSERT(!rec.set_column_name(nb_columns, wxT("a")));
87
 
                                for (USHORT j = 0; j < nb_columns; j++)
88
 
                                {
89
 
                                        TS_ASSERT(rec.set_column_name(j, (wxString() << j)));
90
 
                                }
91
 
                                for (USHORT j = 0; j < nb_columns; j++)
92
 
                                {
93
 
                                        TS_ASSERT(rec.get_column((wxString() << j)) == j);
94
 
                                }
95
 
                        }
96
 
 
97
 
                        // Insert in a wrong location
98
 
                        {
99
 
                                TS_ASSERT(!rec.insert(0, nb_columns,
100
 
                                                pnew pgsString(int_gen.random())));
101
 
                                TS_ASSERT(!rec.insert(0, wx_static_cast(USHORT, -1), 0));
102
 
                                TS_ASSERT(!rec.insert(0, wx_static_cast(USHORT, -1),
103
 
                                                pnew pgsString(int_gen.random())));
104
 
                        }
105
 
 
106
 
                        // Insert random elements in the first 3 columns
107
 
                        {
108
 
                                // (1 <= line <= 10), 0
109
 
                                TS_ASSERT(rec.insert(line, 0, pnew pgsNumber(int_gen.random(),
110
 
                                                pgsInt)));
111
 
                                // (1 <= line <= 10), 1
112
 
                                TS_ASSERT(rec.insert(line, 1, pnew pgsNumber(real_gen.random(),
113
 
                                                pgsReal)));
114
 
                                // (1 <= line <= 10), 2
115
 
                                TS_ASSERT(rec.insert(line, 2,
116
 
                                                pnew pgsString(string_gen.random())));
117
 
                        }
118
 
 
119
 
                        // Verify the number of lines and the number of columns
120
 
                        // Verify that the first 3 columns contain something and not the other ones
121
 
                        {
122
 
                                TS_ASSERT(rec.count_lines()   == line + 1);
123
 
                                TS_ASSERT(rec.count_columns() == nb_columns);
124
 
                                for (USHORT i = 0; i < 3; i++)
125
 
                                {
126
 
                                        TS_ASSERT(rec.get(line, rec.get_column((wxString()
127
 
                                                        << i)))->value() != wxT(""));
128
 
                                }
129
 
                                for (USHORT i = 3; i < nb_columns; i++)
130
 
                                {
131
 
                                        TS_ASSERT(rec.get(line, rec.get_column((wxString()
132
 
                                                        << i)))->value() == wxT(""));
133
 
                                }
134
 
                        }
135
 
                        
136
 
                        // Assignment operator is forbidden
137
 
                        // No test
138
 
 
139
 
                        // Test the copy constructor
140
 
                        pgsRecord copy(rec);
141
 
 
142
 
                        // Check that the copy is equal with the original
143
 
                        // pgsRecord way
144
 
                        {
145
 
                                TS_ASSERT(rec == copy && copy == rec);
146
 
                                TS_ASSERT(rec <= copy && copy <= rec);
147
 
                                TS_ASSERT(rec >= copy && copy >= rec);
148
 
                                TS_ASSERT(!(rec < copy) && !(copy < rec));
149
 
                                TS_ASSERT(!(rec > copy) && !(copy > rec));
150
 
                                TS_ASSERT(rec.almost_equal(copy) && copy.almost_equal(rec));
151
 
                        }
152
 
                        
153
 
                        // Check that the copy is equal with the original
154
 
                        // pgsOperation way
155
 
                        {
156
 
                                pgsEqual eq(rec.clone(),         copy.clone());
157
 
                                TS_ASSERT(eq.eval(vars)->value()  == wxT("1"));
158
 
                                eq = pgsEqual(rec.clone(), copy.clone(), false);
159
 
                                TS_ASSERT(eq.eval(vars)->value()  == wxT("1"));
160
 
                                pgsDifferent neq(rec.clone(),    copy.clone());
161
 
                                TS_ASSERT(neq.eval(vars)->value() == wxT("0"));
162
 
                                pgsLowerEqual leq(rec.clone(),   copy.clone());
163
 
                                TS_ASSERT(leq.eval(vars)->value() == wxT("1"));
164
 
                                pgsGreaterEqual geq(rec.clone(), copy.clone());
165
 
                                TS_ASSERT(geq.eval(vars)->value() == wxT("1"));
166
 
                                pgsLower lo(rec.clone(),         copy.clone());
167
 
                                TS_ASSERT(lo.eval(vars)->value()  == wxT("0"));
168
 
                                pgsGreater gr(rec.clone(),       copy.clone());
169
 
                                TS_ASSERT(gr.eval(vars)->value()  == wxT("0"));
170
 
                        }
171
 
                        
172
 
                        wxString aux = rec.get(line, 2)->value();
173
 
                        rec.insert(line, 2, pnew pgsString(aux.Upper()));
174
 
                        
175
 
                        // Test case sensitivity
176
 
                        // pgsRecord way
177
 
                        {
178
 
                                TS_ASSERT(rec != copy && copy != rec);
179
 
                                TS_ASSERT(!(rec <= copy) && !(copy <= rec));
180
 
                                TS_ASSERT(!(rec >= copy) && !(copy >= rec));
181
 
                                TS_ASSERT(!(rec < copy) && !(copy < rec));
182
 
                                TS_ASSERT(!(rec > copy) && !(copy > rec));
183
 
                                TS_ASSERT(rec.almost_equal(copy) && copy.almost_equal(rec));
184
 
                        }
185
 
                        
186
 
                        // Test case sensitivity
187
 
                        // pgsOperation way
188
 
                        {
189
 
                                pgsEqual eq(rec.clone(),         copy.clone());
190
 
                                TS_ASSERT(eq.eval(vars)->value()  == wxT("0"));
191
 
                                eq = pgsEqual(rec.clone(), copy.clone(), false);
192
 
                                TS_ASSERT(eq.eval(vars)->value()  == wxT("1"));
193
 
                        }
194
 
                        
195
 
                        rec.insert(line, 2, pnew pgsString(aux));
196
 
 
197
 
                        // Add some elements to the copy
198
 
                        {
199
 
                                bool ins1 = copy.insert(0, 0, pnew pgsNumber(int_gen.random(),
200
 
                                                pgsInt));
201
 
                                TS_ASSERT(ins1);
202
 
                                bool ins2 = copy.insert(0, 1, pnew pgsNumber(real_gen.random(),
203
 
                                                pgsReal));
204
 
                                TS_ASSERT(ins2);
205
 
                                // Overwrites the previous element
206
 
                                bool ins3 = copy.insert(0, 1,
207
 
                                                pnew pgsString(string_gen.random()));
208
 
                                TS_ASSERT(ins3);
209
 
                        }
210
 
 
211
 
                        // New checks
212
 
                        {
213
 
                                TS_ASSERT(copy.count_lines()   == line + 1);
214
 
                                TS_ASSERT(copy.count_columns() == nb_columns);
215
 
                        }
216
 
                        
217
 
                        // Destroy copy automatically
218
 
                }
219
 
        }
220
 
 
221
 
        // Remove lines and compare two records
222
 
        {
223
 
                pgsIntegerGen int_gen(min, max, false);
224
 
                pgsRealGen real_gen(min, max, 3, false);
225
 
                pgsStringGen string_gen(10, 20, 1);
226
 
 
227
 
                pgsRecord rec(3);
228
 
 
229
 
                // Insert random data
230
 
                {
231
 
                        for (int i = 0; i < nb_iterations; i++)
232
 
                        {
233
 
                                rec.insert(i, 0, pnew pgsString(int_gen.random()));
234
 
                                rec.insert(i, 1, pnew pgsString(real_gen.random()));
235
 
                                rec.insert(i, 2, pnew pgsString(string_gen.random()));
236
 
                        }
237
 
                }
238
 
 
239
 
                // Check a few things
240
 
                {
241
 
                        TS_ASSERT(rec.count_lines() == nb_iterations);
242
 
                        TS_ASSERT(rec.get(nb_iterations - 1, 0)->value() != wxT(""));
243
 
                }
244
 
 
245
 
                // Create a fresh copy
246
 
                pgsRecord copy(rec);
247
 
 
248
 
                // Remove a line
249
 
                {
250
 
                        TS_ASSERT(!copy.remove_line(nb_iterations));
251
 
                        TS_ASSERT(copy.remove_line(1));
252
 
                        TS_ASSERT(copy.count_lines() == nb_iterations - 1);
253
 
                        TS_ASSERT(copy.get(nb_iterations - 1, 0)->value() == wxT(""));
254
 
                }
255
 
 
256
 
                // Comparisons (copy is included in rec)
257
 
                // Both pgsRecord and pgsOperation ways
258
 
                {
259
 
                        TS_ASSERT(rec != copy && copy != rec);
260
 
                        TS_ASSERT(!(rec <= copy) && copy <= rec);
261
 
                        TS_ASSERT(rec >= copy && !(copy >= rec));
262
 
                        TS_ASSERT(!(rec < copy) && copy < rec);
263
 
                        TS_ASSERT(rec > copy && !(copy > rec));
264
 
 
265
 
                        pgsEqual eq(rec.clone(),         copy.clone());
266
 
                        TS_ASSERT(eq.eval(vars)->value()  == wxT("0"));
267
 
                        pgsDifferent neq(rec.clone(),    copy.clone());
268
 
                        TS_ASSERT(neq.eval(vars)->value() == wxT("1"));
269
 
                        pgsLowerEqual leq(rec.clone(),   copy.clone());
270
 
                        TS_ASSERT(leq.eval(vars)->value() == wxT("0"));
271
 
                        pgsGreaterEqual geq(rec.clone(), copy.clone());
272
 
                        TS_ASSERT(geq.eval(vars)->value() == wxT("1"));
273
 
                        pgsLower lo(rec.clone(),         copy.clone());
274
 
                        TS_ASSERT(lo.eval(vars)->value()  == wxT("0"));
275
 
                        pgsGreater gr(rec.clone(),       copy.clone());
276
 
                        TS_ASSERT(gr.eval(vars)->value()  == wxT("1"));
277
 
                }
278
 
 
279
 
                // Remove a line
280
 
                {
281
 
                        TS_ASSERT(copy.remove_line(nb_iterations - 2));
282
 
                        TS_ASSERT(copy.count_lines() == nb_iterations - 2);
283
 
                        TS_ASSERT(copy.get(nb_iterations - 2, 0)->value() == wxT(""));
284
 
                }
285
 
 
286
 
                // Comparisons (copy should be included in rec)
287
 
                {
288
 
                        TS_ASSERT(rec != copy && copy != rec);
289
 
                        TS_ASSERT(!(rec <= copy) && copy <= rec);
290
 
                        TS_ASSERT(rec >= copy && !(copy >= rec));
291
 
                        TS_ASSERT(!(rec < copy) && copy < rec);
292
 
                        TS_ASSERT(rec > copy && !(copy > rec));
293
 
                }
294
 
 
295
 
                // Remove everything
296
 
                // Copy should still be included in rec as it contains nothing
297
 
                {
298
 
                        while (copy.count_lines() > 0)
299
 
                        {
300
 
                                TS_ASSERT(copy.remove_line(copy.count_lines() - 1));
301
 
                        }
302
 
                        
303
 
                        TS_ASSERT(rec != copy && copy != rec);
304
 
                        TS_ASSERT(!(rec <= copy) && copy <= rec);
305
 
                        TS_ASSERT(rec >= copy && !(copy >= rec));
306
 
                        TS_ASSERT(!(rec < copy) && copy < rec);
307
 
                        TS_ASSERT(rec > copy && !(copy > rec));
308
 
                }
309
 
        }
310
 
        
311
 
        // Compare records
312
 
        {
313
 
                pgsRecord rec(2);
314
 
                pgsRecord cmp(2);
315
 
                
316
 
                // Nothing in the records: they should be equal
317
 
                {
318
 
                        TS_ASSERT(rec == cmp && cmp == rec);
319
 
                        TS_ASSERT(rec <= cmp && cmp <= rec);
320
 
                        TS_ASSERT(rec >= cmp && cmp >= rec);
321
 
                        TS_ASSERT(!(rec < cmp) && !(cmp < rec));
322
 
                        TS_ASSERT(!(rec > cmp) && !(cmp > rec));
323
 
                        TS_ASSERT(rec.almost_equal(cmp));
324
 
                }
325
 
                
326
 
                rec.insert(0, 0, pnew pgsString(wxT("a")));
327
 
                
328
 
                // cmp should be included in rec
329
 
                {
330
 
                        TS_ASSERT(rec != cmp && cmp != rec);
331
 
                        TS_ASSERT(!(rec <= cmp) && cmp <= rec);
332
 
                        TS_ASSERT(rec >= cmp && !(cmp >= rec));
333
 
                        TS_ASSERT(!(rec < cmp) && cmp < rec);
334
 
                        TS_ASSERT(rec > cmp && !(cmp > rec));
335
 
                        TS_ASSERT(!rec.almost_equal(cmp));
336
 
                }
337
 
                
338
 
                rec.insert(1, 0, pnew pgsString(wxT("b")));
339
 
                
340
 
                // cmp should be included in rec
341
 
                {
342
 
                        TS_ASSERT(rec != cmp && cmp != rec);
343
 
                        TS_ASSERT(!(rec <= cmp) && cmp <= rec);
344
 
                        TS_ASSERT(rec >= cmp && !(cmp >= rec));
345
 
                        TS_ASSERT(!(rec < cmp) && cmp < rec);
346
 
                        TS_ASSERT(rec > cmp && !(cmp > rec));
347
 
                        TS_ASSERT(!rec.almost_equal(cmp));
348
 
                }
349
 
                
350
 
                cmp.insert(0, 0, pnew pgsString(wxT("b")));
351
 
                
352
 
                // cmp should be included in rec
353
 
                {
354
 
                        TS_ASSERT(rec != cmp && cmp != rec);
355
 
                        TS_ASSERT(!(rec <= cmp) && cmp <= rec);
356
 
                        TS_ASSERT(rec >= cmp && !(cmp >= rec));
357
 
                        TS_ASSERT(!(rec < cmp) && cmp < rec);
358
 
                        TS_ASSERT(rec > cmp && !(cmp > rec));
359
 
                        TS_ASSERT(!rec.almost_equal(cmp));
360
 
                }
361
 
                
362
 
                cmp.insert(1, 0, pnew pgsString(wxT("A")));
363
 
                
364
 
                // cmp should be almost equal to rec (case insensitive)
365
 
                // The order does not matter
366
 
                {
367
 
                        TS_ASSERT(rec != cmp && cmp != rec);
368
 
                        TS_ASSERT(!(rec <= cmp) && !(cmp <= rec));
369
 
                        TS_ASSERT(!(rec >= cmp) && !(cmp >= rec));
370
 
                        TS_ASSERT(!(rec < cmp) && !(cmp < rec));
371
 
                        TS_ASSERT(!(rec > cmp) && !(cmp > rec));
372
 
                        TS_ASSERT(rec.almost_equal(cmp));
373
 
                }
374
 
                
375
 
                cmp.insert(1, 0, pnew pgsString(wxT("a")));
376
 
                
377
 
                // cmp should be equal to rec
378
 
                // The order does not matter
379
 
                {
380
 
                        TS_ASSERT(rec == cmp && cmp == rec);
381
 
                        TS_ASSERT(rec <= cmp && cmp <= rec);
382
 
                        TS_ASSERT(rec >= cmp && cmp >= rec);
383
 
                        TS_ASSERT(!(rec < cmp) && !(cmp < rec));
384
 
                        TS_ASSERT(!(rec > cmp) && !(cmp > rec));
385
 
                        TS_ASSERT(rec.almost_equal(cmp));
386
 
                }
387
 
                
388
 
                cmp.insert(2, 0, pnew pgsString(wxT("a")));
389
 
                
390
 
                // rec should be included in cmp
391
 
                {
392
 
                        TS_ASSERT(rec != cmp && cmp != rec);
393
 
                        TS_ASSERT(rec <= cmp && !(cmp <= rec));
394
 
                        TS_ASSERT(!(rec >= cmp) && cmp >= rec);
395
 
                        TS_ASSERT(rec < cmp && !(cmp < rec));
396
 
                        TS_ASSERT(!(rec > cmp) && cmp > rec);
397
 
                        TS_ASSERT(!rec.almost_equal(cmp));
398
 
                }
399
 
                
400
 
                cmp.remove_line(1);
401
 
                
402
 
                // cmp should be equal to rec
403
 
                // The order does not matter
404
 
                {
405
 
                        TS_ASSERT(rec == cmp && cmp == rec);
406
 
                        TS_ASSERT(rec <= cmp && cmp <= rec);
407
 
                        TS_ASSERT(rec >= cmp && cmp >= rec);
408
 
                        TS_ASSERT(!(rec < cmp) && !(cmp < rec));
409
 
                        TS_ASSERT(!(rec > cmp) && !(cmp > rec));
410
 
                        TS_ASSERT(rec.almost_equal(cmp));
411
 
                }
412
 
                
413
 
                // Test get_line
414
 
                {
415
 
                        TS_ASSERT(rec.get_line(0)->value() != cmp.get_line(0)->value());
416
 
                        TS_ASSERT(rec.get_line(0)->value() == cmp.get_line(1)->value());
417
 
                }
418
 
        }
419
 
}