git.saurik.com Git - apple/javascriptcore.git/blob - tests/mozilla/js1

1 /* ***** BEGIN LICENSE BLOCK *****

2 * Version: NPL 1.1/GPL 2.0/LGPL 2.1

3 *

4 * The contents of this file are subject to the Netscape Public License

5 * Version 1.1 (the "License"); you may not use this file except in

6 * compliance with the License. You may obtain a copy of the License at

7 * http://www.mozilla.org/NPL/

8 *

9 * Software distributed under the License is distributed on an "AS IS" basis,

10 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License

11 * for the specific language governing rights and limitations under the

12 * License.

13 *

14 * The Original Code is JavaScript Engine testing utilities.

15 *

16 * The Initial Developer of the Original Code is Netscape Communications Corp.

19 *

20 * Contributor(s): pschwartau@netscape.com

21 *

22 * Alternatively, the contents of this file may be used under the terms of

23 * either the GNU General Public License Version 2 or later (the "GPL"), or

24 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),

25 * in which case the provisions of the GPL or the LGPL are applicable instead

26 * of those above. If you wish to allow use of your version of this file only

27 * under the terms of either the GPL or the LGPL, and not to allow others to

28 * use your version of this file under the terms of the NPL, indicate your

29 * decision by deleting the provisions above and replace them with the notice

30 * and other provisions required by the GPL or the LGPL. If you do not delete

31 * the provisions above, a recipient may use your version of this file under

32 * the terms of any one of the NPL, the GPL or the LGPL.

33 *

34 * ***** END LICENSE BLOCK *****

35 *

36 *

37 * Date: 11 Nov 2002

38 * SUMMARY: JS shouldn't crash on extraneous args to str.match(), etc.

39 * See http://bugzilla.mozilla.org/show_bug.cgi?id=179524

40 *

41 * Note that when testing str.replace(), we have to be careful if the first

42 * argument provided to str.replace() is not a regexp object. ECMA-262 says

43 * it is NOT converted to one, unlike the case for str.match(), str.search().

44 *

45 * See http://bugzilla.mozilla.org/show_bug.cgi?id=83293#c21. This means

46 * we have to be careful how we test meta-characters in the first argument

47 * to str.replace(), if that argument is a string -

48 */

49 //-----------------------------------------------------------------------------

50 var UBound = 0;

51 var bug = 179524;

52 var summary = "Don't crash on extraneous arguments to str.match(), etc.";

53 var status = '';

54 var statusitems = [];

55 var actual = '';

56 var actualvalues = [];

57 var expect= '';

58 var expectedvalues = [];

61 str = 'ABC abc';

62 var re = /z/ig;

 status = inSection(1);

 actual = str.match(re);

66 expect = null;

67 addThis();

 status = inSection(2);

 actual = str.match(re, 'i');

71 expect = null;

72 addThis();

 status = inSection(3);

 actual = str.match(re, 'g', '');

76 expect = null;

77 addThis();

 status = inSection(4);

 actual = str.match(re, 'z', new Object(), new Date());

81 expect = null;

82 addThis();

85 /*

86 * Now try the same thing with str.search()

87 */

 status = inSection(5);

 actual = str.search(re);

90 expect = -1;

91 addThis();

 status = inSection(6);

 actual = str.search(re, 'i');

95 expect = -1;

96 addThis();

 status = inSection(7);

 actual = str.search(re, 'g', '');

100 expect = -1;

101 addThis();

102

 status = inSection(8);

 actual = str.search(re, 'z', new Object(), new Date());

105 expect = -1;

106 addThis();

107

108

109 /*

110 * Now try the same thing with str.replace()

111 */

 status = inSection(9);

 actual = str.replace(re, 'Z');

114 expect = str;

115 addThis();

116

 status = inSection(10);

 actual = str.replace(re, 'Z', 'i');

119 expect = str;

120 addThis();

121

 status = inSection(11);

 actual = str.replace(re, 'Z', 'g', '');

124 expect = str;

125 addThis();

126

 status = inSection(12);

 actual = str.replace(re, 'Z', 'z', new Object(), new Date());

129 expect = str;

130 addThis();

131

132

133

134 /*

135 * Now test the case where str.match()'s first argument is not a regexp object.

136 * In that case, JS follows ECMA-262 Ed.3 by converting the 1st argument to a

137 * regexp object using the argument as a regexp pattern, but then extends ECMA

138 * by taking any optional 2nd argument to be a regexp flag string (e.g.'ig').

139 *

140 * Reference: http://bugzilla.mozilla.org/show_bug.cgi?id=179524#c10

141 */

 status = inSection(13);

 actual = str.match('a').toString();

 expect = str.match(/a/).toString();

145 addThis();

146

 status = inSection(14);

 actual = str.match('a', 'i').toString();

 expect = str.match(/a/i).toString();

150 addThis();

151

 status = inSection(15);

 actual = str.match('a', 'ig').toString();

 expect = str.match(/a/ig).toString();

155 addThis();

156

 status = inSection(16);

 actual = str.match('\\s', 'm').toString();

 expect = str.match(/\s/m).toString();

160 addThis();

161

162

163 /*

164 * Now try the previous three cases with extraneous parameters

165 */

 status = inSection(17);

 actual = str.match('a', 'i', 'g').toString();

 expect = str.match(/a/i).toString();

169 addThis();

170

 status = inSection(18);

 actual = str.match('a', 'ig', new Object()).toString();

 expect = str.match(/a/ig).toString();

174 addThis();

175

 status = inSection(19);

 actual = str.match('\\s', 'm', 999).toString();

 expect = str.match(/\s/m).toString();

179 addThis();

180

181

182 /*

183 * Try an invalid second parameter (i.e. an invalid regexp flag)

184 */

 status = inSection(20);

186 try

187 {

   actual = str.match('a', 'z').toString();

189 expect = 'SHOULD HAVE FALLEN INTO CATCH-BLOCK!';

190 addThis();

191 }

192 catch (e)

193 {

194 actual = e instanceof SyntaxError;

195 expect = true;

196 addThis();

197 }

198

199

200

201 /*

202 * Now test str.search() where the first argument is not a regexp object.

203 * The same considerations as above apply -

204 *

205 * Reference: http://bugzilla.mozilla.org/show_bug.cgi?id=179524#c16

206 */

 status = inSection(21);

 actual = str.search('a');

 expect = str.search(/a/);

210 addThis();

211

 status = inSection(22);

 actual = str.search('a', 'i');

 expect = str.search(/a/i);

215 addThis();

216

 status = inSection(23);

 actual = str.search('a', 'ig');

 expect = str.search(/a/ig);

220 addThis();

221

 status = inSection(24);

 actual = str.search('\\s', 'm');

 expect = str.search(/\s/m);

225 addThis();

226

227

228 /*

229 * Now try the previous three cases with extraneous parameters

230 */

 status = inSection(25);

 actual = str.search('a', 'i', 'g');

 expect = str.search(/a/i);

234 addThis();

235

 status = inSection(26);

 actual = str.search('a', 'ig', new Object());

 expect = str.search(/a/ig);

239 addThis();

240

 status = inSection(27);

 actual = str.search('\\s', 'm', 999);

 expect = str.search(/\s/m);

244 addThis();

245

246

247 /*

248 * Try an invalid second parameter (i.e. an invalid regexp flag)

249 */

 status = inSection(28);

251 try

252 {

   actual = str.search('a', 'z');

254 expect = 'SHOULD HAVE FALLEN INTO CATCH-BLOCK!';

255 addThis();

256 }

257 catch (e)

258 {

259 actual = e instanceof SyntaxError;

260 expect = true;

261 addThis();

262 }

263

264

265

266 /*

267 * Now test str.replace() where the first argument is not a regexp object.

268 * The same considerations as above apply, EXCEPT for meta-characters.

269 * See introduction to testcase above. References:

270 *

271 * http://bugzilla.mozilla.org/show_bug.cgi?id=179524#c16

272 * http://bugzilla.mozilla.org/show_bug.cgi?id=83293#c21

273 */

 status = inSection(29);

 actual = str.replace('a', 'Z');

 expect = str.replace(/a/, 'Z');

277 addThis();

278

 status = inSection(30);

 actual = str.replace('a', 'Z', 'i');

 expect = str.replace(/a/i, 'Z');

282 addThis();

283

 status = inSection(31);

 actual = str.replace('a', 'Z', 'ig');

 expect = str.replace(/a/ig, 'Z');

287 addThis();

288

 status = inSection(32);

 actual = str.replace('\\s', 'Z', 'm'); //<--- NO!!! No meta-characters 1st arg!

 actual = str.replace(' ', 'Z', 'm');   //<--- Have to do this instead

 expect = str.replace(/\s/m, 'Z');

293 addThis();

294

295

296 /*

297 * Now try the previous three cases with extraneous parameters

298 */

 status = inSection(33);

 actual = str.replace('a', 'Z', 'i', 'g');

 expect = str.replace(/a/i, 'Z');

302 addThis();

303

 status = inSection(34);

 actual = str.replace('a', 'Z', 'ig', new Object());

 expect = str.replace(/a/ig, 'Z');

307 addThis();

308

 status = inSection(35);

 actual = str.replace('\\s', 'Z', 'm', 999); //<--- NO meta-characters 1st arg!

 actual = str.replace(' ', 'Z', 'm', 999);   //<--- Have to do this instead

 expect = str.replace(/\s/m, 'Z');

313 addThis();

314

315

316 /*

317 * Try an invalid third parameter (i.e. an invalid regexp flag)

318 */

 status = inSection(36);

320 try

321 {

   actual = str.replace('a', 'Z', 'z');

323 expect = 'SHOULD HAVE FALLEN INTO CATCH-BLOCK!';

324 addThis();

325 }

326 catch (e)

327 {

328 actual = e instanceof SyntaxError;

329 expect = true;

330 addThis();

331 }

336 //-----------------------------------------------------------------------------

337 test();

338 //-----------------------------------------------------------------------------

339

340

341

342 function addThis()

343 {

344 statusitems[UBound] = status;

345 actualvalues[UBound] = actual;

346 expectedvalues[UBound] = expect;

347 UBound++;

348 }

349

350

351 function test()

352 {

353 enterFunc('test');

354 printBugNumber(bug);

355 printStatus(summary);

356

   for (var i=0; i<UBound; i++)

358 {

     reportCompare(expectedvalues[i], actualvalues[i], statusitems[i]);

360 }

361

362 exitFunc ('test');

363 }