jasmine-core 3.0.0 → 3.1.0

data/lib/jasmine-core/spec/core/UserContextSpec.js

@@ -1,54 +0,0 @@
-describe("UserContext", function() {
-  it("Behaves just like an plain object", function() {
-    var context = new jasmineUnderTest.UserContext(),
-        properties = [];
-
-    for (var prop in context) {
-      if (obj.hasOwnProperty(prop)) {
-        properties.push(prop);
-      }
-    }
-
-    expect(properties).toEqual([]);
-  });
-
-  describe('.fromExisting', function() {
-    describe('when using an already built context as model', function() {
-      beforeEach(function() {
-        this.context = new jasmineUnderTest.UserContext();
-        this.context.key = 'value';
-        this.cloned = jasmineUnderTest.UserContext.fromExisting(this.context);
-      });
-
-      it('returns a cloned object', function() {
-        expect(this.cloned).toEqual(this.context);
-      });
-
-      it('does not return the same object', function() {
-        expect(this.cloned).not.toBe(this.context);
-      });
-    });
-
-    describe('when using a regular object as parameter', function() {
-      beforeEach(function() {
-        this.context = {};
-        this.value = 'value'
-        this.context.key = this.value;
-        this.cloned = jasmineUnderTest.UserContext.fromExisting(this.context);
-      });
-
-      it('returns an object with the same attributes', function() {
-        expect(this.cloned.key).toEqual(this.value);
-      });
-
-      it('does not return the same object', function() {
-        expect(this.cloned).not.toBe(this.context);
-      });
-
-      it('returns an UserContext', function() {
-        expect(this.cloned.constructor).toBe(jasmineUnderTest.UserContext);
-      });
-    });
-  });
-});
-

data/lib/jasmine-core/spec/core/UtilSpec.js

@@ -1,105 +0,0 @@
-describe("jasmineUnderTest.util", function() {
-  describe("isArray_", function() {
-    it("should return true if the argument is an array", function() {
-      expect(jasmineUnderTest.isArray_([])).toBe(true);
-      expect(jasmineUnderTest.isArray_(['a'])).toBe(true);
-    });
-
-    it("should return false if the argument is not an array", function() {
-      expect(jasmineUnderTest.isArray_(undefined)).toBe(false);
-      expect(jasmineUnderTest.isArray_({})).toBe(false);
-      expect(jasmineUnderTest.isArray_(function() {})).toBe(false);
-      expect(jasmineUnderTest.isArray_('foo')).toBe(false);
-      expect(jasmineUnderTest.isArray_(5)).toBe(false);
-      expect(jasmineUnderTest.isArray_(null)).toBe(false);
-    });
-  });
-
-  describe("isObject_", function() {
-    it("should return true if the argument is an object", function() {
-      expect(jasmineUnderTest.isObject_({})).toBe(true);
-      expect(jasmineUnderTest.isObject_({an: "object"})).toBe(true);
-    });
-
-    it("should return false if the argument is not an object", function() {
-      expect(jasmineUnderTest.isObject_(undefined)).toBe(false);
-      expect(jasmineUnderTest.isObject_([])).toBe(false);
-      expect(jasmineUnderTest.isObject_(function() {})).toBe(false);
-      expect(jasmineUnderTest.isObject_('foo')).toBe(false);
-      expect(jasmineUnderTest.isObject_(5)).toBe(false);
-      expect(jasmineUnderTest.isObject_(null)).toBe(false);
-    });
-  });
-
-  describe("isUndefined", function() {
-    it("reports if a variable is defined", function() {
-      var a;
-      expect(jasmineUnderTest.util.isUndefined(a)).toBe(true);
-      expect(jasmineUnderTest.util.isUndefined(undefined)).toBe(true);
-
-      var undefined = "diz be undefined yo";
-      expect(jasmineUnderTest.util.isUndefined(undefined)).toBe(false);
-    });
-  });
-
-  describe("getPropertyDescriptor", function() {
-    it("get property descriptor from object", function() {
-      var obj = {prop: 1},
-        actual = jasmineUnderTest.util.getPropertyDescriptor(obj, 'prop'),
-        expected = Object.getOwnPropertyDescriptor(obj, 'prop');
-
-      expect(actual).toEqual(expected);
-    });
-
-    it("get property descriptor from object property", function() {
-      var proto = {prop: 1},
-        obj = Object.create(proto),
-        actual = jasmineUnderTest.util.getPropertyDescriptor(proto, 'prop'),
-        expected = Object.getOwnPropertyDescriptor(proto, 'prop');
-
-      expect(actual).toEqual(expected);
-    });
-  });
-
-  describe("objectDifference", function() {
-    it("given two objects A and B, returns the properties in A not present in B", function() {
-      var a = {
-        foo: 3,
-        bar: 4,
-        baz: 5
-      };
-
-      var b = {
-        bar: 6,
-        quux: 7
-      };
-
-      expect(jasmineUnderTest.util.objectDifference(a, b)).toEqual({foo: 3, baz: 5})
-    });
-
-    it("only looks at own properties of both objects", function() {
-      function Foo() {}
-
-      Foo.prototype.x = 1;
-      Foo.prototype.y = 2;
-
-      var a = new Foo();
-      a.x = 1;
-
-      var b = new Foo();
-      b.y = 2;
-
-      expect(jasmineUnderTest.util.objectDifference(a, b)).toEqual({x: 1});
-      expect(jasmineUnderTest.util.objectDifference(b, a)).toEqual({y: 2});
-    });
-  });
-
-  describe("jasmineFile", function() {
-    it("returns the file containing jasmine.util", function() {
-      // Chrome sometimes reports foo.js as foo.js/, so tolerate
-      // a trailing slash if present.
-      expect(jasmineUnderTest.util.jasmineFile()).toMatch(/util.js\/?$/);
-      expect(jasmine.util.jasmineFile()).toMatch(/jasmine.js\/?$/);
-    });
-  });
-});

data/lib/jasmine-core/spec/core/asymmetric_equality/AnySpec.js

@@ -1,91 +0,0 @@
-describe("Any", function() {
-  it("matches a string", function() {
-    var any = new jasmineUnderTest.Any(String);
-
-    expect(any.asymmetricMatch("foo")).toBe(true);
-  });
-
-  it("matches a number", function() {
-    var any = new jasmineUnderTest.Any(Number);
-
-    expect(any.asymmetricMatch(1)).toBe(true);
-  });
-
-  it("matches a function", function() {
-    var any = new jasmineUnderTest.Any(Function);
-
-    expect(any.asymmetricMatch(function(){})).toBe(true);
-  });
-
-  it("matches an Object", function() {
-    var any = new jasmineUnderTest.Any(Object);
-
-    expect(any.asymmetricMatch({})).toBe(true);
-  });
-
-  it("matches a Boolean", function() {
-    var any = new jasmineUnderTest.Any(Boolean);
-
-    expect(any.asymmetricMatch(true)).toBe(true);
-  });
-
-  it("matches a Map", function() {
-    jasmine.getEnv().requireFunctioningMaps();
-
-    var any = new jasmineUnderTest.Any(Map);
-
-    expect(any.asymmetricMatch(new Map())).toBe(true);
-  });
-
-  it("matches a Set", function() {
-    jasmine.getEnv().requireFunctioningSets();
-
-    var any = new jasmineUnderTest.Any(Set);
-
-    expect(any.asymmetricMatch(new Set())).toBe(true);
-  });
-
-  it("matches a TypedArray", function() {
-    jasmine.getEnv().requireFunctioningTypedArrays();
-
-    var any = new jasmineUnderTest.Any(Uint32Array);
-
-    expect(any.asymmetricMatch(new Uint32Array([]))).toBe(true);
-  });
-
-  it("matches a Symbol", function() {
-    jasmine.getEnv().requireFunctioningSymbols();
-
-    var any = new jasmineUnderTest.Any(Symbol);
-
-    expect(any.asymmetricMatch(Symbol())).toBe(true);
-  });
-
-  it("matches another constructed object", function() {
-    var Thing = function() {},
-      any = new jasmineUnderTest.Any(Thing);
-
-    expect(any.asymmetricMatch(new Thing())).toBe(true);
-  });
-
-  it("does not treat null as an Object", function() {
-    var any = new jasmineUnderTest.Any(Object);
-
-    expect(any.asymmetricMatch(null)).toBe(false);
-  });
-
-  it("jasmineToString's itself", function() {
-    var any = new jasmineUnderTest.Any(Number);
-
-    expect(any.jasmineToString()).toEqual('<jasmine.any(Number)>');
-    expect(any.jasmineToString()).toEqual('<jasmine.any(Number)>');
-  });
-
-  describe("when called without an argument", function() {
-    it("tells the user to pass a constructor or use jasmine.anything()", function() {
-      expect(function() {
-        new jasmineUnderTest.Any();
-      }).toThrowError(TypeError, /constructor.*anything/);
-    });
-  });
-});

data/lib/jasmine-core/spec/core/asymmetric_equality/AnythingSpec.js

@@ -1,76 +0,0 @@
-describe("Anything", function() {
-  it("matches a string", function() {
-    var anything = new jasmineUnderTest.Anything();
-
-    expect(anything.asymmetricMatch('foo')).toBe(true);
-  });
-
-  it("matches a number", function() {
-    var anything = new jasmineUnderTest.Anything();
-
-    expect(anything.asymmetricMatch(42)).toBe(true);
-  });
-
-  it("matches an object", function() {
-    var anything = new jasmineUnderTest.Anything();
-
-    expect(anything.asymmetricMatch({ foo: 'bar' })).toBe(true);
-  });
-
-  it("matches an array", function() {
-    var anything = new jasmineUnderTest.Anything();
-
-    expect(anything.asymmetricMatch([1,2,3])).toBe(true);
-  });
-
-  it("matches a Map", function() {
-    jasmine.getEnv().requireFunctioningMaps();
-
-    var anything = new jasmineUnderTest.Anything();
-
-    expect(anything.asymmetricMatch(new Map())).toBe(true);
-  });
-
-  it("matches a Set", function() {
-    jasmine.getEnv().requireFunctioningSets();
-
-    var anything = new jasmineUnderTest.Anything();
-
-    expect(anything.asymmetricMatch(new Set())).toBe(true);
-  });
-
-  it("matches a TypedArray", function() {
-    jasmine.getEnv().requireFunctioningTypedArrays();
-
-    var anything = new jasmineUnderTest.Anything();
-
-    expect(anything.asymmetricMatch(new Uint32Array([]))).toBe(true);
-  });
-
-  it("matches a Symbol", function() {
-    jasmine.getEnv().requireFunctioningSymbols();
-
-    var anything = new jasmineUnderTest.Anything();
-
-    expect(anything.asymmetricMatch(Symbol())).toBe(true);
-  });
-
-  it("doesn't match undefined", function() {
-    var anything = new jasmineUnderTest.Anything();
-
-    expect(anything.asymmetricMatch()).toBe(false);
-    expect(anything.asymmetricMatch(undefined)).toBe(false);
-  });
-
-  it("doesn't match null", function() {
-    var anything = new jasmineUnderTest.Anything();
-
-    expect(anything.asymmetricMatch(null)).toBe(false);
-  });
-
-  it("jasmineToString's itself", function() {
-    var anything = new jasmineUnderTest.Anything();
-
-    expect(anything.jasmineToString()).toEqual("<jasmine.anything>");
-  });
-});

data/lib/jasmine-core/spec/core/asymmetric_equality/ArrayContainingSpec.js

@@ -1,52 +0,0 @@
-describe("ArrayContaining", function() {
-  it("matches any actual to an empty array", function() {
-    var containing = new jasmineUnderTest.ArrayContaining([]);
-
-    expect(containing.asymmetricMatch("foo")).toBe(true);
-  });
-
-  it("does not work when not passed an array", function() {
-    var containing = new jasmineUnderTest.ArrayContaining("foo");
-
-    expect(function() {
-      containing.asymmetricMatch([]);
-    }).toThrowError(/not 'foo'/);
-  });
-
-  it("matches when the item is in the actual", function() {
-    var containing = new jasmineUnderTest.ArrayContaining(["foo"]);
-
-    expect(containing.asymmetricMatch(["foo"])).toBe(true);
-  });
-
-  it("matches when additional items are in the actual", function() {
-    var containing = new jasmineUnderTest.ArrayContaining(["foo"]);
-
-    expect(containing.asymmetricMatch(["foo", "bar"])).toBe(true);
-  });
-
-  it("does not match when the item is not in the actual", function() {
-    var containing = new jasmineUnderTest.ArrayContaining(["foo"]);
-
-    expect(containing.asymmetricMatch(["bar"])).toBe(false);
-  });
-
-  it("jasmineToStrings itself", function() {
-    var containing = new jasmineUnderTest.ArrayContaining([]);
-
-    expect(containing.jasmineToString()).toMatch("<jasmine.arrayContaining");
-  });
-
-  it("uses custom equality testers", function() {
-    var tester = function(a, b) {
-      // All "foo*" strings match each other.
-      if (typeof a == "string" && typeof b == "string" &&
-          a.substr(0, 3) == "foo" && b.substr(0, 3) == "foo") {
-        return true;
-      }
-    };
-    var containing = new jasmineUnderTest.ArrayContaining(["fooVal"]);
-
-    expect(containing.asymmetricMatch(["fooBar"], [tester])).toBe(true);
-  });
-});

data/lib/jasmine-core/spec/core/asymmetric_equality/ArrayWithExactContentsSpec.js

@@ -1,47 +0,0 @@
-describe("ArrayWithExactContents", function() {
-  it("matches an array with the same items in a different order", function() {
-    var matcher = new jasmineUnderTest.ArrayWithExactContents(['a', 2, /a/]);
-
-    expect(matcher.asymmetricMatch([2, 'a', /a/])).toBe(true);
-  });
-
-  it("does not work when not passed an array", function() {
-    var matcher = new jasmineUnderTest.ArrayWithExactContents("foo");
-
-    expect(function() {
-      matcher.asymmetricMatch([]);
-    }).toThrowError(/not 'foo'/);
-  });
-
-  it("does not match when an item is missing", function() {
-    var matcher = new jasmineUnderTest.ArrayWithExactContents(['a', 2, /a/]);
-
-    expect(matcher.asymmetricMatch(['a', 2])).toBe(false);
-    expect(matcher.asymmetricMatch(['a', 2, undefined])).toBe(false);
-  });
-
-  it("does not match when there is an extra item", function() {
-    var matcher = new jasmineUnderTest.ArrayWithExactContents(['a']);
-
-    expect(matcher.asymmetricMatch(['a', 2])).toBe(false);
-  });
-
-  it("jasmineToStrings itself", function() {
-    var matcher = new jasmineUnderTest.ArrayWithExactContents([]);
-
-    expect(matcher.jasmineToString()).toMatch("<jasmine.arrayWithExactContents");
-  });
-
-  it("uses custom equality testers", function() {
-    var tester = function(a, b) {
-      // All "foo*" strings match each other.
-      if (typeof a == "string" && typeof b == "string" &&
-          a.substr(0, 3) == "foo" && b.substr(0, 3) == "foo") {
-        return true;
-      }
-    };
-    var matcher = new jasmineUnderTest.ArrayWithExactContents(["fooVal"]);
-
-    expect(matcher.asymmetricMatch(["fooBar"], [tester])).toBe(true);
-  });
-});

data/lib/jasmine-core/spec/core/asymmetric_equality/ObjectContainingSpec.js

@@ -1,99 +0,0 @@
-describe("ObjectContaining", function() {
-
-  it("matches any actual to an empty object", function() {
-    var containing = new jasmineUnderTest.ObjectContaining({});
-
-    expect(containing.asymmetricMatch("foo")).toBe(true);
-  });
-
-  it("does not match an empty object actual", function() {
-    var containing = new jasmineUnderTest.ObjectContaining("foo");
-
-    expect(function() {
-      containing.asymmetricMatch({})
-    }).toThrowError(/not 'foo'/)
-  });
-
-  it("matches when the key/value pair is present in the actual", function() {
-    var containing = new jasmineUnderTest.ObjectContaining({foo: "fooVal"});
-
-    expect(containing.asymmetricMatch({foo: "fooVal", bar: "barVal"})).toBe(true);
-  });
-
-  it("does not match when the key/value pair is not present in the actual", function() {
-    var containing = new jasmineUnderTest.ObjectContaining({foo: "fooVal"});
-
-    expect(containing.asymmetricMatch({bar: "barVal", quux: "quuxVal"})).toBe(false);
-  });
-
-  it("does not match when the key is present but the value is different in the actual", function() {
-    var containing = new jasmineUnderTest.ObjectContaining({foo: "other"});
-
-    expect(containing.asymmetricMatch({foo: "fooVal", bar: "barVal"})).toBe(false);
-  });
-
-  it("jasmineToString's itself", function() {
-    var containing = new jasmineUnderTest.ObjectContaining({});
-
-    expect(containing.jasmineToString()).toMatch("<jasmine.objectContaining");
-  });
-
-  it("matches recursively", function() {
-    var containing = new jasmineUnderTest.ObjectContaining({one: new jasmineUnderTest.ObjectContaining({two: {}})});
-
-    expect(containing.asymmetricMatch({one: {two: {}}})).toBe(true);
-  });
-
-  it("matches when key is present with undefined value", function() {
-    var containing = new jasmineUnderTest.ObjectContaining({ one: undefined });
-
-    expect(containing.asymmetricMatch({ one: undefined })).toBe(true);
-  });
-
-  it("does not match when key with undefined value is not present", function() {
-    var containing = new jasmineUnderTest.ObjectContaining({ one: undefined });
-
-    expect(containing.asymmetricMatch({})).toBe(false);
-  });
-
-  it("matches defined properties", function(){
-    var containing = new jasmineUnderTest.ObjectContaining({ foo: "fooVal" });
-
-    var definedPropertyObject = {};
-    Object.defineProperty(definedPropertyObject, "foo", {
-      get: function() { return "fooVal" }
-    });
-    expect(containing.asymmetricMatch(definedPropertyObject)).toBe(true);
-  });
-
-  it("matches prototype properties", function(){
-    var containing = new jasmineUnderTest.ObjectContaining({ foo: "fooVal" });
-
-    var prototypeObject = {foo: "fooVal"};
-    var obj;
-
-    if (Object.create) {
-      obj = Object.create(prototypeObject);
-    } else {
-      function Foo() {}
-      Foo.prototype = prototypeObject;
-      Foo.prototype.constructor = Foo;
-      obj = new Foo();
-    }
-
-    expect(containing.asymmetricMatch(obj)).toBe(true);
-  });
-
-  it("uses custom equality testers", function() {
-    var tester = function(a, b) {
-      // All "foo*" strings match each other.
-      if (typeof a == "string" && typeof b == "string" &&
-          a.substr(0, 3) == "foo" && b.substr(0, 3) == "foo") {
-        return true;
-      }
-    };
-    var containing = new jasmineUnderTest.ObjectContaining({foo: "fooVal"});
-
-    expect(containing.asymmetricMatch({foo: "fooBar"}, [tester])).toBe(true);
-  });
-});