← Back to branch summary

~loic.molinari/+junk/qtdeclarative-shadereffectsource-changes

« back to all changes in this revision

Viewing changes to tests/auto/qml/parserstress/tests/ecma_3/extensions/regress-228087.js

  • Committer: Loïc Molinari
  • Date: 2012-04-21 17:59:51 UTC
  • Revision ID: loic.molinari@canonical.com-20120421175951-bqx68caaf5zrp76l
Initial import

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/auto/qml/parserstress/tests/ecma_3/extensions/regress-228087.js
 
1
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
 
2
/* ***** BEGIN LICENSE BLOCK *****
 
3
* Version: MPL 1.1/GPL 2.0/LGPL 2.1
 
4
*
 
5
* The contents of this file are subject to the Mozilla Public License Version
 
6
* 1.1 (the "License"); you may not use this file except in compliance with
 
7
* the License. You may obtain a copy of the License at
 
8
* http://www.mozilla.org/MPL/
 
9
*
 
10
* Software distributed under the License is distributed on an "AS IS" basis,
 
11
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 
12
* for the specific language governing rights and limitations under the
 
13
* License.
 
14
*
 
15
* The Original Code is JavaScript Engine testing utilities.
 
16
*
 
17
* The Initial Developer of the Original Code is
 
18
* Netscape Communications Corp.
 
19
* Portions created by the Initial Developer are Copyright (C) 2003
 
20
* the Initial Developer. All Rights Reserved.
 
21
*
 
22
* Contributor(s):
 
23
*   bex@xaotec.com, PhilSchwartau@aol.com
 
24
*
 
25
* Alternatively, the contents of this file may be used under the terms of
 
26
* either the GNU General Public License Version 2 or later (the "GPL"), or
 
27
* the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 
28
* in which case the provisions of the GPL or the LGPL are applicable instead
 
29
* of those above. If you wish to allow use of your version of this file only
 
30
* under the terms of either the GPL or the LGPL, and not to allow others to
 
31
* use your version of this file under the terms of the MPL, indicate your
 
32
* decision by deleting the provisions above and replace them with the notice
 
33
* and other provisions required by the GPL or the LGPL. If you do not delete
 
34
* the provisions above, a recipient may use your version of this file under
 
35
* the terms of any one of the MPL, the GPL or the LGPL.
 
36
*
 
37
* ***** END LICENSE BLOCK ***** */
 
38
 
 
39
/*
 
40
 *
 
41
 * Date:    12 December 2003
 
42
 * SUMMARY: Testing regexps with unescaped braces
 
43
 * See http://bugzilla.mozilla.org/show_bug.cgi?id=228087
 
44
 *
 
45
 * Note: unbalanced, unescaped braces are not permitted by ECMA-262 Ed.3,
 
46
 * but we decided to follow Perl and IE and allow this for compatibility.
 
47
 *
 
48
 * See http://bugzilla.mozilla.org/show_bug.cgi?id=188206 and its testcase.
 
49
 * See http://bugzilla.mozilla.org/show_bug.cgi?id=223273 and its testcase.
 
50
 */
 
51
//-----------------------------------------------------------------------------
 
52
var gTestfile = 'regress-228087.js';
 
53
var i = 0;
 
54
var BUGNUMBER = 228087;
 
55
var summary = 'Testing regexps with unescaped braces';
 
56
var status = '';
 
57
var statusmessages = new Array();
 
58
var pattern = '';
 
59
var patterns = new Array();
 
60
var string = '';
 
61
var strings = new Array();
 
62
var actualmatch = '';
 
63
var actualmatches = new Array();
 
64
var expectedmatch = '';
 
65
var expectedmatches = new Array();
 
66
var e;
 
67
 
 
68
 
 
69
string = 'foo {1} foo {2} foo';
 
70
 
 
71
// try an example with the braces escaped
 
72
status = inSection(1);
 
73
try
 
74
{
 
75
  pattern = new RegExp('\{1.*\}', 'g');
 
76
  actualmatch = string.match(pattern);
 
77
}
 
78
catch (e)
 
79
{
 
80
  pattern = 'error';
 
81
  actualmatch = '';
 
82
}
 
83
expectedmatch = Array('{1} foo {2}');
 
84
addThis();
 
85
 
 
86
// just like Section 1, without the braces being escaped
 
87
status = inSection(2);
 
88
try
 
89
{
 
90
  pattern = new RegExp('{1.*}', 'g');
 
91
  actualmatch = string.match(pattern);
 
92
}
 
93
catch (e)
 
94
{
 
95
  pattern = 'error';
 
96
  actualmatch = '';
 
97
}
 
98
expectedmatch = Array('{1} foo {2}');
 
99
addThis();
 
100
 
 
101
// try an example with the braces escaped
 
102
status = inSection(3);
 
103
try
 
104
{
 
105
  pattern = new RegExp('\{1[.!\}]*\}', 'g');
 
106
  actualmatch = string.match(pattern);
 
107
}
 
108
catch (e)
 
109
{
 
110
  pattern = 'error';
 
111
  actualmatch = '';
 
112
}
 
113
expectedmatch = Array('{1}');
 
114
addThis();
 
115
 
 
116
// just like Section 3, without the braces being escaped
 
117
status = inSection(4);
 
118
try
 
119
{
 
120
  pattern = new RegExp('{1[.!}]*}', 'g');
 
121
  actualmatch = string.match(pattern);
 
122
}
 
123
catch (e)
 
124
{
 
125
  pattern = 'error';
 
126
  actualmatch = '';
 
127
}
 
128
expectedmatch = Array('{1}');
 
129
addThis();
 
130
 
 
131
 
 
132
string = 'abccccc{3 }c{ 3}c{3, }c{3 ,}c{3 ,4}c{3, 4}c{3,4 }de';
 
133
 
 
134
// use braces in a normal quantifier construct
 
135
status = inSection(5);
 
136
try
 
137
{
 
138
  pattern = new RegExp('c{3}');
 
139
  actualmatch = string.match(pattern);
 
140
}
 
141
catch (e)
 
142
{
 
143
  pattern = 'error';
 
144
  actualmatch = '';
 
145
}
 
146
expectedmatch = Array('ccc');
 
147
addThis();
 
148
 
 
149
// now disrupt the quantifer - the braces should now be interpreted literally
 
150
status = inSection(6);
 
151
try
 
152
{
 
153
  pattern = new RegExp('c{3 }');
 
154
  actualmatch = string.match(pattern);
 
155
}
 
156
catch (e)
 
157
{
 
158
  pattern = 'error';
 
159
  actualmatch = '';
 
160
}
 
161
expectedmatch = Array('c{3 }');
 
162
addThis();
 
163
 
 
164
status = inSection(7);
 
165
try
 
166
{
 
167
  pattern = new RegExp('c{3.}');
 
168
  actualmatch = string.match(pattern);
 
169
}
 
170
catch (e)
 
171
{
 
172
  pattern = 'error';
 
173
  actualmatch = '';
 
174
}
 
175
expectedmatch = Array('c{3 }');
 
176
addThis();
 
177
 
 
178
status = inSection(8);
 
179
try
 
180
{
 
181
  // need to escape the \ in \s since
 
182
  // this has been converted to a constructor call
 
183
  // instead of a literal regexp
 
184
  pattern = new RegExp('c{3\\s}');
 
185
  actualmatch = string.match(pattern);
 
186
}
 
187
catch (e)
 
188
{
 
189
  pattern = 'error';
 
190
  actualmatch = '';
 
191
}
 
192
expectedmatch = Array('c{3 }');
 
193
addThis();
 
194
 
 
195
status = inSection(9);
 
196
try
 
197
{
 
198
  pattern = new RegExp('c{3[ ]}');
 
199
  actualmatch = string.match(pattern);
 
200
}
 
201
catch (e)
 
202
{
 
203
  pattern = 'error';
 
204
  actualmatch = '';
 
205
}
 
206
expectedmatch = Array('c{3 }');
 
207
addThis();
 
208
 
 
209
status = inSection(10);
 
210
try
 
211
{
 
212
  pattern = new RegExp('c{ 3}');
 
213
  actualmatch = string.match(pattern);
 
214
}
 
215
catch (e)
 
216
{
 
217
  pattern = 'error';
 
218
  actualmatch = '';
 
219
}
 
220
expectedmatch = Array('c{ 3}');
 
221
addThis();
 
222
 
 
223
// using braces in a normal quantifier construct again
 
224
status = inSection(11);
 
225
try
 
226
{
 
227
  pattern = new RegExp('c{3,}');
 
228
  actualmatch = string.match(pattern);
 
229
}
 
230
catch (e)
 
231
{
 
232
  pattern = 'error';
 
233
  actualmatch = '';
 
234
}
 
235
expectedmatch = Array('ccccc');
 
236
addThis();
 
237
 
 
238
// now disrupt it - the braces should now be interpreted literally
 
239
status = inSection(12);
 
240
try
 
241
{
 
242
  pattern = new RegExp('c{3, }');
 
243
  actualmatch = string.match(pattern);
 
244
}
 
245
catch (e)
 
246
{
 
247
  pattern = 'error';
 
248
  actualmatch = '';
 
249
}
 
250
expectedmatch = Array('c{3, }');
 
251
addThis();
 
252
 
 
253
status = inSection(13);
 
254
try
 
255
{
 
256
  pattern = new RegExp('c{3 ,}');
 
257
  actualmatch = string.match(pattern);
 
258
}
 
259
catch (e)
 
260
{
 
261
  pattern = 'error';
 
262
  actualmatch = '';
 
263
}
 
264
expectedmatch = Array('c{3 ,}');
 
265
addThis();
 
266
 
 
267
// using braces in a normal quantifier construct again
 
268
status = inSection(14);
 
269
try
 
270
{
 
271
  pattern = new RegExp('c{3,4}');
 
272
  actualmatch = string.match(pattern);
 
273
}
 
274
catch (e)
 
275
{
 
276
  pattern = 'error';
 
277
  actualmatch = '';
 
278
}
 
279
expectedmatch = Array('cccc');
 
280
addThis();
 
281
 
 
282
// now disrupt it - the braces should now be interpreted literally
 
283
status = inSection(15);
 
284
try
 
285
{
 
286
  pattern = new RegExp('c{3 ,4}');
 
287
  actualmatch = string.match(pattern);
 
288
}
 
289
catch (e)
 
290
{
 
291
  pattern = 'error';
 
292
  actualmatch = '';
 
293
}
 
294
expectedmatch = Array('c{3 ,4}');
 
295
addThis();
 
296
 
 
297
status = inSection(16);
 
298
try
 
299
{
 
300
  pattern = new RegExp('c{3, 4}');
 
301
  actualmatch = string.match(pattern);
 
302
}
 
303
catch (e)
 
304
{
 
305
  pattern = 'error';
 
306
  actualmatch = '';
 
307
}
 
308
expectedmatch = Array('c{3, 4}');
 
309
addThis();
 
310
 
 
311
status = inSection(17);
 
312
try
 
313
{
 
314
  pattern = new RegExp('c{3,4 }');
 
315
  actualmatch = string.match(pattern);
 
316
}
 
317
catch (e)
 
318
{
 
319
  pattern = 'error';
 
320
  actualmatch = '';
 
321
}
 
322
expectedmatch = Array('c{3,4 }');
 
323
addThis();
 
324
 
 
325
 
 
326
 
 
327
 
 
328
//-------------------------------------------------------------------------------------------------
 
329
test();
 
330
//-------------------------------------------------------------------------------------------------
 
331
 
 
332
 
 
333
 
 
334
function addThis()
 
335
{
 
336
  statusmessages[i] = status;
 
337
  patterns[i] = pattern;
 
338
  strings[i] = string;
 
339
  actualmatches[i] = actualmatch;
 
340
  expectedmatches[i] = expectedmatch;
 
341
  i++;
 
342
}
 
343
 
 
344
 
 
345
function test()
 
346
{
 
347
  enterFunc ('test');
 
348
  printBugNumber(BUGNUMBER);
 
349
  printStatus (summary);
 
350
  testRegExp(statusmessages, patterns, strings, actualmatches, expectedmatches);
 
351
  exitFunc ('test');
 
352
}