← Back to branch summary

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

« back to all changes in this revision

Viewing changes to xtra/pgscript/test/pgsTestStatements.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/pgsTestStatements.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/pgsAssign.h"
14
 
#include "pgscript/expressions/pgsGenInt.h"
15
 
#include "pgscript/expressions/pgsGenRegex.h"
16
 
#include "pgscript/expressions/pgsGenString.h"
17
 
#include "pgscript/expressions/pgsGreater.h"
18
 
#include "pgscript/expressions/pgsIdent.h"
19
 
#include "pgscript/expressions/pgsLower.h"
20
 
#include "pgscript/expressions/pgsMinus.h"
21
 
#include "pgscript/expressions/pgsPlus.h"
22
 
#include "pgscript/objects/pgsNumber.h"
23
 
#include "pgscript/objects/pgsString.h"
24
 
#include "pgscript/statements/pgsBreakStmt.h"
25
 
#include "pgscript/statements/pgsContinueStmt.h"
26
 
#include "pgscript/statements/pgsExpressionStmt.h"
27
 
#include "pgscript/statements/pgsIfStmt.h"
28
 
#include "pgscript/statements/pgsStmtList.h"
29
 
#include "pgscript/statements/pgsWhileStmt.h"
30
 
 
31
 
void pgsTestSuite::test_statement_stmt(void)
32
 
{
33
 
        // Symbol table
34
 
        pgsVarMap vars;
35
 
 
36
 
        // Test Assignment Statement
37
 
        {
38
 
                pgsStmt * S1 = 0, * S2 = 0, * S3 = 0;
39
 
 
40
 
                // x := 0
41
 
                S1 = pnew pgsExpressionStmt(pnew pgsAssign(wxT("x"),
42
 
                                pnew pgsNumber(wxT("0"), pgsInt)));
43
 
                S1->eval(vars);
44
 
                
45
 
                // y := 2
46
 
                S2 = pnew pgsExpressionStmt(pnew pgsAssign(wxT("y"),
47
 
                                pnew pgsNumber(wxT("2"), pgsInt)));
48
 
                S2->eval(vars);
49
 
 
50
 
                // Check that assignments went fine
51
 
                TS_ASSERT(vars[wxT("x")]->value() == wxT("0"));
52
 
                TS_ASSERT(vars[wxT("y")]->value() == wxT("2"));
53
 
 
54
 
                // x := 1
55
 
                S3 = pnew pgsExpressionStmt(pnew pgsAssign(wxT("x"),
56
 
                                pnew pgsNumber(wxT("1"), pgsInt)));
57
 
                S3->eval(vars);
58
 
 
59
 
                TS_ASSERT(vars[wxT("x")]->value() == wxT("1"));
60
 
                TS_ASSERT(vars[wxT("y")]->value() == wxT("2"));
61
 
 
62
 
                pdelete(S1);
63
 
                pdelete(S2);
64
 
                pdelete(S3);
65
 
        }
66
 
 
67
 
        // Test If Statement (if 0 then z := 0 else z := 1 fi)
68
 
        {
69
 
                pgsStmt * S1 = 0;
70
 
                pgsStmtList * SL1 = 0, * SL2 = 0;
71
 
 
72
 
                // z := 0
73
 
                SL1 = pnew pgsStmtList(pgsTestClass::get_cout());
74
 
                SL1->insert_front(pnew pgsExpressionStmt(pnew pgsAssign(wxT("z"),
75
 
                                pnew pgsNumber(wxT("0"), pgsInt))));
76
 
                
77
 
                // z := 1
78
 
                SL2 = pnew pgsStmtList(pgsTestClass::get_cout());
79
 
                SL2->insert_front(pnew pgsExpressionStmt(pnew pgsAssign(wxT("z"),
80
 
                                pnew pgsNumber(wxT("1"), pgsInt))));
81
 
 
82
 
                // if 0 then z := 0 else z := 1 fi
83
 
                S1 = pnew pgsIfStmt(pnew pgsNumber(wxT("0"), pgsInt), SL1, SL2);
84
 
                S1->eval(vars);
85
 
 
86
 
                TS_ASSERT(vars[wxT("x")]->value() == wxT("1"));
87
 
                TS_ASSERT(vars[wxT("y")]->value() == wxT("2"));
88
 
                TS_ASSERT(vars[wxT("z")]->value() == wxT("1"));
89
 
 
90
 
                pdelete(S1);
91
 
        }
92
 
 
93
 
        // Test If Statement (if 1 then z := 0 else z := 1 fi)
94
 
        {
95
 
                pgsStmt * S1 = 0;
96
 
                pgsStmtList * SL1 = 0, * SL2 = 0;
97
 
 
98
 
                // z := 0
99
 
                SL1 = pnew pgsStmtList(pgsTestClass::get_cout());
100
 
                SL1->insert_front(pnew pgsExpressionStmt(pnew pgsAssign(wxT("z"),
101
 
                                pnew pgsNumber(wxT("0"), pgsInt))));
102
 
                
103
 
                // z := 1
104
 
                SL2 = pnew pgsStmtList(pgsTestClass::get_cout());
105
 
                SL2->insert_front(pnew pgsExpressionStmt(pnew pgsAssign(wxT("z"),
106
 
                                pnew pgsNumber(wxT("1"), pgsInt))));
107
 
 
108
 
                // if 1 then z := 0 else z := 1 fi
109
 
                S1 = pnew pgsIfStmt(pnew pgsNumber(wxT("1"), pgsInt), SL1, SL2);
110
 
                S1->eval(vars);
111
 
 
112
 
                TS_ASSERT(vars[wxT("x")]->value() == wxT("1"));
113
 
                TS_ASSERT(vars[wxT("y")]->value() == wxT("2"));
114
 
                TS_ASSERT(vars[wxT("z")]->value() == wxT("0"));
115
 
 
116
 
                pdelete(S1);
117
 
        }
118
 
        
119
 
        // Test While Statement (while i do s := s + i; i := i-1 done)
120
 
        {
121
 
                pgsStmt * S1 = 0, * S2 = 0, * S3 = 0;
122
 
                pgsStmtList * SL1 = 0;
123
 
 
124
 
                // i := 3
125
 
                pgsExpressionStmt(pnew pgsAssign(wxT("i"), pnew pgsNumber(wxT("3"),
126
 
                                pgsInt))).eval(vars);
127
 
                
128
 
                // s := 0
129
 
                pgsExpressionStmt(pnew pgsAssign(wxT("s"), pnew pgsNumber(wxT("0"),
130
 
                                pgsInt))).eval(vars);
131
 
 
132
 
                TS_ASSERT(vars[wxT("x")]->value() == wxT("1"));
133
 
                TS_ASSERT(vars[wxT("y")]->value() == wxT("2"));
134
 
                TS_ASSERT(vars[wxT("z")]->value() == wxT("0"));
135
 
                TS_ASSERT(vars[wxT("i")]->value() == wxT("3"));
136
 
                TS_ASSERT(vars[wxT("s")]->value() == wxT("0"));
137
 
                TS_ASSERT(vars.size() == 5);
138
 
                
139
 
                // i == 3 ?
140
 
                TS_ASSERT(pgsIdent(wxT("i")).eval(vars)->value() == wxT("3"));
141
 
                // s + i == 3 ?
142
 
                TS_ASSERT(pgsPlus(pnew pgsIdent(wxT("s")),
143
 
                                pnew pgsIdent(wxT("i"))).eval(vars)->value() == wxT("3"));
144
 
                
145
 
                // s := s + i
146
 
                S1 = pnew pgsExpressionStmt(pnew pgsAssign(wxT("s"),
147
 
                                pnew pgsPlus(pnew pgsIdent(wxT("s")),
148
 
                                                pnew pgsIdent(wxT("i")))));
149
 
                // i := i-1
150
 
                S2 = pnew pgsExpressionStmt(pnew pgsAssign(wxT("i"),
151
 
                                pnew pgsMinus(pnew pgsIdent(wxT("i")),
152
 
                                                pnew pgsNumber(wxT("1"), pgsInt))));
153
 
                SL1 = pnew pgsStmtList(pgsTestClass::get_cout());
154
 
                SL1->insert_front(S2);
155
 
                SL1->insert_front(S1);
156
 
 
157
 
                // while i do s := s + i; i := i-1 done
158
 
                S3 = pnew pgsWhileStmt(pnew pgsIdent(wxT("i")), SL1);
159
 
                S3->eval(vars);
160
 
                pdelete(S3);
161
 
 
162
 
                TS_ASSERT(vars[wxT("x")]->value() == wxT("1"));
163
 
                TS_ASSERT(vars[wxT("y")]->value() == wxT("2"));
164
 
                TS_ASSERT(vars[wxT("z")]->value() == wxT("0"));
165
 
                TS_ASSERT(vars[wxT("i")]->value() == wxT("0"));
166
 
                TS_ASSERT(vars[wxT("s")]->value() == wxT("6"));
167
 
                TS_ASSERT(vars.size() == 5);
168
 
        }
169
 
        
170
 
        // Test While Statement
171
 
        // while i < 10 do
172
 
        //   i := i + i;
173
 
        //   if i > 5 then
174
 
        //     break;
175
 
        //   else
176
 
        //     continue;
177
 
        //     s := s + 1;
178
 
        //   fi
179
 
        // done
180
 
        {
181
 
                pgsStmt * S1 = 0, * S2 = 0, * S3 = 0, * S4 = 0;
182
 
                pgsStmtList * SL1 = 0, * SL2 = 0;
183
 
 
184
 
                // i := 0
185
 
                pgsExpressionStmt(pnew pgsAssign(wxT("i"), pnew pgsNumber(wxT("0"),
186
 
                                pgsInt))).eval(vars);
187
 
                
188
 
                // s := 5
189
 
                pgsExpressionStmt(pnew pgsAssign(wxT("s"), pnew pgsNumber(wxT("5"),
190
 
                                pgsInt))).eval(vars);
191
 
 
192
 
                TS_ASSERT(vars[wxT("i")]->value() == wxT("0"));
193
 
                TS_ASSERT(vars[wxT("s")]->value() == wxT("5"));
194
 
                
195
 
                // i := i + 1
196
 
                S1 = pnew pgsExpressionStmt(pnew pgsAssign(wxT("i"),
197
 
                                pnew pgsPlus(pnew pgsIdent(wxT("i")),
198
 
                                                pnew pgsNumber(wxT("1"), pgsInt))));
199
 
                
200
 
                // s := s + 1
201
 
                S2 = pnew pgsExpressionStmt(pnew pgsAssign(wxT("s"),
202
 
                                pnew pgsPlus(pnew pgsIdent(wxT("s")),
203
 
                                                pnew pgsNumber(wxT("1"), pgsInt))));
204
 
 
205
 
                // s := s + 1; continue
206
 
                SL2 = pnew pgsStmtList(pgsTestClass::get_cout());
207
 
                SL2->insert_back(pnew pgsContinueStmt());
208
 
                SL2->insert_back(S2);
209
 
                
210
 
                // if i > 5 ... fi
211
 
                S3 = pnew pgsIfStmt(pnew pgsGreater(pnew pgsIdent(wxT("i")),
212
 
                                pnew pgsNumber(wxT("5"))), pnew pgsBreakStmt(), SL2);
213
 
 
214
 
                // while ... done
215
 
                SL1 = pnew pgsStmtList(pgsTestClass::get_cout());
216
 
                SL1->insert_back(S1);
217
 
                SL1->insert_back(S3);
218
 
                S4 = pnew pgsWhileStmt(pnew pgsLower(pnew pgsIdent(wxT("i")),
219
 
                                pnew pgsNumber(wxT("10"))), SL1);
220
 
                S4->eval(vars);
221
 
                pdelete(S4);
222
 
 
223
 
                TS_ASSERT(vars[wxT("i")]->value() == wxT("6"));
224
 
                TS_ASSERT(vars[wxT("s")]->value() == wxT("5"));
225
 
        }
226
 
 
227
 
        // Test Assign Statement with a generator
228
 
        {
229
 
                pgsExpression * N0 = 0, * N1 = 0, * N2 = 0;
230
 
                pgsStmt * S1 = 0, * S2 = 0, * S3 = 0;
231
 
 
232
 
                // m := -10
233
 
                pgsExpressionStmt(pnew pgsAssign(wxT("m"),
234
 
                                pnew pgsNumber(wxT("-10")))).eval(vars);
235
 
 
236
 
                // integer(m, 10, true, now)
237
 
                N0 = pnew pgsGenInt(pnew pgsIdent(wxT("m")), pnew pgsNumber(wxT("10")),
238
 
                                pnew pgsNumber(wxT("1")), pnew pgsNumber(wxString()
239
 
                                                << wxDateTime::GetTimeNow()));
240
 
                // string(1, 10, 2, now)
241
 
                N1 = pnew pgsGenString(pnew pgsNumber(wxT("1")),
242
 
                                pnew pgsNumber(wxT("10")), pnew pgsNumber(wxT("2")),
243
 
                                                pnew pgsNumber(wxString() << wxDateTime::GetTimeNow()));
244
 
                // regex(a{2}[a-zA-Z]{10}c{3}, now)
245
 
                N2 = pnew pgsGenRegex(pnew pgsString(wxT("a{2}[a-zA-Z]{10}c{3}")),
246
 
                                                pnew pgsNumber(wxString() << wxDateTime::GetTimeNow()));
247
 
 
248
 
                // x := integer(m, 10, true, now)
249
 
                S1 = pnew pgsExpressionStmt(pnew pgsAssign(wxT("x"), N0));
250
 
                S1->eval(vars);
251
 
                // y := string(1, 10, 2, now)
252
 
                S2 = pnew pgsExpressionStmt(pnew pgsAssign(wxT("y"), N1));
253
 
                S2->eval(vars);
254
 
                // z := regex(a{2}[a-zA-Z]{10}c{3}, now)
255
 
                S3 = pnew pgsExpressionStmt(pnew pgsAssign(wxT("z"), N2));
256
 
                S3->eval(vars);
257
 
 
258
 
                wxString result1, result2, result3;
259
 
                wxArrayString sav;
260
 
                for (int i = 0; i < 21; i++)
261
 
                {
262
 
                        // Check that x result is unique (we wanted to generate a sequence)
263
 
                        result1 = pgsIdent(wxT("x")).eval(vars)->value();
264
 
                        TS_ASSERT(sav.Index(result1) == wxNOT_FOUND);
265
 
                        sav.Add(result1);
266
 
                        
267
 
                        // Check that y result is at least 3 characters (two words of 1
268
 
                        // character with a space in the middle) and less than 21
269
 
                        result2 = pgsIdent(wxT("y")).eval(vars)->value();
270
 
                        TS_ASSERT(result2.Length() >= 3 && result2.Length() <= 21);
271
 
                        
272
 
                        // Check the regex-based generators
273
 
                        result3 = pgsIdent(wxT("z")).eval(vars)->value();
274
 
                        TS_ASSERT(result3.Length() == 15);
275
 
                        TS_ASSERT(result3.StartsWith(wxT("aa")) && result3.EndsWith(wxT("ccc")));
276
 
                }
277
 
 
278
 
                pdelete(S1); // Deletes N0
279
 
                pdelete(S2); // Deletes N1
280
 
                pdelete(S3); // Deletes N2
281
 
        }
282
 
 
283
 
        
284
 
        // Test an unknown identifier
285
 
        {
286
 
                pgsExpression * E1;
287
 
                
288
 
                E1 = pnew pgsIdent(wxT("unknown"));
289
 
                TS_ASSERT(E1->eval(vars)->value() == wxT(""));
290
 
                
291
 
                pdelete(E1);
292
 
        }
293
 
}