chrome/test/data/dromaeo/tests/dromaeo-object-regexp.html

   1 <html>
   2 <head>
   3 <script src="../htmlrunner.js"></script>
   4 <script>
   5 window.onload = function(){ startTest("dromaeo-object-regexp", '812dde38');
   6
   7 // Try to force real results
   8 var str = [], tmp, ret, re, testStrings = [];
   9 var i = 65536;
  10
  11 function randomChar(){
  12         return String.fromCharCode( (25 * Math.random()) + 97 );
  13 }
  14
  15 for ( var i = 0; i < 16384; i++ )
  16         str.push( randomChar() );
  17
  18 str = str.join("");
  19 str += str;
  20 str += str;
  21
  22 function generateTestStrings(count){
  23         var t, nest;
  24         if ( testStrings.length >= count )
  25                 return testStrings.slice(0, count);
  26         for ( var i = testStrings.length; i < count; i++ ) {
  27                 // Make all tested strings different
  28                 t = randomChar() + str + randomChar();
  29                 nest = Math.floor(4 * Math.random());
  30                 for ( var j = 0; j < nest; j++ ) {
  31                         t = randomChar() + t + randomChar();
  32                 }
  33                 // Try to minimize benchmark order dependencies by
  34                 // exercising the strings
  35                 for ( var j = 0; j < t.length; j += 100 ) {
  36                         ret = t[j];
  37                         ret = t.substring(j, j + 100);
  38                 }
  39                 testStrings[i] = t;
  40         }
  41         return testStrings;
  42 }
  43
  44         // TESTS: split
  45
  46         prep(function(){
  47                 // It's impossible to specify empty regexp by simply
  48                 // using two slashes as this will be interpreted as a
  49                 // comment start. See note to ECMA-262 5th 7.8.5.
  50                 re = /(?:)/;
  51                 tmp = generateTestStrings(30);
  52         });
  53
  54         test( "Compiled Object Empty Split", function(){
  55                 for ( var i = 0; i < 30; i++ )
  56                         ret = tmp[i].split( re );
  57         });
  58
  59         prep(function(){
  60                 re = /a/;
  61                 tmp = generateTestStrings(30);
  62         });
  63
  64         test( "Compiled Object Char Split", function(){
  65                 for ( var i = 0; i < 30; i++ )
  66                         ret = tmp[i].split( re );
  67         });
  68
  69         prep(function(){
  70                 re = /.*/;
  71                 tmp = generateTestStrings(100);
  72         });
  73
  74         test( "Compiled Object Variable Split", function(){
  75                 for ( var i = 0; i < 100; i++ )
  76                         ret = tmp[i].split( re );
  77         });
  78
  79         // TESTS: Compiled RegExps
  80
  81         prep(function(){
  82                 re = /aaaaaaaaaa/g;
  83                 tmp = generateTestStrings(100);
  84         });
  85
  86         test( "Compiled Match", function(){
  87                 for ( var i = 0; i < 100; i++ )
  88                         ret = tmp[i].match( re );
  89         });
  90
  91         prep(function(){
  92                 tmp = generateTestStrings(100);
  93         });
  94
  95         test( "Compiled Test", function(){
  96                 for ( var i = 0; i < 100; i++ )
  97                         ret = re.test( tmp[i] );
  98         });
  99
 100         prep(function(){
 101                 tmp = generateTestStrings(100);
 102         });
 103
 104         test( "Compiled Empty Replace", function(){
 105                 for ( var i = 0; i < 50; i++ )
 106                         ret = tmp[i].replace( re, "" );
 107         });
 108
 109         prep(function(){
 110                 tmp = generateTestStrings(50);
 111         });
 112
 113         test( "Compiled 12 Char Replace", function(){
 114                 for ( var i = 0; i < 50; i++ )
 115                         ret = tmp[i].replace( re, "asdfasdfasdf" );
 116         });
 117
 118         prep(function(){
 119                 re = new RegExp("aaaaaaaaaa", "g");
 120                 tmp = generateTestStrings(100);
 121         });
 122
 123         test( "Compiled Object Match", function(){
 124                 for ( var i = 0; i < 100; i++ )
 125                         ret = tmp[i].match( re );
 126         });
 127
 128         prep(function(){
 129                 tmp = generateTestStrings(100);
 130         });
 131
 132         test( "Compiled Object Test", function(){
 133                 for ( var i = 0; i < 100; i++ )
 134                         ret = re.test( tmp[i] );
 135         });
 136
 137         prep(function(){
 138                 tmp = generateTestStrings(50);
 139         });
 140
 141         test( "Compiled Object Empty Replace", function(){
 142                 for ( var i = 0; i < 50; i++ )
 143                         ret = tmp[i].replace( re, "" );
 144         });
 145
 146         prep(function(){
 147                 tmp = generateTestStrings(50);
 148         });
 149
 150         test( "Compiled Object 12 Char Replace", function(){
 151                 for ( var i = 0; i < 50; i++ )
 152                         ret = tmp[i].replace( re, "asdfasdfasdf" );
 153         });
 154
 155         prep(function(){
 156                 tmp = generateTestStrings(50);
 157         });
 158
 159         test( "Compiled Object 12 Char Replace Function", function(){
 160                 for ( var i = 0; i < 50; i++ )
 161                         ret = tmp[i].replace( re, function(all){
 162                         return "asdfasdfasdf";
 163                 });
 164         });
 165
 166         // TESTS: Variable Length
 167
 168         prep(function(){
 169                 re = /a.*a/;
 170                 tmp = generateTestStrings(100);
 171         });
 172
 173         test( "Compiled Variable Match", function(){
 174                 for ( var i = 0; i < 100; i++ )
 175                         ret = tmp[i].match( re );
 176         });
 177
 178         prep(function(){
 179                 tmp = generateTestStrings(100);
 180         });
 181
 182         test( "Compiled Variable Test", function(){
 183                 for ( var i = 0; i < 100; i++ )
 184                         ret = re.test( tmp[i] );
 185         });
 186
 187         prep(function(){
 188                 tmp = generateTestStrings(50);
 189         });
 190
 191         test( "Compiled Variable Empty Replace", function(){
 192                 for ( var i = 0; i < 50; i++ )
 193                         ret = tmp[i].replace( re, "" );
 194         });
 195
 196         prep(function(){
 197                 tmp = generateTestStrings(50);
 198         });
 199
 200         test( "Compiled Variable 12 Char Replace", function(){
 201                 for ( var i = 0; i < 50; i++ )
 202                         ret = tmp[i].replace( re, "asdfasdfasdf" );
 203         });
 204
 205         prep(function(){
 206                 re = new RegExp("aaaaaaaaaa", "g");
 207                 tmp = generateTestStrings(100);
 208         });
 209
 210         test( "Compiled Variable Object Match", function(){
 211                 for ( var i = 0; i < 100; i++ )
 212                         ret = tmp[i].match( re );
 213         });
 214
 215         prep(function(){
 216                 tmp = generateTestStrings(100);
 217         });
 218
 219         test( "Compiled Variable Object Test", function(){
 220                 for ( var i = 0; i < 100; i++ )
 221                         ret = re.test( tmp[i] );
 222         });
 223
 224         prep(function(){
 225                 tmp = generateTestStrings(50);
 226         });
 227
 228         test( "Compiled Variable Object Empty Replace", function(){
 229                 for ( var i = 0; i < 50; i++ )
 230                         ret = tmp[i].replace( re, "" );
 231         });
 232
 233         prep(function(){
 234                 tmp = generateTestStrings(50);
 235         });
 236
 237         test( "Compiled Variable Object 12 Char Replace", function(){
 238                 for ( var i = 0; i < 50; i++ )
 239                         ret = tmp[i].replace( re, "asdfasdfasdf" );
 240         });
 241
 242         prep(function(){
 243                 tmp = generateTestStrings(50);
 244         });
 245
 246         test( "Compiled Variable Object 12 Char Replace Function", function(){
 247                 for ( var i = 0; i < 50; i++ )
 248                         ret = tmp[i].replace( re, function(all){
 249                         return "asdfasdfasdf";
 250                 });
 251         });
 252
 253         // TESTS: Capturing
 254
 255         prep(function(){
 256                 re = /aa(b)aa/g;
 257                 tmp = generateTestStrings(100);
 258         });
 259
 260         test( "Compiled Capture Match", function(){
 261                 for ( var i = 0; i < 100; i++ )
 262                         ret = tmp[i].match( re );
 263         });
 264
 265         prep(function(){
 266                 tmp = generateTestStrings(50);
 267         });
 268
 269         test( "Compiled Capture Replace", function(){
 270                 for ( var i = 0; i < 50; i++ )
 271                         ret = tmp[i].replace( re, "asdfasdfasdf" );
 272         });
 273
 274         prep(function(){
 275                 tmp = generateTestStrings(50);
 276         });
 277
 278         test( "Compiled Capture Replace with Capture", function(){
 279                 for ( var i = 0; i < 50; i++ )
 280                         ret = tmp[i].replace( re, "asdf\\1asdfasdf" );
 281         });
 282
 283         prep(function(){
 284                 tmp = generateTestStrings(50);
 285         });
 286
 287         test( "Compiled Capture Replace with Capture Function", function(){
 288                 for ( var i = 0; i < 50; i++ )
 289                         ret = tmp[i].replace( re, function(all,capture){
 290                         return "asdf" + capture + "asdfasdf";
 291                 });
 292         });
 293
 294         prep(function(){
 295                 tmp = generateTestStrings(50);
 296         });
 297
 298         test( "Compiled Capture Replace with Upperase Capture Function", function(){
 299                 for ( var i = 0; i < 50; i++ )
 300                         ret = tmp[i].replace( re, function(all,capture){
 301                         return capture.toUpperCase();
 302                 });
 303         });
 304
 305         // TESTS: Uncompiled RegExps
 306
 307         prep(function(){
 308                 tmp = generateTestStrings(100);
 309         });
 310
 311         test( "Uncompiled Match", function(){
 312                 for ( var i = 0; i < 100; i++ )
 313                         ret = tmp[i].match( /aaaaaaaaaa/g );
 314         });
 315
 316         prep(function(){
 317                 tmp = generateTestStrings(100);
 318         });
 319
 320         test( "Uncompiled Test", function(){
 321                 for ( var i = 0; i < 100; i++ )
 322                         ret = (/aaaaaaaaaa/g).test( tmp[i] );
 323         });
 324
 325         prep(function(){
 326                 tmp = generateTestStrings(50);
 327         });
 328
 329         test( "Uncompiled Empty Replace", function(){
 330                 for ( var i = 0; i < 50; i++ )
 331                         ret = tmp[i].replace( /aaaaaaaaaa/g, "" );
 332         });
 333
 334         prep(function(){
 335                 tmp = generateTestStrings(50);
 336         });
 337
 338         test( "Uncompiled 12 Char Replace", function(){
 339                 for ( var i = 0; i < 50; i++ )
 340                         ret = tmp[i].replace( /aaaaaaaaaa/g, "asdfasdfasdf" );
 341         });
 342
 343         prep(function(){
 344                 tmp = generateTestStrings(100);
 345         });
 346
 347         test( "Uncompiled Object Match", function(){
 348                 for ( var i = 0; i < 100; i++ )
 349                         ret = tmp[i].match( new RegExp("aaaaaaaaaa", "g") );
 350         });
 351
 352         prep(function(){
 353                 tmp = generateTestStrings(100);
 354         });
 355
 356         test( "Uncompiled Object Test", function(){
 357                 for ( var i = 0; i < 100; i++ )
 358                         ret = (new RegExp("aaaaaaaaaa", "g")).test( tmp[i] );
 359         });
 360
 361         prep(function(){
 362                 tmp = generateTestStrings(50);
 363         });
 364
 365         test( "Uncompiled Object Empty Replace", function(){
 366                 for ( var i = 0; i < 50; i++ )
 367                         ret = tmp[i].replace( new RegExp("aaaaaaaaaa", "g"), "" );
 368         });
 369
 370         prep(function(){
 371                 tmp = generateTestStrings(50);
 372         });
 373
 374         test( "Uncompiled Object 12 Char Replace", function(){
 375                 for ( var i = 0; i < 50; i++ )
 376                         ret = tmp[i].replace( new RegExp("aaaaaaaaaa", "g"), "asdfasdfasdf" );
 377         });
 378
 379 endTest(); };
 380 </script>
 381 </head>
 382 <body></body>
 383 </html>