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. 17 * Portions created by the Initial Developer are Copyright (C) 2002 18 * the Initial Developer. All Rights Reserved. 19 * 20 * Contributor(s): igor (at) icesoft.no, pschwartau (at) 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: 09 November 2002 38 * SUMMARY: Test that interpreter can handle string literals exceeding 64K 39 * See http://bugzilla.mozilla.org/show_bug.cgi?id=179068 40 * 41 * Test that the interpreter can handle string literals exceeding 64K limit. 42 * For that the script passes to eval() "str ='LONG_STRING_LITERAL';" where 43 * LONG_STRING_LITERAL is a string with 200K chars. 44 * 45 * Igor Bukanov explains the technique used below: 46 * 47 * > Philip Schwartau wrote: 48 * >... 49 * > Here is the heart of the testcase: 50 * > 51 * > // Generate 200K long string 52 * > var long_str = duplicate(LONG_STR_SEED, N); 53 * > var str = ""; 54 * > eval("str='".concat(long_str, "';")); 55 * > var test_is_ok = (str.length == LONG_STR_SEED.length * N); 56 * > 57 * > 58 * > The testcase creates two identical strings, |long_str| and |str|. It 59 * > uses eval() simply to assign the value of |long_str| to |str|. Why is 60 * > it necessary to have the variable |str|, then? Why not just create 61 * > |long_str| and test it? Wouldn't this be enough: 62 * > 63 * > // Generate 200K long string 64 * > var long_str = duplicate(LONG_STR_SEED, N); 65 * > var test_is_ok = (long_str.length == LONG_STR_SEED.length * N); 66 * > 67 * > Or do we specifically need to test eval() to exercise the interpreter? 68 * 69 * The reason for eval is to test string literals like in 'a string literal 70 * with 100 000 characters...', Rhino deals fine with strings generated at 71 * run time where lengths > 64K. Without eval it would be necessary to have 72 * a test file excedding 64K which is not that polite for CVS and then a 73 * special treatment for the compiled mode in Rhino should be added. 74 * 75 * 76 * > 77 * > If so, is it important to use the concat() method in the assignment, as 78 * > you have done: |eval("str='".concat(long_str, "';"))|, or can we simply 79 * > do |eval("str = long_str;")| ? 80 * 81 * The concat is a replacement for eval("str='"+long_str+"';"), but as 82 * long_str is huge, this leads to constructing first a new string via 83 * "str='"+long_str and then another one via ("str='"+long_str) + "';" 84 * which takes time under JDK 1.1 on a something like StrongArm 200MHz. 85 * Calling concat makes less copies, that is why it is used in the 86 * duplicate function and this is faster then doing recursion like in the 87 * test case to test that 64K different string literals can be handled. 88 * 89 */ 90 //----------------------------------------------------------------------------- 91 var UBound = 0; 92 var bug = 179068; 93 var summary = 'Test that interpreter can handle string literals exceeding 64K'; 94 var status = ''; 95 var statusitems = []; 96 var actual = ''; 97 var actualvalues = []; 98 var expect= ''; 99 var expectedvalues = []; 100 var LONG_STR_SEED = "0123456789"; 101 var N = 20 * 1024; 102 var str = ""; 103 104 105 // Generate 200K long string and assign it to |str| via eval() 106 var long_str = duplicate(LONG_STR_SEED, N); 107 eval("str='".concat(long_str, "';")); 108 109 status = inSection(1); 110 actual = str.length == LONG_STR_SEED.length * N 111 expect = true; 112 addThis(); 113 114 115 116 //----------------------------------------------------------------------------- 117 test(); 118 //----------------------------------------------------------------------------- 119 120 121 122 function duplicate(str, count) 123 { 124 var tmp = new Array(count); 125 126 while (count != 0) 127 tmp[--count] = str; 128 129 return String.prototype.concat.apply("", tmp); 130 } 131 132 133 function addThis() 134 { 135 statusitems[UBound] = status; 136 actualvalues[UBound] = actual; 137 expectedvalues[UBound] = expect; 138 UBound++; 139 } 140 141 142 function test() 143 { 144 enterFunc('test'); 145 printBugNumber(bug); 146 printStatus(summary); 147 148 for (var i=0; i<UBound; i++) 149 { 150 reportCompare(expectedvalues[i], actualvalues[i], statusitems[i]); 151 } 152 153 exitFunc ('test'); 154 } 155
