@qooxdoo/framework 7.0.0-beta.5 → 7.0.0-beta.9

package/source/class/qx/test/data/DataArray.js

@@ -15,27 +15,21 @@
      * Martin Wittemann (martinwittemann)
 
 ************************************************************************ */
-qx.Class.define("qx.test.data.DataArray",
-{
-  extend : qx.dev.unit.TestCase,
-
-  members :
-  {
+qx.Class.define("qx.test.data.DataArray", {
+  extend: qx.dev.unit.TestCase,
 
+  members: {
     __a: null,
 
-    setUp : function()
-    {
+    setUp() {
       this.__a = new qx.data.Array("one", "two", "three");
     },
 
-
-    tearDown : function()
-    {
+    tearDown() {
       this.__a.dispose();
     },
 
-    testConstructor: function() {
+    testConstructor() {
       // create empty array
       var a = new qx.data.Array();
       this.assertEquals(0, a.length, "Length does not fit an an empty array!");
@@ -61,95 +55,200 @@ qx.Class.define("qx.test.data.DataArray",
       a.dispose();
 
       // test some wrong inputs
-      this.assertException(function() {
-        new qx.data.Array(true);
-      }, Error, null, "Boolean not supported!");
-      this.assertException(function() {
-        new qx.data.Array({});
-      }, Error, null, "Objects not supported!");
-      this.assertException(function() {
-        new qx.data.Array(function() {});
-      }, Error, null, "Functions not supported!");
+      this.assertException(
+        function () {
+          new qx.data.Array(true);
+        },
+        Error,
+        null,
+        "Boolean not supported!"
+      );
+
+      this.assertException(
+        function () {
+          new qx.data.Array({});
+        },
+        Error,
+        null,
+        "Objects not supported!"
+      );
+
+      this.assertException(
+        function () {
+          new qx.data.Array(function () {});
+        },
+        Error,
+        null,
+        "Functions not supported!"
+      );
     },
 
-
-    testGetItem: function() {
+    testGetItem() {
       // check the getvalue function
-      this.assertEquals("one", this.__a.getItem(0), "IndexAt does not work at position 0");
-      this.assertEquals("two", this.__a.getItem(1), "IndexAt does not work at position 1");
-      this.assertEquals("three", this.__a.getItem(2), "IndexAt does not work at position 2");
+      this.assertEquals(
+        "one",
+        this.__a.getItem(0),
+        "IndexAt does not work at position 0"
+      );
+
+      this.assertEquals(
+        "two",
+        this.__a.getItem(1),
+        "IndexAt does not work at position 1"
+      );
+
+      this.assertEquals(
+        "three",
+        this.__a.getItem(2),
+        "IndexAt does not work at position 2"
+      );
 
       // try some wrong inputs
-      this.assertUndefined(this.__a.getItem(-1), "There should be no element at -1");
-      this.assertUndefined(this.__a.getItem(3), "There should be no element at 3");
+      this.assertUndefined(
+        this.__a.getItem(-1),
+        "There should be no element at -1"
+      );
+
+      this.assertUndefined(
+        this.__a.getItem(3),
+        "There should be no element at 3"
+      );
     },
 
-
-    testSetItem: function() {
+    testSetItem() {
       this.__a.setItem(0, "eins");
-      this.assertEquals("eins", this.__a.getItem(0), "IndexAt does not work at position 0");
+      this.assertEquals(
+        "eins",
+        this.__a.getItem(0),
+        "IndexAt does not work at position 0"
+      );
+
       this.__a.setItem(3, "drei");
-      this.assertEquals("drei", this.__a.getItem(3), "IndexAt does not work at position 0");
+      this.assertEquals(
+        "drei",
+        this.__a.getItem(3),
+        "IndexAt does not work at position 0"
+      );
     },
 
-
-    testJoin: function() {
-      this.assertEquals("one, two, three", this.__a.join(", "), "Join does not work");
+    testJoin() {
+      this.assertEquals(
+        "one, two, three",
+        this.__a.join(", "),
+        "Join does not work"
+      );
     },
 
-
-    testReverse: function() {
+    testReverse() {
       this.__a.reverse();
       this.assertEquals("one", this.__a.getItem(2), "Reverse does not work");
 
       // test for the event
       var a = new qx.data.Array(1, 2, 3);
       var self = this;
-      this.assertEventFired(a, "change", function () {
-        a.reverse();
-      }, function(e) {
-        self.assertEquals(0, e.getData().start, "Wrong start index in the event.");
-        self.assertEquals(2, e.getData().end, "Wrong end index in the event.");
-        self.assertEquals("order", e.getData().type, "Wrong type in the event.");
-      }, "Change event not fired!");
+      this.assertEventFired(
+        a,
+        "change",
+        function () {
+          a.reverse();
+        },
+        function (e) {
+          self.assertEquals(
+            0,
+            e.getData().start,
+            "Wrong start index in the event."
+          );
+
+          self.assertEquals(
+            2,
+            e.getData().end,
+            "Wrong end index in the event."
+          );
+
+          self.assertEquals(
+            "order",
+            e.getData().type,
+            "Wrong type in the event."
+          );
+        },
+        "Change event not fired!"
+      );
+
       a.dispose();
     },
 
-
-    testSort: function() {
+    testSort() {
       this.__a.sort();
-      this.assertEquals("one three two", this.__a.join(" "), "Simple sort does not work");
-      this.__a.sort(function(a, b) {
+      this.assertEquals(
+        "one three two",
+        this.__a.join(" "),
+        "Simple sort does not work"
+      );
+
+      this.__a.sort(function (a, b) {
         return a > b ? -1 : 1;
       });
-      this.assertEquals("two three one", this.__a.join(" "), "Own sort does not work");
+      this.assertEquals(
+        "two three one",
+        this.__a.join(" "),
+        "Own sort does not work"
+      );
 
       // test for the event
       var a = new qx.data.Array(2, 7, 5);
       var self = this;
-      this.assertEventFired(a, "change", function () {
-        a.sort();
-      }, function(e) {
-        self.assertEquals(0, e.getData().start, "Wrong start index in the event.");
-        self.assertEquals(2, e.getData().end, "Wrong end index in the event.");
-        self.assertEquals("order", e.getData().type, "Wrong type in the event.");
-      }, "Change event not fired!");
+      this.assertEventFired(
+        a,
+        "change",
+        function () {
+          a.sort();
+        },
+        function (e) {
+          self.assertEquals(
+            0,
+            e.getData().start,
+            "Wrong start index in the event."
+          );
+
+          self.assertEquals(
+            2,
+            e.getData().end,
+            "Wrong end index in the event."
+          );
+
+          self.assertEquals(
+            "order",
+            e.getData().type,
+            "Wrong type in the event."
+          );
+        },
+        "Change event not fired!"
+      );
+
       a.dispose();
     },
 
+    testConcat() {
+      var b = this.__a.concat(["four", "five"]);
+      this.assertEquals(
+        "one two three four five",
+        b.join(" "),
+        "Concat does not work"
+      );
 
-    testConcat: function() {
-       var b = this.__a.concat(["four", "five"]);
-       this.assertEquals("one two three four five", b.join(" "), "Concat does not work");
-       b.dispose();
-       
-       var b = this.__a.concat(new qx.data.Array(["four", "five"]));
-       this.assertEquals("one two three four five", b.join(" "), "Concat does not work");
-       b.dispose();
-    },
+      b.dispose();
+
+      var b = this.__a.concat(new qx.data.Array(["four", "five"]));
+      this.assertEquals(
+        "one two three four five",
+        b.join(" "),
+        "Concat does not work"
+      );
 
+      b.dispose();
+    },
 
-    testSlice: function() {
+    testSlice() {
       var slice = this.__a.slice(0, 1);
       this.assertEquals("one", slice.getItem(0), "Slice does not work");
       slice.dispose();
@@ -163,28 +262,26 @@ qx.Class.define("qx.test.data.DataArray",
       this.assertEquals("two", slice.getItem(1), "Slice does not work");
       slice.dispose();
     },
-    
-    
-    testReplace: function() {
+
+    testReplace() {
       var numFired = 0;
-      var id = this.__a.addListener("change", function() {
+      var id = this.__a.addListener("change", function () {
         numFired++;
       });
-      
-      this.__a.replace([ "one", "two", "three" ]);
+
+      this.__a.replace(["one", "two", "three"]);
       this.assertEquals(0, numFired);
-      this.__a.replace([ "one", "three" ]);
+      this.__a.replace(["one", "three"]);
       this.assertEquals(1, numFired);
-      this.assertArrayEquals([ "one", "three" ], this.__a.toArray());
-      this.__a.replace(new qx.data.Array([ "two", "four" ]));
+      this.assertArrayEquals(["one", "three"], this.__a.toArray());
+      this.__a.replace(new qx.data.Array(["two", "four"]));
       this.assertEquals(2, numFired);
-      this.assertArrayEquals([ "two", "four" ], this.__a.toArray());
-      
+      this.assertArrayEquals(["two", "four"], this.__a.toArray());
+
       this.__a.removeListenerById(id);
     },
 
-
-    testPop: function() {
+    testPop() {
       this.assertEquals("three", this.__a.pop(), "Pop does not work.");
       this.assertEquals(2, this.__a.length, "Wrong length after pop");
       this.assertEquals("two", this.__a.pop(), "Pop does not work.");
@@ -192,45 +289,79 @@ qx.Class.define("qx.test.data.DataArray",
       this.assertEquals(0, this.__a.length, "Wrong length after pop");
     },
 
+    testPush() {
+      this.assertEquals(
+        4,
+        this.__a.push("four"),
+        "Push does not give the right length back."
+      );
+
+      this.assertEquals(
+        "one two three four",
+        this.__a.join(" "),
+        "Single push does not work."
+      );
 
-    testPush: function() {
-      this.assertEquals(4, this.__a.push("four"), "Push does not give the right length back.");
-      this.assertEquals("one two three four", this.__a.join(" "), "Single push does not work.");
       this.assertEquals(4, this.__a.length, "Single push does not work.");
       this.__a.dispose();
       this.__a = new qx.data.Array();
       this.__a.push(1, 2, 3);
-      this.assertEquals("1 2 3", this.__a.join(" "), "Multiple push does not work.");
+      this.assertEquals(
+        "1 2 3",
+        this.__a.join(" "),
+        "Multiple push does not work."
+      );
     },
 
-
-    testShift: function() {
+    testShift() {
       this.assertEquals("one", this.__a.shift(), "Shift does not work.");
-      this.assertEquals("two three", this.__a.join(" "), "Shift does not work.");
+      this.assertEquals(
+        "two three",
+        this.__a.join(" "),
+        "Shift does not work."
+      );
+
       this.assertEquals("two", this.__a.shift(), "Shift does not work.");
       this.assertEquals(1, this.__a.length, "Shift does not work.");
     },
 
-
-    testShiftWithEventPropagation : function() {
+    testShiftWithEventPropagation() {
       var data = {
-        "bar" : [1,2,3,4,5]
+        bar: [1, 2, 3, 4, 5]
       };
-      var model = qx.data.marshal.Json.createModel( data, true );
+
+      var model = qx.data.marshal.Json.createModel(data, true);
       this.assertEquals(1, model.getBar().shift());
       model.dispose();
     },
 
-
-    testUnshift: function() {
-      this.assertEquals(4, this.__a.unshift("zero"), "Unshift does not return the proper length.");
-      this.assertEquals("zero one two three", this.__a.join(" "), "Unshift does not work!");
-      this.assertEquals(6, this.__a.unshift("-2", "-1"), "Unshift does not return the proper length.");
-      this.assertEquals("-2 -1 zero one two three", this.__a.join(" "), "Unshift does not work!");
+    testUnshift() {
+      this.assertEquals(
+        4,
+        this.__a.unshift("zero"),
+        "Unshift does not return the proper length."
+      );
+
+      this.assertEquals(
+        "zero one two three",
+        this.__a.join(" "),
+        "Unshift does not work!"
+      );
+
+      this.assertEquals(
+        6,
+        this.__a.unshift("-2", "-1"),
+        "Unshift does not return the proper length."
+      );
+
+      this.assertEquals(
+        "-2 -1 zero one two three",
+        this.__a.join(" "),
+        "Unshift does not work!"
+      );
     },
 
-
-    testSplice: function() {
+    testSplice() {
       var a = new qx.data.Array(1, 2, 3, 4, 5, 6, 7, 8);
 
       var splice = a.splice(4, a.length - 1);
@@ -259,57 +390,80 @@ qx.Class.define("qx.test.data.DataArray",
       a.dispose();
     },
 
+    testToArray() {
+      this.assertEquals(
+        "one two three",
+        this.__a.toArray().join(" "),
+        "toArray does not work!"
+      );
 
-    testToArray: function() {
-      this.assertEquals("one two three", this.__a.toArray().join(" "), "toArray does not work!");
-      this.assertInstance( this.__a.toArray(), Array, "toArray does not work!");
+      this.assertInstance(this.__a.toArray(), Array, "toArray does not work!");
     },
 
-
-    testLengthEvent: function() {
+    testLengthEvent() {
       var self = this;
       // test for the event
       var a = new qx.data.Array(1, 2, 3);
-      this.assertEventFired(a, "changeLength", function () {
-        a.pop();
-      }, function(e) {
-        self.assertEquals(2, e.getData());
-        self.assertEquals(3, e.getOldData());
-      }, "ChangeLength event not fired!");
+      this.assertEventFired(
+        a,
+        "changeLength",
+        function () {
+          a.pop();
+        },
+        function (e) {
+          self.assertEquals(2, e.getData());
+          self.assertEquals(3, e.getOldData());
+        },
+        "ChangeLength event not fired!"
+      );
+
       a.dispose();
     },
 
-
-    testToString: function() {
-      this.assertEquals(this.__a.toArray().toString(), this.__a.toString(), "toString does not work!");
+    testToString() {
+      this.assertEquals(
+        this.__a.toArray().toString(),
+        this.__a.toString(),
+        "toString does not work!"
+      );
     },
 
-
-    testContains: function() {
+    testContains() {
       this.assertTrue(this.__a.contains("one"), "contains does not work!");
       this.assertTrue(this.__a.contains("two"), "contains does not work!");
       this.assertTrue(this.__a.contains("three"), "contains does not work!");
     },
 
-
-    testIndexOf: function() {
+    testIndexOf() {
       this.assertEquals(0, this.__a.indexOf("one"), "indexOf does not work!");
       this.assertEquals(1, this.__a.indexOf("two"), "indexOf does not work!");
       this.assertEquals(2, this.__a.indexOf("three"), "indexOf does not work!");
     },
 
-
-    testLastIndexOf: function() {
+    testLastIndexOf() {
       this.__a.push("one");
       this.__a.push("two");
       this.__a.push("three");
-      this.assertEquals(3, this.__a.lastIndexOf("one"), "lastIndexOf does not work!");
-      this.assertEquals(4, this.__a.lastIndexOf("two"), "lastIndexOf does not work!");
-      this.assertEquals(5, this.__a.lastIndexOf("three"), "lastIndexOf does not work!");
+      this.assertEquals(
+        3,
+        this.__a.lastIndexOf("one"),
+        "lastIndexOf does not work!"
+      );
+
+      this.assertEquals(
+        4,
+        this.__a.lastIndexOf("two"),
+        "lastIndexOf does not work!"
+      );
+
+      this.assertEquals(
+        5,
+        this.__a.lastIndexOf("three"),
+        "lastIndexOf does not work!"
+      );
     },
 
-
-    testCopy: function(attribute) {
+    testCopy(attribute) {
       var a = this.__a.copy();
       // change the original array
       this.__a.setItem(0, "0");
@@ -324,8 +478,7 @@ qx.Class.define("qx.test.data.DataArray",
       a.dispose();
     },
 
-
-    testInsertAt: function() {
+    testInsertAt() {
       this.__a.insertAt(1, "eins");
       this.__a.insertAt(3, "drei");
 
@@ -337,34 +490,79 @@ qx.Class.define("qx.test.data.DataArray",
       this.assertEquals("three", this.__a.getItem(4), "insertAt does not work");
     },
 
-
-    testInsertBefore: function() {
+    testInsertBefore() {
       this.__a.insertBefore("two", "eins");
       this.__a.insertBefore("three", "drei");
 
       // check the value
-      this.assertEquals("one", this.__a.getItem(0), "insertBefore does not work");
-      this.assertEquals("eins", this.__a.getItem(1), "insertBefore does not work");
-      this.assertEquals("two", this.__a.getItem(2), "insertBefore does not work");
-      this.assertEquals("drei", this.__a.getItem(3), "insertBefore does not work");
-      this.assertEquals("three", this.__a.getItem(4), "insertBefore does not work");
+      this.assertEquals(
+        "one",
+        this.__a.getItem(0),
+        "insertBefore does not work"
+      );
+
+      this.assertEquals(
+        "eins",
+        this.__a.getItem(1),
+        "insertBefore does not work"
+      );
+
+      this.assertEquals(
+        "two",
+        this.__a.getItem(2),
+        "insertBefore does not work"
+      );
+
+      this.assertEquals(
+        "drei",
+        this.__a.getItem(3),
+        "insertBefore does not work"
+      );
+
+      this.assertEquals(
+        "three",
+        this.__a.getItem(4),
+        "insertBefore does not work"
+      );
     },
 
-
-    testInsertAfter: function() {
+    testInsertAfter() {
       this.__a.insertAfter("one", "eins");
       this.__a.insertAfter("two", "drei");
 
       // check the value
-      this.assertEquals("one", this.__a.getItem(0), "insertAfter does not work");
-      this.assertEquals("eins", this.__a.getItem(1), "insertAfter does not work");
-      this.assertEquals("two", this.__a.getItem(2), "insertAfter does not work");
-      this.assertEquals("drei", this.__a.getItem(3), "insertAfter does not work");
-      this.assertEquals("three", this.__a.getItem(4), "insertAfter does not work");
+      this.assertEquals(
+        "one",
+        this.__a.getItem(0),
+        "insertAfter does not work"
+      );
+
+      this.assertEquals(
+        "eins",
+        this.__a.getItem(1),
+        "insertAfter does not work"
+      );
+
+      this.assertEquals(
+        "two",
+        this.__a.getItem(2),
+        "insertAfter does not work"
+      );
+
+      this.assertEquals(
+        "drei",
+        this.__a.getItem(3),
+        "insertAfter does not work"
+      );
+
+      this.assertEquals(
+        "three",
+        this.__a.getItem(4),
+        "insertAfter does not work"
+      );
     },
 
-
-    testRemoveAt: function() {
+    testRemoveAt() {
       var removed = this.__a.removeAt(1);
 
       // check the value
@@ -373,38 +571,61 @@ qx.Class.define("qx.test.data.DataArray",
       this.assertEquals("three", this.__a.getItem(1), "removeAt does not work");
     },
 
-
-    testRemoveAll: function() {
-
+    testRemoveAll() {
       var self = this;
-      this.assertEventFired(self.__a, "changeLength", function () {
-        self.__a.removeAll();
-      }, function(e) {
-        self.assertEquals(0, self.__a.getLength(), "length not 0");
-      }, "Change event not fired!");
-
+      this.assertEventFired(
+        self.__a,
+        "changeLength",
+        function () {
+          self.__a.removeAll();
+        },
+        function (e) {
+          self.assertEquals(0, self.__a.getLength(), "length not 0");
+        },
+        "Change event not fired!"
+      );
 
       this.__a.push("a");
       this.__a.push("b");
 
-      this.assertEventFired(self.__a, "change", function () {
-        var removed = self.__a.removeAll();
-        self.assertEquals(2, removed.length);
-        self.assertEquals("a", removed[0]);
-        self.assertEquals("b", removed[1]);
-      }, function(e) {
-        self.assertEquals(0, e.getData().start, "Wrong start index in the event.");
-        self.assertEquals(1, e.getData().end, "Wrong end index in the event.");
-        self.assertEquals("remove", e.getData().type, "Wrong type in the event.");
-        self.assertEquals("a", e.getData().removed[0]);
-        self.assertEquals("b", e.getData().removed[1]);
-      }, "Change event not fired!");
+      this.assertEventFired(
+        self.__a,
+        "change",
+        function () {
+          var removed = self.__a.removeAll();
+          self.assertEquals(2, removed.length);
+          self.assertEquals("a", removed[0]);
+          self.assertEquals("b", removed[1]);
+        },
+        function (e) {
+          self.assertEquals(
+            0,
+            e.getData().start,
+            "Wrong start index in the event."
+          );
+
+          self.assertEquals(
+            1,
+            e.getData().end,
+            "Wrong end index in the event."
+          );
+
+          self.assertEquals(
+            "remove",
+            e.getData().type,
+            "Wrong type in the event."
+          );
+
+          self.assertEquals("a", e.getData().removed[0]);
+          self.assertEquals("b", e.getData().removed[1]);
+        },
+        "Change event not fired!"
+      );
 
       this.assertEquals(0, this.__a.length, "RemoveAll does not work.");
     },
 
-
-    testAppend: function() {
+    testAppend() {
       var dArray = new qx.data.Array("4", "5");
       this.__a.append(dArray.toArray());
 
@@ -422,20 +643,18 @@ qx.Class.define("qx.test.data.DataArray",
       this.assertEquals("sechs", this.__a.getItem(5), "append does not work");
       dArray.dispose();
     },
-    
-    
-    testExclude: function() {
-      var tmp = new qx.data.Array([ "one", "two", "three", "four", "five" ]);
-      tmp.exclude([ "two", "four" ]);
-      this.assertArrayEquals(tmp.toArray(), [ "one", "three", "five" ]);
-      
-      var tmp = new qx.data.Array([ "one", "two", "three", "four", "five" ]);
-      tmp.exclude(new qx.data.Array([ "one", "three", "five" ]));
-      this.assertArrayEquals(tmp.toArray(), [ "two", "four" ]);
-    },
 
+    testExclude() {
+      var tmp = new qx.data.Array(["one", "two", "three", "four", "five"]);
+      tmp.exclude(["two", "four"]);
+      this.assertArrayEquals(tmp.toArray(), ["one", "three", "five"]);
 
-    testRemove: function() {
+      var tmp = new qx.data.Array(["one", "two", "three", "four", "five"]);
+      tmp.exclude(new qx.data.Array(["one", "three", "five"]));
+      this.assertArrayEquals(tmp.toArray(), ["two", "four"]);
+    },
+
+    testRemove() {
       this.__a.remove("two");
 
       // check the value
@@ -443,17 +662,18 @@ qx.Class.define("qx.test.data.DataArray",
       this.assertEquals("three", this.__a.getItem(1), "removeAt does not work");
     },
 
-
-    testEquals: function() {
+    testEquals() {
       var a = new qx.data.Array("one", "two", "three");
       this.assertTrue(this.__a.equals(a), "equals does not work.");
       a.dispose();
-      
-      this.assertTrue(this.__a.equals([ "one", "two", "three" ]), "equals does not work.");
-    },
 
+      this.assertTrue(
+        this.__a.equals(["one", "two", "three"]),
+        "equals does not work."
+      );
+    },
 
-    testSum: function() {
+    testSum() {
       var a = new qx.data.Array(1, 2, 3);
 
       this.assertEquals(6, a.sum(), "sum does not work.");
@@ -461,8 +681,7 @@ qx.Class.define("qx.test.data.DataArray",
       a.dispose();
     },
 
-
-    testMax: function() {
+    testMax() {
       var a = new qx.data.Array(1, 2, 3);
 
       this.assertEquals(3, a.max(), "max does not work.");
@@ -470,8 +689,7 @@ qx.Class.define("qx.test.data.DataArray",
       a.dispose();
     },
 
-
-    testMin: function() {
+    testMin() {
       var a = new qx.data.Array(1, 2, -3);
 
       this.assertEquals(-3, a.min(), "min does not work.");
@@ -479,262 +697,697 @@ qx.Class.define("qx.test.data.DataArray",
       a.dispose();
     },
 
-
-    testPopEvent: function() {
+    testPopEvent() {
       // test for the event
       var a = new qx.data.Array(1, 2, 3);
       var self = this;
-      this.assertEventFired(a, "change", function () {
-        a.pop();
-      }, function(e) {
-        self.assertEquals(1, e.getData().start, "Wrong start index in the event.");
-        self.assertEquals(1, e.getData().end, "Wrong end index in the event.");
-        self.assertEquals("remove", e.getData().type, "Wrong type in the event.");
-        self.assertEquals(3, e.getData().removed[0], "Wrong removed array in the event.");
-      }, "Change event not fired!");
+      this.assertEventFired(
+        a,
+        "change",
+        function () {
+          a.pop();
+        },
+        function (e) {
+          self.assertEquals(
+            1,
+            e.getData().start,
+            "Wrong start index in the event."
+          );
+
+          self.assertEquals(
+            1,
+            e.getData().end,
+            "Wrong end index in the event."
+          );
+
+          self.assertEquals(
+            "remove",
+            e.getData().type,
+            "Wrong type in the event."
+          );
+
+          self.assertEquals(
+            3,
+            e.getData().removed[0],
+            "Wrong removed array in the event."
+          );
+        },
+        "Change event not fired!"
+      );
+
       a.dispose();
     },
 
-    testPushEvent: function() {
+    testPushEvent() {
       // test for the event
       var a = new qx.data.Array(1, 2, 3);
       var self = this;
-      this.assertEventFired(a, "change", function () {
-        a.push(4);
-      }, function(e) {
-        self.assertEquals(3, e.getData().start, "Wrong start index in the event.");
-        self.assertEquals(3, e.getData().end, "Wrong end index in the event.");
-        self.assertEquals("add", e.getData().type, "Wrong type in the event.");
-        self.assertEquals(4, e.getData().added[0], "Wrong item array in the event.");
-      }, "Change event not fired!");
+      this.assertEventFired(
+        a,
+        "change",
+        function () {
+          a.push(4);
+        },
+        function (e) {
+          self.assertEquals(
+            3,
+            e.getData().start,
+            "Wrong start index in the event."
+          );
+
+          self.assertEquals(
+            3,
+            e.getData().end,
+            "Wrong end index in the event."
+          );
+
+          self.assertEquals(
+            "add",
+            e.getData().type,
+            "Wrong type in the event."
+          );
+
+          self.assertEquals(
+            4,
+            e.getData().added[0],
+            "Wrong item array in the event."
+          );
+        },
+        "Change event not fired!"
+      );
+
       a.dispose();
     },
 
-    testAppendEvent: function() {
+    testAppendEvent() {
       // test for the event
       var a = new qx.data.Array(1, 2, 3);
       var self = this;
-      this.assertEventFired(a, "change", function () {
-        a.append([4, 5]);
-      }, function(e) {
-        self.assertEquals(3, e.getData().start, "Wrong start index in the event.");
-        self.assertEquals(4, e.getData().end, "Wrong end index in the event.");
-        self.assertEquals("add", e.getData().type, "Wrong type in the event.");
-        self.assertEquals(4, e.getData().added[0], "Wrong item array in the event.");
-        self.assertEquals(5, e.getData().added[1], "Wrong item array in the event.");
-      }, "Change event not fired!");
+      this.assertEventFired(
+        a,
+        "change",
+        function () {
+          a.append([4, 5]);
+        },
+        function (e) {
+          self.assertEquals(
+            3,
+            e.getData().start,
+            "Wrong start index in the event."
+          );
+
+          self.assertEquals(
+            4,
+            e.getData().end,
+            "Wrong end index in the event."
+          );
+
+          self.assertEquals(
+            "add",
+            e.getData().type,
+            "Wrong type in the event."
+          );
+
+          self.assertEquals(
+            4,
+            e.getData().added[0],
+            "Wrong item array in the event."
+          );
+
+          self.assertEquals(
+            5,
+            e.getData().added[1],
+            "Wrong item array in the event."
+          );
+        },
+        "Change event not fired!"
+      );
+
       a.dispose();
     },
 
-    testShiftEvent: function() {
+    testShiftEvent() {
       // test for the event
       var a = new qx.data.Array(1, 2, 3);
       var self = this;
-      this.assertEventFired(a, "change", function () {
-        a.shift();
-      }, function(e) {
-        self.assertEquals(0, e.getData().start, "Wrong start index in the event.");
-        self.assertEquals(1, e.getData().end, "Wrong end index in the event.");
-        self.assertEquals("remove", e.getData().type, "Wrong type in the event.");
-        self.assertEquals(1, e.getData().removed[0], "Wrong item in the event.");
-      }, "Change event not fired!");
+      this.assertEventFired(
+        a,
+        "change",
+        function () {
+          a.shift();
+        },
+        function (e) {
+          self.assertEquals(
+            0,
+            e.getData().start,
+            "Wrong start index in the event."
+          );
+
+          self.assertEquals(
+            1,
+            e.getData().end,
+            "Wrong end index in the event."
+          );
+
+          self.assertEquals(
+            "remove",
+            e.getData().type,
+            "Wrong type in the event."
+          );
+
+          self.assertEquals(
+            1,
+            e.getData().removed[0],
+            "Wrong item in the event."
+          );
+        },
+        "Change event not fired!"
+      );
+
       a.dispose();
     },
 
-    testUnshiftEvent: function() {
+    testUnshiftEvent() {
       // test for the event
       var a = new qx.data.Array(1, 2, 3);
       var self = this;
-      this.assertEventFired(a, "change", function () {
-        a.unshift(0);
-      }, function(e) {
-        self.assertEquals(0, e.getData().start, "Wrong start index in the event.");
-        self.assertEquals(3, e.getData().end, "Wrong end index in the event.");
-        self.assertEquals("add", e.getData().type, "Wrong type in the event.");
-        self.assertEquals(0, e.getData().added[0], "Wrong item in the event.");
-      }, "Change event not fired!");
+      this.assertEventFired(
+        a,
+        "change",
+        function () {
+          a.unshift(0);
+        },
+        function (e) {
+          self.assertEquals(
+            0,
+            e.getData().start,
+            "Wrong start index in the event."
+          );
+
+          self.assertEquals(
+            3,
+            e.getData().end,
+            "Wrong end index in the event."
+          );
+
+          self.assertEquals(
+            "add",
+            e.getData().type,
+            "Wrong type in the event."
+          );
+
+          self.assertEquals(
+            0,
+            e.getData().added[0],
+            "Wrong item in the event."
+          );
+        },
+        "Change event not fired!"
+      );
+
       a.dispose();
     },
 
-    testSpliceEvent: function() {
+    testSpliceEvent() {
       // test for the event (remove)
       var a = new qx.data.Array("a", "b", "c", "d", "e");
       var self = this;
-      this.assertEventFired(a, "change", function () {
-        a.splice(1, 2).dispose();
-      }, function(e) {
-        self.assertEquals(1, e.getData().start, "Wrong start index in the event (remove).");
-        self.assertEquals(2, e.getData().end, "Wrong end index in the event (remove).");
-        self.assertEquals("remove", e.getData().type, "Wrong type in the event (remove).");
-        self.assertEquals("b", e.getData().removed[0], "Wrong item in the event (remove).");
-        self.assertEquals("c", e.getData().removed[1], "Wrong item in the event (remove).");
-        self.assertEquals(2, e.getData().removed.length, "Wrong item in the event (remove).");
-        self.assertEquals(0, e.getData().added.length, "Wrong item in the event (remove).");
-      }, "Change event not fired!");
+      this.assertEventFired(
+        a,
+        "change",
+        function () {
+          a.splice(1, 2).dispose();
+        },
+        function (e) {
+          self.assertEquals(
+            1,
+            e.getData().start,
+            "Wrong start index in the event (remove)."
+          );
+
+          self.assertEquals(
+            2,
+            e.getData().end,
+            "Wrong end index in the event (remove)."
+          );
+
+          self.assertEquals(
+            "remove",
+            e.getData().type,
+            "Wrong type in the event (remove)."
+          );
+
+          self.assertEquals(
+            "b",
+            e.getData().removed[0],
+            "Wrong item in the event (remove)."
+          );
+
+          self.assertEquals(
+            "c",
+            e.getData().removed[1],
+            "Wrong item in the event (remove)."
+          );
+
+          self.assertEquals(
+            2,
+            e.getData().removed.length,
+            "Wrong item in the event (remove)."
+          );
+
+          self.assertEquals(
+            0,
+            e.getData().added.length,
+            "Wrong item in the event (remove)."
+          );
+        },
+        "Change event not fired!"
+      );
+
       a.dispose();
 
       // test for the event (add)
       a = new qx.data.Array("a", "b", "c");
-      this.assertEventFired(a, "change", function () {
-        a.splice(0, 0, "x").dispose();
-      }, function(e) {
-        self.assertEquals(0, e.getData().start, "Wrong start index in the event. (add)");
-        self.assertEquals(1, e.getData().end, "Wrong end index in the event. (add)");
-        self.assertEquals("add", e.getData().type, "Wrong type in the event. (add)");
-        self.assertEquals("x", e.getData().added[0], "Wrong items in the event. (add)");
-        self.assertEquals(1, e.getData().added.length, "Wrong amount of items in the event. (add)");
-        self.assertEquals(0, e.getData().removed.length, "Wrong amount of items in the event. (add)");
-      }, "Change event not fired!");
+      this.assertEventFired(
+        a,
+        "change",
+        function () {
+          a.splice(0, 0, "x").dispose();
+        },
+        function (e) {
+          self.assertEquals(
+            0,
+            e.getData().start,
+            "Wrong start index in the event. (add)"
+          );
+
+          self.assertEquals(
+            1,
+            e.getData().end,
+            "Wrong end index in the event. (add)"
+          );
+
+          self.assertEquals(
+            "add",
+            e.getData().type,
+            "Wrong type in the event. (add)"
+          );
+
+          self.assertEquals(
+            "x",
+            e.getData().added[0],
+            "Wrong items in the event. (add)"
+          );
+
+          self.assertEquals(
+            1,
+            e.getData().added.length,
+            "Wrong amount of items in the event. (add)"
+          );
+
+          self.assertEquals(
+            0,
+            e.getData().removed.length,
+            "Wrong amount of items in the event. (add)"
+          );
+        },
+        "Change event not fired!"
+      );
+
       a.dispose();
 
       // test for the event (add/remove)
       a = new qx.data.Array("a", "b", "c");
-      this.assertEventFired(a, "change", function () {
-        a.splice(0, 1, "x").dispose();
-      }, function(e) {
-        self.assertEquals(0, e.getData().start, "Wrong start index in the event. (add/remove)");
-        self.assertEquals(0, e.getData().end, "Wrong end index in the event. (add/remove)");
-        self.assertEquals("add/remove", e.getData().type, "Wrong type in the event. (add/remove)");
-        self.assertEquals("x", e.getData().added[0], "Wrong items in the event. (add/remove)");
-        self.assertEquals(1, e.getData().added.length, "Wrong amount of items in the event. (add/remove)");
-        self.assertEquals("a", e.getData().removed[0], "Wrong items in the event. (add/remove)");
-        self.assertEquals(1, e.getData().removed.length, "Wrong amount of items in the event. (add/remove)");
-      }, "Change event not fired!");
+      this.assertEventFired(
+        a,
+        "change",
+        function () {
+          a.splice(0, 1, "x").dispose();
+        },
+        function (e) {
+          self.assertEquals(
+            0,
+            e.getData().start,
+            "Wrong start index in the event. (add/remove)"
+          );
+
+          self.assertEquals(
+            0,
+            e.getData().end,
+            "Wrong end index in the event. (add/remove)"
+          );
+
+          self.assertEquals(
+            "add/remove",
+            e.getData().type,
+            "Wrong type in the event. (add/remove)"
+          );
+
+          self.assertEquals(
+            "x",
+            e.getData().added[0],
+            "Wrong items in the event. (add/remove)"
+          );
+
+          self.assertEquals(
+            1,
+            e.getData().added.length,
+            "Wrong amount of items in the event. (add/remove)"
+          );
+
+          self.assertEquals(
+            "a",
+            e.getData().removed[0],
+            "Wrong items in the event. (add/remove)"
+          );
+
+          self.assertEquals(
+            1,
+            e.getData().removed.length,
+            "Wrong amount of items in the event. (add/remove)"
+          );
+        },
+        "Change event not fired!"
+      );
+
       a.dispose();
 
       // test for the event (add/remove) in replace
       a = new qx.data.Array("a", "b", "c");
-      this.assertEventFired(a, "change", function () {
-        a.splice(0, 3, "x", "y", "z").dispose();
-      }, function(e) {
-        self.assertEquals(0, e.getData().start, "Wrong start index in the event. (replace)");
-        self.assertEquals(2, e.getData().end, "Wrong end index in the event. (replace)");
-        self.assertEquals("add/remove", e.getData().type, "Wrong type in the event. (replace)");
-        self.assertEquals("x", e.getData().added[0], "Wrong items in the event. (replace)");
-        self.assertEquals("y", e.getData().added[1], "Wrong items in the event. (replace)");
-        self.assertEquals("z", e.getData().added[2], "Wrong items in the event. (replace)");
-        self.assertEquals(3, e.getData().added.length, "Wrong amount of items in the event. (replace)");
-        self.assertEquals("a", e.getData().removed[0], "Wrong items in the event. (replace)");
-        self.assertEquals("b", e.getData().removed[1], "Wrong items in the event. (replace)");
-        self.assertEquals("c", e.getData().removed[2], "Wrong items in the event. (replace)");
-        self.assertEquals(3, e.getData().removed.length, "Wrong amount of items in the event. (replace)");
-      }, "Change event not fired!");
-      a.dispose();
-    },
-
-    testSpliceBubbleEvent: function() {
+      this.assertEventFired(
+        a,
+        "change",
+        function () {
+          a.splice(0, 3, "x", "y", "z").dispose();
+        },
+        function (e) {
+          self.assertEquals(
+            0,
+            e.getData().start,
+            "Wrong start index in the event. (replace)"
+          );
+
+          self.assertEquals(
+            2,
+            e.getData().end,
+            "Wrong end index in the event. (replace)"
+          );
+
+          self.assertEquals(
+            "add/remove",
+            e.getData().type,
+            "Wrong type in the event. (replace)"
+          );
+
+          self.assertEquals(
+            "x",
+            e.getData().added[0],
+            "Wrong items in the event. (replace)"
+          );
+
+          self.assertEquals(
+            "y",
+            e.getData().added[1],
+            "Wrong items in the event. (replace)"
+          );
+
+          self.assertEquals(
+            "z",
+            e.getData().added[2],
+            "Wrong items in the event. (replace)"
+          );
+
+          self.assertEquals(
+            3,
+            e.getData().added.length,
+            "Wrong amount of items in the event. (replace)"
+          );
+
+          self.assertEquals(
+            "a",
+            e.getData().removed[0],
+            "Wrong items in the event. (replace)"
+          );
+
+          self.assertEquals(
+            "b",
+            e.getData().removed[1],
+            "Wrong items in the event. (replace)"
+          );
+
+          self.assertEquals(
+            "c",
+            e.getData().removed[2],
+            "Wrong items in the event. (replace)"
+          );
+
+          self.assertEquals(
+            3,
+            e.getData().removed.length,
+            "Wrong amount of items in the event. (replace)"
+          );
+        },
+        "Change event not fired!"
+      );
+
+      a.dispose();
+    },
+
+    testSpliceBubbleEvent() {
       // test for the event (remove)
       var a = new qx.data.Array("a", "b", "c", "d", "e");
       var self = this;
-      this.assertEventFired(a, "changeBubble", function () {
-        a.splice(1, 2).dispose();
-      }, function(e) {
-        var data = e.getData();
-        self.assertEquals(0, data.value.length, "Wrong amount of item(s) added in the bubble event (remove).");
-        self.assertEquals(2, data.old.length, "Wrong amount of item(s) removed in the bubble event (remove).");
-        self.assertEquals("1-2", data.name, "Wrong name in the bubble event (remove).");
-      }, "changeBubble event not fired!");
+      this.assertEventFired(
+        a,
+        "changeBubble",
+        function () {
+          a.splice(1, 2).dispose();
+        },
+        function (e) {
+          var data = e.getData();
+          self.assertEquals(
+            0,
+            data.value.length,
+            "Wrong amount of item(s) added in the bubble event (remove)."
+          );
+
+          self.assertEquals(
+            2,
+            data.old.length,
+            "Wrong amount of item(s) removed in the bubble event (remove)."
+          );
+
+          self.assertEquals(
+            "1-2",
+            data.name,
+            "Wrong name in the bubble event (remove)."
+          );
+        },
+        "changeBubble event not fired!"
+      );
+
       a.dispose();
 
       // test for the event (add)
       a = new qx.data.Array("a", "b", "c");
-      this.assertEventFired(a, "changeBubble", function () {
-        a.splice(0, 0, "x").dispose();
-      }, function(e) {
-        var data = e.getData();
-        self.assertEquals(1, data.value.length, "Wrong amount of item(s) added in the bubble event (add).");
-        self.assertEquals(0, data.old.length, "Wrong amount of item(s) removed in the bubble event (add).");
-        self.assertEquals("0", data.name, "Wrong name in the bubble event (add).");
-      }, "changeBubble event not fired!");
+      this.assertEventFired(
+        a,
+        "changeBubble",
+        function () {
+          a.splice(0, 0, "x").dispose();
+        },
+        function (e) {
+          var data = e.getData();
+          self.assertEquals(
+            1,
+            data.value.length,
+            "Wrong amount of item(s) added in the bubble event (add)."
+          );
+
+          self.assertEquals(
+            0,
+            data.old.length,
+            "Wrong amount of item(s) removed in the bubble event (add)."
+          );
+
+          self.assertEquals(
+            "0",
+            data.name,
+            "Wrong name in the bubble event (add)."
+          );
+        },
+        "changeBubble event not fired!"
+      );
+
       a.dispose();
 
       // test for the event (add/remove)
       a = new qx.data.Array("a", "b", "c");
-      this.assertEventFired(a, "changeBubble", function () {
-        a.splice(0, 1, "x").dispose();
-      }, function(e) {
-        var data = e.getData();
-        self.assertEquals(1, data.value.length, "Wrong amount of item(s) added in the bubble event (add/remove).");
-        self.assertEquals(1, data.old.length, "Wrong amount of item(s) removed in the bubble event (add/remove).");
-        self.assertEquals("0", data.name, "Wrong name in the bubble event (add/remove).");
-      }, "changeBubble event not fired!");
+      this.assertEventFired(
+        a,
+        "changeBubble",
+        function () {
+          a.splice(0, 1, "x").dispose();
+        },
+        function (e) {
+          var data = e.getData();
+          self.assertEquals(
+            1,
+            data.value.length,
+            "Wrong amount of item(s) added in the bubble event (add/remove)."
+          );
+
+          self.assertEquals(
+            1,
+            data.old.length,
+            "Wrong amount of item(s) removed in the bubble event (add/remove)."
+          );
+
+          self.assertEquals(
+            "0",
+            data.name,
+            "Wrong name in the bubble event (add/remove)."
+          );
+        },
+        "changeBubble event not fired!"
+      );
+
       a.dispose();
     },
 
-
-    testSpliceEventNoChange: function() {
+    testSpliceEventNoChange() {
       var a = new qx.data.Array(1, 2, 3);
-      this.assertEventNotFired(a, "change", function () {
-        a.splice(0, 0).dispose();
-      }, "Change event fired!");
+      this.assertEventNotFired(
+        a,
+        "change",
+        function () {
+          a.splice(0, 0).dispose();
+        },
+        "Change event fired!"
+      );
 
       a.dispose();
     },
 
-
-    testSpliceEventEqualContent: function() {
+    testSpliceEventEqualContent() {
       var a = new qx.data.Array(1, 2, 3);
-      this.assertEventNotFired(a, "change", function () {
-        a.splice(0, 2, 1, 2).dispose();
-      }, "Change event fired!");
+      this.assertEventNotFired(
+        a,
+        "change",
+        function () {
+          a.splice(0, 2, 1, 2).dispose();
+        },
+        "Change event fired!"
+      );
 
       a.dispose();
     },
 
-
-    testSpliceBubbleEventNoChange: function() {
+    testSpliceBubbleEventNoChange() {
       var a = new qx.data.Array(1, 2, 3);
-      this.assertEventNotFired(a, "changeBubble", function () {
-        a.splice(0, 0).dispose();
-      }, "Change bubble event fired!");
+      this.assertEventNotFired(
+        a,
+        "changeBubble",
+        function () {
+          a.splice(0, 0).dispose();
+        },
+        "Change bubble event fired!"
+      );
 
       a.dispose();
     },
 
-
-    testSpliceBubbleEventEqualContent: function() {
+    testSpliceBubbleEventEqualContent() {
       var a = new qx.data.Array(1, 2, 3);
-      this.assertEventNotFired(a, "changeBubble", function () {
-        a.splice(0, 2, 1, 2).dispose();
-      }, "Change bubble event fired!");
+      this.assertEventNotFired(
+        a,
+        "changeBubble",
+        function () {
+          a.splice(0, 2, 1, 2).dispose();
+        },
+        "Change bubble event fired!"
+      );
 
       a.dispose();
     },
 
-
-    testSetItemEvent: function() {
+    testSetItemEvent() {
       // test for the event
       var a = new qx.data.Array(1, 2, 3);
       var self = this;
 
-      this.assertEventFired(a, "change", function () {
-        a.setItem(0, 4);
-      }, function(e) {
-        self.assertEquals(0, e.getData().start, "Wrong start index in the event.");
-        self.assertEquals(0, e.getData().end, "Wrong end index in the event.");
-        self.assertEquals("add/remove", e.getData().type, "Wrong type in the event.");
-        self.assertEquals(4, e.getData().added[0], "Wrong item in the event.");
-        self.assertEquals(1, e.getData().added.length, "Wrong item in the event.");
-        self.assertEquals(1, e.getData().removed[0], "Wrong item in the event.");
-        self.assertEquals(1, e.getData().removed.length, "Wrong item in the event.");
-      }, "Change event not fired!");
+      this.assertEventFired(
+        a,
+        "change",
+        function () {
+          a.setItem(0, 4);
+        },
+        function (e) {
+          self.assertEquals(
+            0,
+            e.getData().start,
+            "Wrong start index in the event."
+          );
+
+          self.assertEquals(
+            0,
+            e.getData().end,
+            "Wrong end index in the event."
+          );
+
+          self.assertEquals(
+            "add/remove",
+            e.getData().type,
+            "Wrong type in the event."
+          );
+
+          self.assertEquals(
+            4,
+            e.getData().added[0],
+            "Wrong item in the event."
+          );
+
+          self.assertEquals(
+            1,
+            e.getData().added.length,
+            "Wrong item in the event."
+          );
+
+          self.assertEquals(
+            1,
+            e.getData().removed[0],
+            "Wrong item in the event."
+          );
+
+          self.assertEquals(
+            1,
+            e.getData().removed.length,
+            "Wrong item in the event."
+          );
+        },
+        "Change event not fired!"
+      );
 
       // set the same thing again and check if we get a second event
-      this.assertEventNotFired(a, "change", function () {
-        a.setItem(0, 4);
-      }, "Change event fired!");
+      this.assertEventNotFired(
+        a,
+        "change",
+        function () {
+          a.setItem(0, 4);
+        },
+        "Change event fired!"
+      );
+
       a.dispose();
     },
 
-
-    testForEach : function()
-    {
+    testForEach() {
       var self = this;
       var i = 0;
       var thisContext = {};
       var handlerCalled = false;
 
-      var forEachHandler = function(item, index, array) {
+      var forEachHandler = function (item, index, array) {
         handlerCalled = true;
         // check for the context
         self.assertEquals(this, thisContext);
@@ -766,8 +1419,7 @@ qx.Class.define("qx.test.data.DataArray",
       this.assertTrue(handlerCalled);
     },
 
-
-    testNotAutoDisposeItems : function() {
+    testNotAutoDisposeItems() {
       var o = new qx.core.Object();
       this.__a.push(o);
       this.__a.dispose();
@@ -775,8 +1427,7 @@ qx.Class.define("qx.test.data.DataArray",
       o.dispose();
     },
 
-
-    testAutoDisposeItems : function() {
+    testAutoDisposeItems() {
       var o = new qx.core.Object();
       this.__a.push(o);
       this.__a.setAutoDisposeItems(true);
@@ -784,10 +1435,9 @@ qx.Class.define("qx.test.data.DataArray",
       this.assertTrue(o.isDisposed());
     },
 
-
-    testFilter : function() {
+    testFilter() {
       var self = this;
-      var b = this.__a.filter(function(item, index, array) {
+      var b = this.__a.filter(function (item, index, array) {
         self.assertEquals(self, this);
         self.assertString(item);
         self.assertNumber(index);
@@ -802,10 +1452,9 @@ qx.Class.define("qx.test.data.DataArray",
       b.dispose();
     },
 
-
-    testMap : function() {
+    testMap() {
       var self = this;
-      var b = this.__a.map(function(item, index, array) {
+      var b = this.__a.map(function (item, index, array) {
         self.assertEquals(self, this);
         self.assertString(item);
         self.assertNumber(index);
@@ -821,64 +1470,80 @@ qx.Class.define("qx.test.data.DataArray",
       b.dispose();
     },
 
-
-    testSome : function() {
+    testSome() {
       var self = this;
-      this.assertTrue(this.__a.some(function(item, index, array) {
-        self.assertEquals(self, this);
-        self.assertString(item);
-        self.assertNumber(index);
-        self.assertEquals(self.__a.toArray(), array);
-        return item == "one";
-      }, this));
-
-      this.assertFalse(this.__a.some(function(item, index, array) {
-        return item == "xxx";
-      }, this));
+      this.assertTrue(
+        this.__a.some(function (item, index, array) {
+          self.assertEquals(self, this);
+          self.assertString(item);
+          self.assertNumber(index);
+          self.assertEquals(self.__a.toArray(), array);
+          return item == "one";
+        }, this)
+      );
+
+      this.assertFalse(
+        this.__a.some(function (item, index, array) {
+          return item == "xxx";
+        }, this)
+      );
     },
 
-
-    testEvery : function() {
+    testEvery() {
       var self = this;
-      this.assertTrue(this.__a.every(function(item, index, array) {
-        self.assertEquals(self, this);
-        self.assertString(item);
-        self.assertNumber(index);
-        self.assertEquals(self.__a.toArray(), array);
-        return ["one", "two", "three"].indexOf(item) >= 0;
-      }, this));
-
-      this.assertFalse(this.__a.every(function(item, index, array) {
-        return item == "one";
-      }, this));
+      this.assertTrue(
+        this.__a.every(function (item, index, array) {
+          self.assertEquals(self, this);
+          self.assertString(item);
+          self.assertNumber(index);
+          self.assertEquals(self.__a.toArray(), array);
+          return ["one", "two", "three"].indexOf(item) >= 0;
+        }, this)
+      );
+
+      this.assertFalse(
+        this.__a.every(function (item, index, array) {
+          return item == "one";
+        }, this)
+      );
     },
 
-
-    testReduce : function() {
+    testReduce() {
       var self = this;
-      var reduced = this.__a.reduce(function(previousValue, currentValue, index, array) {
+      var reduced = this.__a.reduce(function (
+        previousValue,
+        currentValue,
+        index,
+        array
+      ) {
         self.assertString(previousValue);
         self.assertString(currentValue);
         self.assertNumber(index);
         self.assertEquals(self.__a.toArray(), array);
         return previousValue + currentValue;
-      }, "---");
+      },
+      "---");
 
       this.assertEquals("---onetwothree", reduced);
     },
 
-
-    testReduceRight : function() {
+    testReduceRight() {
       var self = this;
-      var reduced = this.__a.reduceRight(function(previousValue, currentValue, index, array) {
+      var reduced = this.__a.reduceRight(function (
+        previousValue,
+        currentValue,
+        index,
+        array
+      ) {
         self.assertString(previousValue);
         self.assertString(currentValue);
         self.assertNumber(index);
         self.assertEquals(self.__a.toArray(), array);
         return previousValue + currentValue;
-      }, "---");
+      },
+      "---");
 
       this.assertEquals("---threetwoone", reduced);
     }
   }
-});
+});