Make more JS files beter match the coding standard.

test/mjsunit/array-elements-from-array-prototype-chain.js

Index: test/mjsunit/array-elements-from-array-prototype-chain.js
diff --git a/test/mjsunit/array-elements-from-array-prototype-chain.js b/test/mjsunit/array-elements-from-array-prototype-chain.js
index edbeb2a64ed6b0b67c088a5ef79333ac516b59ff..2ec01fe45f96cf510c5c816a9ab5ad8a58b18a5e 100644
--- a/test/mjsunit/array-elements-from-array-prototype-chain.js
+++ b/test/mjsunit/array-elements-from-array-prototype-chain.js
@@ -40,152 +40,152 @@
 // 'dirty' VM.
 ////////////////////////////////////////////////////////////////////////
 
-var at3 = '@3'
-var at7 = '@7'
+var at3 = '@3';
+var at7 = '@7';
 
 Array.prototype.__proto__ = {3: at3};
 Array.prototype.__proto__.__proto__ = {7: at7};
 
-var a = new Array(13)
+var a = new Array(13);
 
-assertEquals(at3, a[3])
-assertFalse(a.hasOwnProperty(3))
+assertEquals(at3, a[3]);
+assertFalse(a.hasOwnProperty(3));
 
-assertEquals(at7, a[7])
-assertFalse(a.hasOwnProperty(7))
+assertEquals(at7, a[7]);
+assertFalse(a.hasOwnProperty(7));
 
-assertEquals(undefined, a.shift(), 'hole should be returned as undefined')
+assertEquals(undefined, a.shift(), 'hole should be returned as undefined');
 // Side-effects: Array.prototype[3] percolates into a[2] and Array.prototype[7[
 // into a[6], still visible at the corresponding indices.
 
-assertEquals(at3, a[2])
-assertTrue(a.hasOwnProperty(2))
-assertEquals(at3, a[3])
-assertFalse(a.hasOwnProperty(3))
+assertEquals(at3, a[2]);
+assertTrue(a.hasOwnProperty(2));
+assertEquals(at3, a[3]);
+assertFalse(a.hasOwnProperty(3));
 
-assertEquals(at7, a[6])
-assertTrue(a.hasOwnProperty(6))
-assertEquals(at7, a[7])
-assertFalse(a.hasOwnProperty(7))
+assertEquals(at7, a[6]);
+assertTrue(a.hasOwnProperty(6));
+assertEquals(at7, a[7]);
+assertFalse(a.hasOwnProperty(7));
 
-a.unshift('foo', 'bar')
+a.unshift('foo', 'bar');
 // Side-effects: Array.prototype[3] now percolates into a[5] and Array.prototype[7]

[Rico, 2011/12/08 10:24:37]

long line

 // into a[9].
 
-assertEquals(at3, a[3])
-assertFalse(a.hasOwnProperty(3))
-assertEquals(at3, a[4])
-assertTrue(a.hasOwnProperty(4))
-assertEquals(at3, a[5])
-assertTrue(a.hasOwnProperty(5))
+assertEquals(at3, a[3]);
+assertFalse(a.hasOwnProperty(3));
+assertEquals(at3, a[4]);
+assertTrue(a.hasOwnProperty(4));
+assertEquals(at3, a[5]);
+assertTrue(a.hasOwnProperty(5));
 
-assertEquals(undefined, a[6])
-assertFalse(a.hasOwnProperty(6))
+assertEquals(undefined, a[6]);
+assertFalse(a.hasOwnProperty(6));
 
-assertEquals(at7, a[7])
-assertFalse(a.hasOwnProperty(7))
-assertEquals(at7, a[8])
-assertTrue(a.hasOwnProperty(8))
-assertEquals(at7, a[9])
-assertTrue(a.hasOwnProperty(9))
+assertEquals(at7, a[7]);
+assertFalse(a.hasOwnProperty(7));
+assertEquals(at7, a[8]);
+assertTrue(a.hasOwnProperty(8));
+assertEquals(at7, a[9]);
+assertTrue(a.hasOwnProperty(9));
 
-var sliced = a.slice(3, 10)
+var sliced = a.slice(3, 10);
 // Slice must keep intact a and reify holes at indices 0--2 and 4--6.
 
-assertEquals(at3, a[3])
-assertFalse(a.hasOwnProperty(3))
-assertEquals(at3, a[4])
-assertTrue(a.hasOwnProperty(4))
-assertEquals(at3, a[5])
-assertTrue(a.hasOwnProperty(5))
-
-assertEquals(undefined, a[6])
-assertFalse(a.hasOwnProperty(6))
-
-assertEquals(at7, a[7])
-assertFalse(a.hasOwnProperty(7))
-assertEquals(at7, a[8])
-assertTrue(a.hasOwnProperty(8))
-assertEquals(at7, a[9])
-assertTrue(a.hasOwnProperty(9))
-
-assertEquals(at3, sliced[0])
-assertTrue(sliced.hasOwnProperty(0))
-assertEquals(at3, sliced[1])
-assertTrue(sliced.hasOwnProperty(1))
-assertEquals(at3, sliced[2])
-assertTrue(sliced.hasOwnProperty(2))
+assertEquals(at3, a[3]);
+assertFalse(a.hasOwnProperty(3));
+assertEquals(at3, a[4]);
+assertTrue(a.hasOwnProperty(4));
+assertEquals(at3, a[5]);
+assertTrue(a.hasOwnProperty(5));
+
+assertEquals(undefined, a[6]);
+assertFalse(a.hasOwnProperty(6));
+
+assertEquals(at7, a[7]);
+assertFalse(a.hasOwnProperty(7));
+assertEquals(at7, a[8]);
+assertTrue(a.hasOwnProperty(8));
+assertEquals(at7, a[9]);
+assertTrue(a.hasOwnProperty(9));
+
+assertEquals(at3, sliced[0]);
+assertTrue(sliced.hasOwnProperty(0));
+assertEquals(at3, sliced[1]);
+assertTrue(sliced.hasOwnProperty(1));
+assertEquals(at3, sliced[2]);
+assertTrue(sliced.hasOwnProperty(2));
 
 // Note: sliced[3] comes directly from Array.prototype[3]
 assertEquals(at3, sliced[3]);
-assertFalse(sliced.hasOwnProperty(3))
+assertFalse(sliced.hasOwnProperty(3));
 
-assertEquals(at7, sliced[4])
-assertTrue(sliced.hasOwnProperty(4))
-assertEquals(at7, sliced[5])
-assertTrue(sliced.hasOwnProperty(5))
-assertEquals(at7, sliced[6])
-assertTrue(sliced.hasOwnProperty(6))
+assertEquals(at7, sliced[4]);
+assertTrue(sliced.hasOwnProperty(4));
+assertEquals(at7, sliced[5]);
+assertTrue(sliced.hasOwnProperty(5));
+assertEquals(at7, sliced[6]);
+assertTrue(sliced.hasOwnProperty(6));
 
 
 // Splice is too complicated the operation, start afresh.
 
 // Shrking array.
-var a0 = [0, 1, , , 4, 5, , , , 9]
-var result = a0.splice(4, 1)
+var a0 = [0, 1, , , 4, 5, , , , 9];
+var result = a0.splice(4, 1);
 // Side-effects: everything before 4 is kept intact:
 
-assertEquals(0, a0[0])
-assertTrue(a0.hasOwnProperty(0))
-assertEquals(1, a0[1])
-assertTrue(a0.hasOwnProperty(1))
-assertEquals(undefined, a0[2])
-assertFalse(a0.hasOwnProperty(2))
-assertEquals(at3, a0[3])
-assertFalse(a0.hasOwnProperty(3))
+assertEquals(0, a0[0]);
+assertTrue(a0.hasOwnProperty(0));
+assertEquals(1, a0[1]);
+assertTrue(a0.hasOwnProperty(1));
+assertEquals(undefined, a0[2]);
+assertFalse(a0.hasOwnProperty(2));
+assertEquals(at3, a0[3]);
+assertFalse(a0.hasOwnProperty(3));
 
 // 4 and above shifted left by one reifying at7 into a0[6] and keeping
 // a hole at a0[7]
 
-assertEquals(5, a0[4])
-assertTrue(a0.hasOwnProperty(4))
-assertEquals(undefined, a0[5])
-assertFalse(a0.hasOwnProperty(5))
-assertEquals(at7, a0[6])
-assertTrue(a0.hasOwnProperty(6))
-assertEquals(at7, a0[7])
-assertFalse(a0.hasOwnProperty(7))
-assertEquals(9, a0[8])
-assertTrue(a0.hasOwnProperty(8))
+assertEquals(5, a0[4]);
+assertTrue(a0.hasOwnProperty(4));
+assertEquals(undefined, a0[5]);
+assertFalse(a0.hasOwnProperty(5));
+assertEquals(at7, a0[6]);
+assertTrue(a0.hasOwnProperty(6));
+assertEquals(at7, a0[7]);
+assertFalse(a0.hasOwnProperty(7));
+assertEquals(9, a0[8]);
+assertTrue(a0.hasOwnProperty(8));
 
 // Growing array.
-var a1 = [0, 1, , , 4, 5, , , , 9]
-var result = a1.splice(4, 0, undefined)
+var a1 = [0, 1, , , 4, 5, , , , 9];
+var result = a1.splice(4, 0, undefined);
 // Side-effects: everything before 4 is kept intact:
 
-assertEquals(0, a1[0])
-assertTrue(a1.hasOwnProperty(0))
-assertEquals(1, a1[1])
-assertTrue(a1.hasOwnProperty(1))
-assertEquals(undefined, a1[2])
-assertFalse(a1.hasOwnProperty(2))
-assertEquals(at3, a1[3])
-assertFalse(a1.hasOwnProperty(3))
+assertEquals(0, a1[0]);
+assertTrue(a1.hasOwnProperty(0));
+assertEquals(1, a1[1]);
+assertTrue(a1.hasOwnProperty(1));
+assertEquals(undefined, a1[2]);
+assertFalse(a1.hasOwnProperty(2));
+assertEquals(at3, a1[3]);
+assertFalse(a1.hasOwnProperty(3));
 
 // Now owned undefined resides at 4 and rest is shifted right by one
 // reifying at7 into a0[8] and keeping a hole at a0[7].
 
-assertEquals(undefined, a1[4])
-assertTrue(a1.hasOwnProperty(4))
-assertEquals(4, a1[5])
-assertTrue(a1.hasOwnProperty(5))
-assertEquals(5, a1[6])
-assertTrue(a1.hasOwnProperty(6))
-assertEquals(at7, a1[7])
-assertFalse(a1.hasOwnProperty(7))
-assertEquals(at7, a1[8])
-assertTrue(a1.hasOwnProperty(8))
-assertEquals(undefined, a1[9])
-assertFalse(a1.hasOwnProperty(9))
-assertEquals(9, a1[10])
-assertTrue(a1.hasOwnProperty(10))
+assertEquals(undefined, a1[4]);
+assertTrue(a1.hasOwnProperty(4));
+assertEquals(4, a1[5]);
+assertTrue(a1.hasOwnProperty(5));
+assertEquals(5, a1[6]);
+assertTrue(a1.hasOwnProperty(6));
+assertEquals(at7, a1[7]);
+assertFalse(a1.hasOwnProperty(7));
+assertEquals(at7, a1[8]);
+assertTrue(a1.hasOwnProperty(8));
+assertEquals(undefined, a1[9]);
+assertFalse(a1.hasOwnProperty(9));
+assertEquals(9, a1[10]);
+assertTrue(a1.hasOwnProperty(10));