Two spaces indentation for tests

tests/utils/decorator-tests.js

@@ -3,135 +3,135 @@ module("Decorators")
 var Utils = require("select2/utils");
 
 test("overridden - method", function (assert) {
-    function BaseClass () {};
+  function BaseClass () {};
 
-    BaseClass.prototype.hello = function () {
-        return "A";
-    }
+  BaseClass.prototype.hello = function () {
+    return "A";
+  }
 
-    function DecoratorClass () {};
+  function DecoratorClass () {};
 
-    DecoratorClass.prototype.hello = function () {
-        return "B";
-    }
+  DecoratorClass.prototype.hello = function () {
+    return "B";
+  }
 
-    var DecoratedClass = Utils.Decorate(BaseClass, DecoratorClass);
+  var DecoratedClass = Utils.Decorate(BaseClass, DecoratorClass);
 
-    var inst = new DecoratedClass();
+  var inst = new DecoratedClass();
 
-    assert.strictEqual(inst.hello(), "B");
+  assert.strictEqual(inst.hello(), "B");
 });
 
 test("overridden - constructor", function (assert) {
-    function BaseClass () {
-        this.inherited = true;
-    };
+  function BaseClass () {
+    this.inherited = true;
+  };
 
-    BaseClass.prototype.hello = function () {
-        return "A";
-    }
+  BaseClass.prototype.hello = function () {
+    return "A";
+  }
 
-    function DecoratorClass (decorated) {
-        this.called = true;
-    };
+  function DecoratorClass (decorated) {
+    this.called = true;
+  };
 
-    DecoratorClass.prototype.other = function () {
-        return "B";
-    }
+  DecoratorClass.prototype.other = function () {
+    return "B";
+  }
 
-    var DecoratedClass = Utils.Decorate(BaseClass, DecoratorClass);
+  var DecoratedClass = Utils.Decorate(BaseClass, DecoratorClass);
 
-    var inst = new DecoratedClass();
+  var inst = new DecoratedClass();
 
-    assert.ok(inst.called);
-    assert.ok(!inst.inherited);
+  assert.ok(inst.called);
+  assert.ok(!inst.inherited);
 });
 
 test("not overridden - method", function (assert) {
-    function BaseClass () {};
+  function BaseClass () {};
 
-    BaseClass.prototype.hello = function () {
-        return "A";
-    }
+  BaseClass.prototype.hello = function () {
+    return "A";
+  }
 
-    function DecoratorClass () {};
+  function DecoratorClass () {};
 
-    DecoratorClass.prototype.other = function () {
-        return "B";
-    }
+  DecoratorClass.prototype.other = function () {
+    return "B";
+  }
 
-    var DecoratedClass = Utils.Decorate(BaseClass, DecoratorClass);
+  var DecoratedClass = Utils.Decorate(BaseClass, DecoratorClass);
 
-    var inst = new DecoratedClass();
+  var inst = new DecoratedClass();
 
-    assert.strictEqual(inst.hello(), "A");
+  assert.strictEqual(inst.hello(), "A");
 });
 
 test("not overridden - constructor", function (assert) {
-    function BaseClass () {
-        this.called = true;
-    };
+  function BaseClass () {
+    this.called = true;
+  };
 
-    BaseClass.prototype.hello = function () {
-        return "A";
-    }
+  BaseClass.prototype.hello = function () {
+    return "A";
+  }
 
-    function DecoratorClass () {};
+  function DecoratorClass () {};
 
-    DecoratorClass.prototype.other = function () {
-        return "B";
-    }
+  DecoratorClass.prototype.other = function () {
+    return "B";
+  }
 
-    var DecoratedClass = Utils.Decorate(BaseClass, DecoratorClass);
+  var DecoratedClass = Utils.Decorate(BaseClass, DecoratorClass);
 
-    var inst = new DecoratedClass();
+  var inst = new DecoratedClass();
 
-    assert.ok(inst.called);
+  assert.ok(inst.called);
 });
 
 test("inherited - method", function (assert) {
-    function BaseClass () { };
+  function BaseClass () { };
 
-    BaseClass.prototype.hello = function () {
-        return "A";
-    }
+  BaseClass.prototype.hello = function () {
+    return "A";
+  }
 
-    function DecoratorClass (decorated) { };
+  function DecoratorClass (decorated) { };
 
-    DecoratorClass.prototype.hello = function (decorated) {
-        return "B" + decorated.call(this) + "C";
-    }
+  DecoratorClass.prototype.hello = function (decorated) {
+    return "B" + decorated.call(this) + "C";
+  }
 
-    var DecoratedClass = Utils.Decorate(BaseClass, DecoratorClass);
+  var DecoratedClass = Utils.Decorate(BaseClass, DecoratorClass);
 
-    var inst = new DecoratedClass();
+  var inst = new DecoratedClass();
 
-    assert.strictEqual(inst.hello(), "BAC");
+  assert.strictEqual(inst.hello(), "BAC");
 });
 
 test("inherited - constructor", function (assert) {
-    function BaseClass () {
-        this.inherited = true;
-    };
+  function BaseClass () {
+    this.inherited = true;
+  };
 
-    BaseClass.prototype.hello = function () {
-        return "A";
-    }
+  BaseClass.prototype.hello = function () {
+    return "A";
+  }
 
-    function DecoratorClass (decorated) {
-        this.called = true;
+  function DecoratorClass (decorated) {
+    this.called = true;
 
-        decorated.call(this);
-    };
+    decorated.call(this);
+  };
 
-    DecoratorClass.prototype.other = function () {
-        return "B";
-    }
+  DecoratorClass.prototype.other = function () {
+    return "B";
+  }
 
-    var DecoratedClass = Utils.Decorate(BaseClass, DecoratorClass);
+  var DecoratedClass = Utils.Decorate(BaseClass, DecoratorClass);
 
-    var inst = new DecoratedClass();
+  var inst = new DecoratedClass();
 
-    assert.ok(inst.called);
-    assert.ok(inst.inherited);
+  assert.ok(inst.called);
+  assert.ok(inst.inherited);
 });