admin/jasmine
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Run Prettier on all files

Browse Source
This commit is contained in:
Steve Gravrock
2020-09-29 18:05:38 -07:00
parent 7d5ca27b9d
commit d27bb8fa96
108 changed files with 4399 additions and 2926 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
spec/core/asymmetric_equality/AnySpec.js
View File

@@ -1,35 +1,35 @@
describe("Any", function() {
it("matches a string", function() {
describe('Any', function() {
it('matches a string', function() {
var any = new jasmineUnderTest.Any(String);
expect(any.asymmetricMatch("foo")).toBe(true);
expect(any.asymmetricMatch('foo')).toBe(true);
});
it("matches a number", function() {
it('matches a number', function() {
var any = new jasmineUnderTest.Any(Number);
expect(any.asymmetricMatch(1)).toBe(true);
});
it("matches a function", function() {
it('matches a function', function() {
var any = new jasmineUnderTest.Any(Function);
expect(any.asymmetricMatch(function(){})).toBe(true);
expect(any.asymmetricMatch(function() {})).toBe(true);
});
it("matches an Object", function() {
it('matches an Object', function() {
var any = new jasmineUnderTest.Any(Object);
expect(any.asymmetricMatch({})).toBe(true);
});
it("matches a Boolean", function() {
it('matches a Boolean', function() {
var any = new jasmineUnderTest.Any(Boolean);
expect(any.asymmetricMatch(true)).toBe(true);
});
it("matches a Map", function() {
it('matches a Map', function() {
jasmine.getEnv().requireFunctioningMaps();
var any = new jasmineUnderTest.Any(Map);
@@ -37,7 +37,7 @@ describe("Any", function() {
expect(any.asymmetricMatch(new Map())).toBe(true); // eslint-disable-line compat/compat
});
it("matches a Set", function() {
it('matches a Set', function() {
jasmine.getEnv().requireFunctioningSets();
var any = new jasmineUnderTest.Any(Set);
@@ -45,7 +45,7 @@ describe("Any", function() {
expect(any.asymmetricMatch(new Set())).toBe(true); // eslint-disable-line compat/compat
});
it("matches a TypedArray", function() {
it('matches a TypedArray', function() {
jasmine.getEnv().requireFunctioningTypedArrays();
var any = new jasmineUnderTest.Any(Uint32Array); // eslint-disable-line compat/compat
@@ -53,7 +53,7 @@ describe("Any", function() {
expect(any.asymmetricMatch(new Uint32Array([]))).toBe(true); // eslint-disable-line compat/compat
});
it("matches a Symbol", function() {
it('matches a Symbol', function() {
jasmine.getEnv().requireFunctioningSymbols();
var any = new jasmineUnderTest.Any(Symbol); // eslint-disable-line compat/compat
@@ -61,14 +61,14 @@ describe("Any", function() {
expect(any.asymmetricMatch(Symbol())).toBe(true); // eslint-disable-line compat/compat
});
it("matches another constructed object", function() {
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() {
it('does not treat null as an Object', function() {
var any = new jasmineUnderTest.Any(Object);
expect(any.asymmetricMatch(null)).toBe(false);
@@ -81,8 +81,8 @@ describe("Any", function() {
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() {
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/);

22
spec/core/asymmetric_equality/AnythingSpec.js
View File

@@ -1,29 +1,29 @@
describe("Anything", function() {
it("matches a string", function() {
describe('Anything', function() {
it('matches a string', function() {
var anything = new jasmineUnderTest.Anything();
expect(anything.asymmetricMatch('foo')).toBe(true);
});
it("matches a number", function() {
it('matches a number', function() {
var anything = new jasmineUnderTest.Anything();
expect(anything.asymmetricMatch(42)).toBe(true);
});
it("matches an object", function() {
it('matches an object', function() {
var anything = new jasmineUnderTest.Anything();
expect(anything.asymmetricMatch({ foo: 'bar' })).toBe(true);
});
it("matches an array", function() {
it('matches an array', function() {
var anything = new jasmineUnderTest.Anything();
expect(anything.asymmetricMatch([1,2,3])).toBe(true);
expect(anything.asymmetricMatch([1, 2, 3])).toBe(true);
});
it("matches a Map", function() {
it('matches a Map', function() {
jasmine.getEnv().requireFunctioningMaps();
var anything = new jasmineUnderTest.Anything();
@@ -31,7 +31,7 @@ describe("Anything", function() {
expect(anything.asymmetricMatch(new Map())).toBe(true); // eslint-disable-line compat/compat
});
it("matches a Set", function() {
it('matches a Set', function() {
jasmine.getEnv().requireFunctioningSets();
var anything = new jasmineUnderTest.Anything();
@@ -39,7 +39,7 @@ describe("Anything", function() {
expect(anything.asymmetricMatch(new Set())).toBe(true); // eslint-disable-line compat/compat
});
it("matches a TypedArray", function() {
it('matches a TypedArray', function() {
jasmine.getEnv().requireFunctioningTypedArrays();
var anything = new jasmineUnderTest.Anything();
@@ -47,7 +47,7 @@ describe("Anything", function() {
expect(anything.asymmetricMatch(new Uint32Array([]))).toBe(true); // eslint-disable-line compat/compat
});
it("matches a Symbol", function() {
it('matches a Symbol', function() {
jasmine.getEnv().requireFunctioningSymbols();
var anything = new jasmineUnderTest.Anything();
@@ -71,6 +71,6 @@ describe("Anything", function() {
it("jasmineToString's itself", function() {
var anything = new jasmineUnderTest.Anything();
expect(anything.jasmineToString()).toEqual("<jasmine.anything>");
expect(anything.jasmineToString()).toEqual('<jasmine.anything>');
});
});

54
spec/core/asymmetric_equality/ArrayContainingSpec.js
View File

@@ -1,47 +1,47 @@
describe("ArrayContaining", function() {
it("matches any actual to an empty array", function() {
describe('ArrayContaining', function() {
it('matches any actual to an empty array', function() {
var containing = new jasmineUnderTest.ArrayContaining([]);
expect(containing.asymmetricMatch("foo")).toBe(true);
expect(containing.asymmetricMatch('foo')).toBe(true);
});
it("does not work when not passed an array", function() {
var containing = new jasmineUnderTest.ArrayContaining("foo");
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"]);
it('matches when the item is in the actual', function() {
var containing = new jasmineUnderTest.ArrayContaining(['foo']);
var matchersUtil = new jasmineUnderTest.MatchersUtil();
expect(containing.asymmetricMatch(["foo"], matchersUtil)).toBe(true);
expect(containing.asymmetricMatch(['foo'], matchersUtil)).toBe(true);
});
it("matches when additional items are in the actual", function() {
var containing = new jasmineUnderTest.ArrayContaining(["foo"]);
it('matches when additional items are in the actual', function() {
var containing = new jasmineUnderTest.ArrayContaining(['foo']);
var matchersUtil = new jasmineUnderTest.MatchersUtil();
expect(containing.asymmetricMatch(["foo", "bar"], matchersUtil)).toBe(true);
expect(containing.asymmetricMatch(['foo', 'bar'], matchersUtil)).toBe(true);
});
it("does not match when the item is not in the actual", function() {
var containing = new jasmineUnderTest.ArrayContaining(["foo"]);
it('does not match when the item is not in the actual', function() {
var containing = new jasmineUnderTest.ArrayContaining(['foo']);
var matchersUtil = new jasmineUnderTest.MatchersUtil();
expect(containing.asymmetricMatch(["bar"], matchersUtil)).toBe(false);
expect(containing.asymmetricMatch(['bar'], matchersUtil)).toBe(false);
});
it("does not match when the actual is not an array", function() {
var containing = new jasmineUnderTest.ArrayContaining(["foo"]);
it('does not match when the actual is not an array', function() {
var containing = new jasmineUnderTest.ArrayContaining(['foo']);
var matchersUtil = new jasmineUnderTest.MatchersUtil();
expect(containing.asymmetricMatch("foo", matchersUtil)).toBe(false);
expect(containing.asymmetricMatch('foo', matchersUtil)).toBe(false);
});
it("jasmineToStrings itself", function() {
it('jasmineToStrings itself', function() {
var sample = [],
matcher = new jasmineUnderTest.ArrayContaining(sample),
pp = jasmine.createSpy('pp').and.returnValue('sample');
@@ -52,17 +52,23 @@ describe("ArrayContaining", function() {
expect(pp).toHaveBeenCalledWith(sample);
});
it("uses custom equality testers", function() {
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") {
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"]);
var matchersUtil = new jasmineUnderTest.MatchersUtil({customTesters: [tester]});
var containing = new jasmineUnderTest.ArrayContaining(['fooVal']);
var matchersUtil = new jasmineUnderTest.MatchersUtil({
customTesters: [tester]
});
expect(containing.asymmetricMatch(["fooBar"], matchersUtil)).toBe(true);
expect(containing.asymmetricMatch(['fooBar'], matchersUtil)).toBe(true);
});
});

36
spec/core/asymmetric_equality/ArrayWithExactContentsSpec.js
View File

@@ -1,35 +1,37 @@
describe("ArrayWithExactContents", function() {
it("matches an array with the same items in a different order", function() {
describe('ArrayWithExactContents', function() {
it('matches an array with the same items in a different order', function() {
var matcher = new jasmineUnderTest.ArrayWithExactContents(['a', 2, /a/]);
var matchersUtil = new jasmineUnderTest.MatchersUtil();
expect(matcher.asymmetricMatch([2, 'a', /a/], matchersUtil)).toBe(true);
});
it("does not work when not passed an array", function() {
var matcher = new jasmineUnderTest.ArrayWithExactContents("foo");
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() {
it('does not match when an item is missing', function() {
var matcher = new jasmineUnderTest.ArrayWithExactContents(['a', 2, /a/]);
var matchersUtil = new jasmineUnderTest.MatchersUtil();
expect(matcher.asymmetricMatch(['a', 2], matchersUtil)).toBe(false);
expect(matcher.asymmetricMatch(['a', 2, undefined], matchersUtil)).toBe(false);
expect(matcher.asymmetricMatch(['a', 2, undefined], matchersUtil)).toBe(
false
);
});
it("does not match when there is an extra item", function() {
it('does not match when there is an extra item', function() {
var matcher = new jasmineUnderTest.ArrayWithExactContents(['a']);
var matchersUtil = new jasmineUnderTest.MatchersUtil();
expect(matcher.asymmetricMatch(['a', 2], matchersUtil)).toBe(false);
});
it("jasmineToStrings itself", function() {
it('jasmineToStrings itself', function() {
var sample = [],
matcher = new jasmineUnderTest.ArrayWithExactContents(sample),
pp = jasmine.createSpy('pp').and.returnValue('sample');
@@ -40,17 +42,23 @@ describe("ArrayWithExactContents", function() {
expect(pp).toHaveBeenCalledWith(sample);
});
it("uses custom equality testers", function() {
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") {
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"]);
var matchersUtil = new jasmineUnderTest.MatchersUtil({customTesters: [tester]});
var matcher = new jasmineUnderTest.ArrayWithExactContents(['fooVal']);
var matchersUtil = new jasmineUnderTest.MatchersUtil({
customTesters: [tester]
});
expect(matcher.asymmetricMatch(["fooBar"], matchersUtil)).toBe(true);
expect(matcher.asymmetricMatch(['fooBar'], matchersUtil)).toBe(true);
});
});

20
spec/core/asymmetric_equality/EmptySpec.js
View File

@@ -1,27 +1,27 @@
describe("Empty", function () {
it("matches an empty object", function () {
describe('Empty', function() {
it('matches an empty object', function() {
var empty = new jasmineUnderTest.Empty();
expect(empty.asymmetricMatch({})).toBe(true);
expect(empty.asymmetricMatch({undefined: false})).toBe(false);
expect(empty.asymmetricMatch({ undefined: false })).toBe(false);
});
it("matches an empty array", function () {
it('matches an empty array', function() {
var empty = new jasmineUnderTest.Empty();
expect(empty.asymmetricMatch([])).toBe(true);
expect(empty.asymmetricMatch([1, 12, 3])).toBe(false);
});
it("matches an empty string", function () {
it('matches an empty string', function() {
var empty = new jasmineUnderTest.Empty();
expect(empty.asymmetricMatch("")).toBe(true);
expect(empty.asymmetricMatch('')).toBe(true);
expect(empty.asymmetricMatch('')).toBe(true);
expect(empty.asymmetricMatch('12312')).toBe(false);
});
it("matches an empty map", function () {
it('matches an empty map', function() {
jasmine.getEnv().requireFunctioningMaps();
var empty = new jasmineUnderTest.Empty();
var fullMap = new Map(); // eslint-disable-line compat/compat
@@ -31,7 +31,7 @@ describe("Empty", function () {
expect(empty.asymmetricMatch(fullMap)).toBe(false);
});
it("matches an empty set", function () {
it('matches an empty set', function() {
jasmine.getEnv().requireFunctioningSets();
var empty = new jasmineUnderTest.Empty();
var fullSet = new Set(); // eslint-disable-line compat/compat
@@ -41,11 +41,11 @@ describe("Empty", function () {
expect(empty.asymmetricMatch(fullSet)).toBe(false);
});
it("matches an empty typed array", function() {
it('matches an empty typed array', function() {
jasmine.getEnv().requireFunctioningTypedArrays();
var empty = new jasmineUnderTest.Empty();
expect(empty.asymmetricMatch(new Int16Array())).toBe(true); // eslint-disable-line compat/compat
expect(empty.asymmetricMatch(new Int16Array([1,2]))).toBe(false); // eslint-disable-line compat/compat
expect(empty.asymmetricMatch(new Int16Array([1, 2]))).toBe(false); // eslint-disable-line compat/compat
});
});

56
spec/core/asymmetric_equality/FalsySpec.js
View File

@@ -1,38 +1,38 @@
describe("Falsy", function() {
it("is true for an empty string", function() {
var falsy = new jasmineUnderTest.Falsy();
describe('Falsy', function() {
it('is true for an empty string', function() {
var falsy = new jasmineUnderTest.Falsy();
expect(falsy.asymmetricMatch("")).toBe(true);
expect(falsy.asymmetricMatch('')).toBe(true);
expect(falsy.asymmetricMatch('asdasdad')).toBe(false);
});
expect(falsy.asymmetricMatch('')).toBe(true);
expect(falsy.asymmetricMatch('')).toBe(true);
expect(falsy.asymmetricMatch('asdasdad')).toBe(false);
});
it("is false for a number that is 0", function() {
var falsy = new jasmineUnderTest.Falsy(Number);
it('is false for a number that is 0', function() {
var falsy = new jasmineUnderTest.Falsy(Number);
expect(falsy.asymmetricMatch(1)).toBe(false);
expect(falsy.asymmetricMatch(0)).toBe(true);
expect(falsy.asymmetricMatch(-23)).toBe(false);
expect(falsy.asymmetricMatch(-3.1)).toBe(false);
});
expect(falsy.asymmetricMatch(1)).toBe(false);
expect(falsy.asymmetricMatch(0)).toBe(true);
expect(falsy.asymmetricMatch(-23)).toBe(false);
expect(falsy.asymmetricMatch(-3.1)).toBe(false);
});
it("is true for a null or undefined", function() {
var falsy = new jasmineUnderTest.Falsy(Function);
it('is true for a null or undefined', function() {
var falsy = new jasmineUnderTest.Falsy(Function);
expect(falsy.asymmetricMatch(null)).toBe(true);
expect(falsy.asymmetricMatch(undefined )).toBe(true);
});
expect(falsy.asymmetricMatch(null)).toBe(true);
expect(falsy.asymmetricMatch(undefined)).toBe(true);
});
it("is true for NaN", function() {
var falsy = new jasmineUnderTest.Falsy(Object);
it('is true for NaN', function() {
var falsy = new jasmineUnderTest.Falsy(Object);
expect(falsy.asymmetricMatch(NaN)).toBe(true);
});
expect(falsy.asymmetricMatch(NaN)).toBe(true);
});
it("is true for a false Boolean", function() {
var falsy = new jasmineUnderTest.Falsy(Boolean);
it('is true for a false Boolean', function() {
var falsy = new jasmineUnderTest.Falsy(Boolean);
expect(falsy.asymmetricMatch(false)).toBe(true);
expect(falsy.asymmetricMatch(true)).toBe(false);
});
expect(falsy.asymmetricMatch(false)).toBe(true);
expect(falsy.asymmetricMatch(true)).toBe(false);
});
});

114
spec/core/asymmetric_equality/MapContainingSpec.js
View File

@@ -1,6 +1,7 @@
/* eslint-disable compat/compat */
describe('MapContaining', function() {
function MapI(iterable) { // for IE11
function MapI(iterable) {
// for IE11
var map = new Map();
iterable.forEach(function(kv) {
map.set(kv[0], kv[1]);
@@ -12,7 +13,6 @@ describe('MapContaining', function() {
jasmine.getEnv().requireFunctioningMaps();
});
it('matches any actual map to an empty map', function() {
var actualMap = new MapI([['foo', 'bar']]);
var containing = new jasmineUnderTest.MapContaining(new Map());
@@ -23,14 +23,11 @@ describe('MapContaining', function() {
it('matches when all the key/value pairs in sample have matches in actual', function() {
var actualMap = new MapI([
['foo', [1, 2, 3]],
[{'foo': 'bar'}, 'baz'],
['other', 'any'],
[{ foo: 'bar' }, 'baz'],
['other', 'any']
]);
var containingMap = new MapI([
[{'foo': 'bar'}, 'baz'],
['foo', [1, 2, 3]],
]);
var containingMap = new MapI([[{ foo: 'bar' }, 'baz'], ['foo', [1, 2, 3]]]);
var containing = new jasmineUnderTest.MapContaining(containingMap);
var matchersUtil = new jasmineUnderTest.MatchersUtil();
@@ -40,13 +37,10 @@ describe('MapContaining', function() {
it('does not match when a key is not in actual', function() {
var actualMap = new MapI([
['foo', [1, 2, 3]],
[{'foo': 'not a bar'}, 'baz'],
[{ foo: 'not a bar' }, 'baz']
]);
var containingMap = new MapI([
[{'foo': 'bar'}, 'baz'],
['foo', [1, 2, 3]],
]);
var containingMap = new MapI([[{ foo: 'bar' }, 'baz'], ['foo', [1, 2, 3]]]);
var containing = new jasmineUnderTest.MapContaining(containingMap);
var matchersUtil = new jasmineUnderTest.MatchersUtil();
@@ -54,15 +48,9 @@ describe('MapContaining', function() {
});
it('does not match when a value is not in actual', function() {
var actualMap = new MapI([
['foo', [1, 2, 3]],
[{'foo': 'bar'}, 'baz'],
]);
var actualMap = new MapI([['foo', [1, 2, 3]], [{ foo: 'bar' }, 'baz']]);
var containingMap = new MapI([
[{'foo': 'bar'}, 'baz'],
['foo', [1, 2]],
]);
var containingMap = new MapI([[{ foo: 'bar' }, 'baz'], ['foo', [1, 2]]]);
var containing = new jasmineUnderTest.MapContaining(containingMap);
var matchersUtil = new jasmineUnderTest.MatchersUtil();
@@ -73,18 +61,12 @@ describe('MapContaining', function() {
var actualMap = new MapI([
['foo1', 'not a bar'],
['foo2', 'bar'],
['baz', [1, 2, 3, 4]],
['baz', [1, 2, 3, 4]]
]);
var containingMap = new MapI([
[
jasmineUnderTest.stringMatching(/^foo\d/),
'bar'
],
[
'baz',
jasmineUnderTest.arrayContaining([2, 3])
],
[jasmineUnderTest.stringMatching(/^foo\d/), 'bar'],
['baz', jasmineUnderTest.arrayContaining([2, 3])]
]);
var containing = new jasmineUnderTest.MapContaining(containingMap);
var matchersUtil = new jasmineUnderTest.MatchersUtil();
@@ -93,20 +75,11 @@ describe('MapContaining', function() {
});
it('does not match when a key in sample has no asymmetric matches in actual', function() {
var actualMap = new MapI([
['a-foo1', 'bar'],
['baz', [1, 2, 3, 4]],
]);
var actualMap = new MapI([['a-foo1', 'bar'], ['baz', [1, 2, 3, 4]]]);
var containingMap = new MapI([
[
jasmineUnderTest.stringMatching(/^foo\d/),
'bar'
],
[
'baz',
jasmineUnderTest.arrayContaining([2, 3])
],
[jasmineUnderTest.stringMatching(/^foo\d/), 'bar'],
['baz', jasmineUnderTest.arrayContaining([2, 3])]
]);
var containing = new jasmineUnderTest.MapContaining(containingMap);
var matchersUtil = new jasmineUnderTest.MatchersUtil();
@@ -115,20 +88,11 @@ describe('MapContaining', function() {
});
it('does not match when a value in sample has no asymmetric matches in actual', function() {
var actualMap = new MapI([
['foo1', 'bar'],
['baz', [1, 2, 3, 4]],
]);
var actualMap = new MapI([['foo1', 'bar'], ['baz', [1, 2, 3, 4]]]);
var containingMap = new MapI([
[
jasmineUnderTest.stringMatching(/^foo\d/),
'bar'
],
[
'baz',
jasmineUnderTest.arrayContaining([4, 5])
],
[jasmineUnderTest.stringMatching(/^foo\d/), 'bar'],
['baz', jasmineUnderTest.arrayContaining([4, 5])]
]);
var containing = new jasmineUnderTest.MapContaining(containingMap);
var matchersUtil = new jasmineUnderTest.MatchersUtil();
@@ -140,18 +104,12 @@ describe('MapContaining', function() {
var actualMap = new MapI([
['foo', new MapI([['foo1', 1], ['foo2', 2]])],
[new MapI([[1, 'bar1'], [2, 'bar2']]), 'bar'],
['other', 'any'],
['other', 'any']
]);
var containingMap = new MapI([
[
'foo',
new jasmineUnderTest.MapContaining(new MapI([['foo1', 1]]))
],
[
new jasmineUnderTest.MapContaining(new MapI([[2, 'bar2']])),
'bar'
],
['foo', new jasmineUnderTest.MapContaining(new MapI([['foo1', 1]]))],
[new jasmineUnderTest.MapContaining(new MapI([[2, 'bar2']])), 'bar']
]);
var containing = new jasmineUnderTest.MapContaining(containingMap);
var matchersUtil = new jasmineUnderTest.MatchersUtil();
@@ -162,25 +120,41 @@ describe('MapContaining', function() {
it('uses custom equality testers', function() {
function tester(a, b) {
// treat all negative numbers as equal
return (typeof a == 'number' && typeof b == 'number') ? (a < 0 && b < 0) : a === b;
return typeof a == 'number' && typeof b == 'number'
? a < 0 && b < 0
: a === b;
}
var actualMap = new MapI([['foo', -1]]);
var containing = new jasmineUnderTest.MapContaining(new MapI([['foo', -2]]));
var matchersUtil = new jasmineUnderTest.MatchersUtil({customTesters: [tester]});
var containing = new jasmineUnderTest.MapContaining(
new MapI([['foo', -2]])
);
var matchersUtil = new jasmineUnderTest.MatchersUtil({
customTesters: [tester]
});
expect(containing.asymmetricMatch(actualMap, matchersUtil)).toBe(true);
});
it('does not match when actual is not a map', function() {
var containingMap = new MapI([['foo', 'bar']]);
expect(new jasmineUnderTest.MapContaining(containingMap).asymmetricMatch('foo')).toBe(false);
expect(new jasmineUnderTest.MapContaining(containingMap).asymmetricMatch(-1)).toBe(false);
expect(new jasmineUnderTest.MapContaining(containingMap).asymmetricMatch({'foo': 'bar'})).toBe(false);
expect(
new jasmineUnderTest.MapContaining(containingMap).asymmetricMatch('foo')
).toBe(false);
expect(
new jasmineUnderTest.MapContaining(containingMap).asymmetricMatch(-1)
).toBe(false);
expect(
new jasmineUnderTest.MapContaining(containingMap).asymmetricMatch({
foo: 'bar'
})
).toBe(false);
});
it('throws an error when sample is not a map', function() {
expect(function() {
new jasmineUnderTest.MapContaining({'foo': 'bar'}).asymmetricMatch(new Map());
new jasmineUnderTest.MapContaining({ foo: 'bar' }).asymmetricMatch(
new Map()
);
}).toThrowError(/You must provide a map/);
});

20
spec/core/asymmetric_equality/NotEmptySpec.js
View File

@@ -1,27 +1,27 @@
describe("NotEmpty", function () {
it("matches a non empty object", function () {
describe('NotEmpty', function() {
it('matches a non empty object', function() {
var notEmpty = new jasmineUnderTest.NotEmpty();
expect(notEmpty.asymmetricMatch({undefined: false})).toBe(true);
expect(notEmpty.asymmetricMatch({ undefined: false })).toBe(true);
expect(notEmpty.asymmetricMatch({})).toBe(false);
});
it("matches a non empty array", function () {
it('matches a non empty array', function() {
var notEmpty = new jasmineUnderTest.NotEmpty();
expect(notEmpty.asymmetricMatch([1, 12, 3])).toBe(true);
expect(notEmpty.asymmetricMatch([])).toBe(false);
});
it("matches a non empty string", function () {
it('matches a non empty string', function() {
var notEmpty = new jasmineUnderTest.NotEmpty();
expect(notEmpty.asymmetricMatch('12312')).toBe(true);
expect(notEmpty.asymmetricMatch("")).toBe(false);
expect(notEmpty.asymmetricMatch('')).toBe(false);
expect(notEmpty.asymmetricMatch('')).toBe(false);
});
it("matches a non empty map", function () {
it('matches a non empty map', function() {
jasmine.getEnv().requireFunctioningMaps();
var notEmpty = new jasmineUnderTest.NotEmpty();
var fullMap = new Map(); // eslint-disable-line compat/compat
@@ -32,7 +32,7 @@ describe("NotEmpty", function () {
expect(notEmpty.asymmetricMatch(emptyMap)).toBe(false);
});
it("matches a non empty set", function () {
it('matches a non empty set', function() {
jasmine.getEnv().requireFunctioningSets();
var notEmpty = new jasmineUnderTest.NotEmpty();
var filledSet = new Set(); // eslint-disable-line compat/compat
@@ -43,11 +43,11 @@ describe("NotEmpty", function () {
expect(notEmpty.asymmetricMatch(emptySet)).toBe(false);
});
it("matches a non empty typed array", function() {
it('matches a non empty typed array', function() {
jasmine.getEnv().requireFunctioningTypedArrays();
var notEmpty = new jasmineUnderTest.NotEmpty();
expect(notEmpty.asymmetricMatch(new Int16Array([1,2,3]))).toBe(true); // eslint-disable-line compat/compat
expect(notEmpty.asymmetricMatch(new Int16Array([1, 2, 3]))).toBe(true); // eslint-disable-line compat/compat
expect(notEmpty.asymmetricMatch(new Int16Array())).toBe(false); // eslint-disable-line compat/compat
});
});

143
spec/core/asymmetric_equality/ObjectContainingSpec.js
View File

@@ -1,47 +1,55 @@
describe("ObjectContaining", function() {
it("matches any object actual to an empty object", function() {
describe('ObjectContaining', function() {
it('matches any object actual to an empty object', function() {
var containing = new jasmineUnderTest.ObjectContaining({});
var matchersUtil = new jasmineUnderTest.MatchersUtil();
expect(containing.asymmetricMatch({foo: 1}, matchersUtil)).toBe(true);
expect(containing.asymmetricMatch({ foo: 1 }, matchersUtil)).toBe(true);
});
it("does not match when the actual is not an object", function() {
it('does not match when the actual is not an object', function() {
var containing = new jasmineUnderTest.ObjectContaining({});
[1, true, undefined, "a string"].forEach(function(actual) {
[1, true, undefined, 'a string'].forEach(function(actual) {
expect(containing.asymmetricMatch(actual)).toBe(false);
});
});
it("does not match an empty object actual", function() {
var containing = new jasmineUnderTest.ObjectContaining("foo");
it('does not match an empty object actual', function() {
var containing = new jasmineUnderTest.ObjectContaining('foo');
expect(function() {
containing.asymmetricMatch({})
}).toThrowError(/not 'foo'/)
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"});
it('matches when the key/value pair is present in the actual', function() {
var containing = new jasmineUnderTest.ObjectContaining({ foo: 'fooVal' });
var matchersUtil = new jasmineUnderTest.MatchersUtil();
expect(containing.asymmetricMatch({foo: "fooVal", bar: "barVal"}, matchersUtil)).toBe(true);
expect(
containing.asymmetricMatch({ foo: 'fooVal', bar: 'barVal' }, matchersUtil)
).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"});
it('does not match when the key/value pair is not present in the actual', function() {
var containing = new jasmineUnderTest.ObjectContaining({ foo: 'fooVal' });
var matchersUtil = new jasmineUnderTest.MatchersUtil();
expect(containing.asymmetricMatch({bar: "barVal", quux: "quuxVal"}, matchersUtil)).toBe(false);
expect(
containing.asymmetricMatch(
{ bar: 'barVal', quux: 'quuxVal' },
matchersUtil
)
).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"});
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' });
var matchersUtil = new jasmineUnderTest.MatchersUtil();
expect(containing.asymmetricMatch({foo: "fooVal", bar: "barVal"}, matchersUtil)).toBe(false);
expect(
containing.asymmetricMatch({ foo: 'fooVal', bar: 'barVal' }, matchersUtil)
).toBe(false);
});
it("jasmineToString's itself", function() {
@@ -53,46 +61,55 @@ describe("ObjectContaining", function() {
'<jasmine.objectContaining(sample)>'
);
expect(pp).toHaveBeenCalledWith(sample);
});
it("matches recursively", function() {
var containing = new jasmineUnderTest.ObjectContaining({one: new jasmineUnderTest.ObjectContaining({two: {}})});
it('matches recursively', function() {
var containing = new jasmineUnderTest.ObjectContaining({
one: new jasmineUnderTest.ObjectContaining({ two: {} })
});
var matchersUtil = new jasmineUnderTest.MatchersUtil();
expect(containing.asymmetricMatch({one: {two: {}}}, matchersUtil)).toBe(true);
expect(containing.asymmetricMatch({ one: { two: {} } }, matchersUtil)).toBe(
true
);
});
it("matches when key is present with undefined value", function() {
it('matches when key is present with undefined value', function() {
var containing = new jasmineUnderTest.ObjectContaining({ one: undefined });
var matchersUtil = new jasmineUnderTest.MatchersUtil();
expect(containing.asymmetricMatch({ one: undefined }, matchersUtil)).toBe(true);
expect(containing.asymmetricMatch({ one: undefined }, matchersUtil)).toBe(
true
);
});
it("does not match when key with undefined value is not present", function() {
it('does not match when key with undefined value is not present', function() {
var containing = new jasmineUnderTest.ObjectContaining({ one: undefined });
var matchersUtil = new jasmineUnderTest.MatchersUtil();
expect(containing.asymmetricMatch({}, matchersUtil)).toBe(false);
});
it("matches defined properties", function(){
var containing = new jasmineUnderTest.ObjectContaining({ foo: "fooVal" });
it('matches defined properties', function() {
var containing = new jasmineUnderTest.ObjectContaining({ foo: 'fooVal' });
var matchersUtil = new jasmineUnderTest.MatchersUtil();
var definedPropertyObject = {};
Object.defineProperty(definedPropertyObject, "foo", {
get: function() { return "fooVal" }
Object.defineProperty(definedPropertyObject, 'foo', {
get: function() {
return 'fooVal';
}
});
expect(containing.asymmetricMatch(definedPropertyObject, matchersUtil)).toBe(true);
expect(
containing.asymmetricMatch(definedPropertyObject, matchersUtil)
).toBe(true);
});
it("matches prototype properties", function(){
var containing = new jasmineUnderTest.ObjectContaining({ foo: "fooVal" });
it('matches prototype properties', function() {
var containing = new jasmineUnderTest.ObjectContaining({ foo: 'fooVal' });
var matchersUtil = new jasmineUnderTest.MatchersUtil();
var prototypeObject = {foo: "fooVal"};
var prototypeObject = { foo: 'fooVal' };
var obj;
if (Object.create) {
@@ -107,23 +124,31 @@ describe("ObjectContaining", function() {
expect(containing.asymmetricMatch(obj, matchersUtil)).toBe(true);
});
it("uses custom equality testers", function() {
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") {
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"});
var matchersUtil = new jasmineUnderTest.MatchersUtil({customTesters: [tester]});
var containing = new jasmineUnderTest.ObjectContaining({ foo: 'fooVal' });
var matchersUtil = new jasmineUnderTest.MatchersUtil({
customTesters: [tester]
});
expect(containing.asymmetricMatch({foo: "fooBar"}, matchersUtil)).toBe(true);
expect(containing.asymmetricMatch({ foo: 'fooBar' }, matchersUtil)).toBe(
true
);
});
describe("valuesForDiff_", function() {
describe("when other is not an object", function() {
it("sets self to jasmineToString()", function () {
describe('valuesForDiff_', function() {
describe('when other is not an object', function() {
it('sets self to jasmineToString()', function() {
var containing = new jasmineUnderTest.ObjectContaining({}),
pp = jasmineUnderTest.makePrettyPrinter(),
result = containing.valuesForDiff_('a', pp);
@@ -135,27 +160,31 @@ describe("ObjectContaining", function() {
});
});
describe("when other is an object", function() {
it("includes keys that are present in both other and sample", function() {
var sample = {a: 1, b: 2},
other = {a: 3, b: 4},
describe('when other is an object', function() {
it('includes keys that are present in both other and sample', function() {
var sample = { a: 1, b: 2 },
other = { a: 3, b: 4 },
containing = new jasmineUnderTest.ObjectContaining(sample),
result = containing.valuesForDiff_(other);
expect(result.self).not.toBeInstanceOf(jasmineUnderTest.ObjectContaining);
expect(result.self).not.toBeInstanceOf(
jasmineUnderTest.ObjectContaining
);
expect(result).toEqual({
self: sample,
other: other
});
});
it("includes keys that are present only in sample", function() {
var sample = {a: 1, b: 2},
other = {a: 3},
it('includes keys that are present only in sample', function() {
var sample = { a: 1, b: 2 },
other = { a: 3 },
containing = new jasmineUnderTest.ObjectContaining(sample),
result = containing.valuesForDiff_(other);
expect(result.self).not.toBeInstanceOf(jasmineUnderTest.ObjectContaining);
expect(result.self).not.toBeInstanceOf(
jasmineUnderTest.ObjectContaining
);
expect(containing.valuesForDiff_(other)).toEqual({
self: sample,
other: {
@@ -165,13 +194,15 @@ describe("ObjectContaining", function() {
});
});
it("omits keys that are present only in other", function() {
var sample = {a: 1, b: 2},
other = {a: 3, b: 4, c: 5},
it('omits keys that are present only in other', function() {
var sample = { a: 1, b: 2 },
other = { a: 3, b: 4, c: 5 },
containing = new jasmineUnderTest.ObjectContaining(sample),
result = containing.valuesForDiff_(other);
expect(result.self).not.toBeInstanceOf(jasmineUnderTest.ObjectContaining);
expect(result.self).not.toBeInstanceOf(
jasmineUnderTest.ObjectContaining
);
expect(result).toEqual({
self: sample,
other: {

63
spec/core/asymmetric_equality/SetContainingSpec.js
View File

@@ -1,6 +1,7 @@
/* eslint-disable compat/compat */
describe('SetContaining', function() {
function SetI(iterable) { // for IE11
function SetI(iterable) {
// for IE11
var set = new Set();
iterable.forEach(function(v) {
set.add(v);
@@ -12,7 +13,6 @@ describe('SetContaining', function() {
jasmine.getEnv().requireFunctioningSets();
});
it('matches any actual set to an empty set', function() {
var actualSet = new SetI(['foo', 'bar']);
var containing = new jasmineUnderTest.SetContaining(new Set());
@@ -21,13 +21,9 @@ describe('SetContaining', function() {
});
it('matches when all the values in sample have matches in actual', function() {
var actualSet = new SetI([
{'foo': 'bar'}, 'baz', [1, 2, 3]
]);
var actualSet = new SetI([{ foo: 'bar' }, 'baz', [1, 2, 3]]);
var containingSet = new SetI([
[1, 2, 3], {'foo': 'bar'}
]);
var containingSet = new SetI([[1, 2, 3], { foo: 'bar' }]);
var containing = new jasmineUnderTest.SetContaining(containingSet);
var matchersUtil = new jasmineUnderTest.MatchersUtil();
@@ -35,13 +31,9 @@ describe('SetContaining', function() {
});
it('does not match when a value is not in actual', function() {
var actualSet = new SetI([
{'foo': 'bar'}, 'baz', [1, 2, 3]
]);
var actualSet = new SetI([{ foo: 'bar' }, 'baz', [1, 2, 3]]);
var containingSet = new SetI([
[1, 2], {'foo': 'bar'}
]);
var containingSet = new SetI([[1, 2], { foo: 'bar' }]);
var containing = new jasmineUnderTest.SetContaining(containingSet);
var matchersUtil = new jasmineUnderTest.MatchersUtil();
@@ -49,13 +41,11 @@ describe('SetContaining', function() {
});
it('matches when all the values in sample have asymmetric matches in actual', function() {
var actualSet = new SetI([
[1, 2, 3, 4], 'other', 'foo1'
]);
var actualSet = new SetI([[1, 2, 3, 4], 'other', 'foo1']);
var containingSet = new SetI([
jasmineUnderTest.stringMatching(/^foo\d/),
jasmineUnderTest.arrayContaining([2, 3]),
jasmineUnderTest.arrayContaining([2, 3])
]);
var containing = new jasmineUnderTest.SetContaining(containingSet);
var matchersUtil = new jasmineUnderTest.MatchersUtil();
@@ -64,13 +54,11 @@ describe('SetContaining', function() {
});
it('does not match when a value in sample has no asymmetric matches in actual', function() {
var actualSet = new SetI([
'a-foo1', [1, 2, 3, 4], 'other'
]);
var actualSet = new SetI(['a-foo1', [1, 2, 3, 4], 'other']);
var containingSet = new SetI([
jasmine.stringMatching(/^foo\d/),
jasmine.arrayContaining([2, 3]),
jasmine.arrayContaining([2, 3])
]);
var containing = new jasmineUnderTest.SetContaining(containingSet);
var matchersUtil = new jasmineUnderTest.MatchersUtil();
@@ -79,12 +67,11 @@ describe('SetContaining', function() {
});
it('matches recursively', function() {
var actualSet = new SetI([
'foo', new SetI([1, 'bar', 2]), 'other'
]);
var actualSet = new SetI(['foo', new SetI([1, 'bar', 2]), 'other']);
var containingSet = new SetI([
new jasmineUnderTest.SetContaining(new SetI(['bar'])), 'foo'
new jasmineUnderTest.SetContaining(new SetI(['bar'])),
'foo'
]);
var containing = new jasmineUnderTest.SetContaining(containingSet);
var matchersUtil = new jasmineUnderTest.MatchersUtil();
@@ -95,25 +82,37 @@ describe('SetContaining', function() {
it('uses custom equality testers', function() {
function tester(a, b) {
// treat all negative numbers as equal
return (typeof a == 'number' && typeof b == 'number') ? (a < 0 && b < 0) : a === b;
return typeof a == 'number' && typeof b == 'number'
? a < 0 && b < 0
: a === b;
}
var actualSet = new SetI(['foo', -1]);
var containing = new jasmineUnderTest.SetContaining(new SetI([-2, 'foo']));
var matchersUtil = new jasmineUnderTest.MatchersUtil({customTesters: [tester]});
var matchersUtil = new jasmineUnderTest.MatchersUtil({
customTesters: [tester]
});
expect(containing.asymmetricMatch(actualSet, matchersUtil)).toBe(true);
});
it('does not match when actual is not a set', function() {
var containingSet = new SetI(['foo']);
expect(new jasmineUnderTest.SetContaining(containingSet).asymmetricMatch('foo')).toBe(false);
expect(new jasmineUnderTest.SetContaining(containingSet).asymmetricMatch(1)).toBe(false);
expect(new jasmineUnderTest.SetContaining(containingSet).asymmetricMatch(['foo'])).toBe(false);
expect(
new jasmineUnderTest.SetContaining(containingSet).asymmetricMatch('foo')
).toBe(false);
expect(
new jasmineUnderTest.SetContaining(containingSet).asymmetricMatch(1)
).toBe(false);
expect(
new jasmineUnderTest.SetContaining(containingSet).asymmetricMatch(['foo'])
).toBe(false);
});
it('throws an error when sample is not a set', function() {
expect(function() {
new jasmineUnderTest.SetContaining({'foo': 'bar'}).asymmetricMatch(new Set());
new jasmineUnderTest.SetContaining({ foo: 'bar' }).asymmetricMatch(
new Set()
);
}).toThrowError(/You must provide a set/);
});

12
spec/core/asymmetric_equality/StringMatchingSpec.js
View File

@@ -1,19 +1,19 @@
describe("StringMatching", function() {
it("matches a string against a provided regexp", function() {
describe('StringMatching', function() {
it('matches a string against a provided regexp', function() {
var matcher = new jasmineUnderTest.StringMatching(/foo/);
expect(matcher.asymmetricMatch('barfoobaz')).toBe(true);
expect(matcher.asymmetricMatch('barbaz')).toBe(false);
});
it("matches a string against provided string", function() {
it('matches a string against provided string', function() {
var matcher = new jasmineUnderTest.StringMatching('foo');
expect(matcher.asymmetricMatch('barfoobaz')).toBe(true);
expect(matcher.asymmetricMatch('barbaz')).toBe(false);
});
it("raises an Error when the expected is not a String or RegExp", function() {
it('raises an Error when the expected is not a String or RegExp', function() {
expect(function() {
new jasmineUnderTest.StringMatching({});
}).toThrowError(/not a String or a RegExp/);
@@ -22,6 +22,8 @@ describe("StringMatching", function() {
it("jasmineToString's itself", function() {
var matching = new jasmineUnderTest.StringMatching(/^foo/);
expect(matching.jasmineToString()).toEqual("<jasmine.stringMatching(/^foo/)>");
expect(matching.jasmineToString()).toEqual(
'<jasmine.stringMatching(/^foo/)>'
);
});
});

28
spec/core/asymmetric_equality/TruthySpec.js
View File

@@ -1,12 +1,12 @@
describe("Truthy", function () {
it("is true for a non empty string", function () {
describe('Truthy', function() {
it('is true for a non empty string', function() {
var truthy = new jasmineUnderTest.Truthy();
expect(truthy.asymmetricMatch("foo")).toBe(true);
expect(truthy.asymmetricMatch("")).toBe(false);
expect(truthy.asymmetricMatch('foo')).toBe(true);
expect(truthy.asymmetricMatch('')).toBe(false);
});
it("is true for a number that is not 0", function () {
it('is true for a number that is not 0', function() {
var truthy = new jasmineUnderTest.Truthy();
expect(truthy.asymmetricMatch(1)).toBe(true);
@@ -15,49 +15,47 @@ describe("Truthy", function () {
expect(truthy.asymmetricMatch(-3.1)).toBe(true);
});
it("is true for a function", function () {
it('is true for a function', function() {
var truthy = new jasmineUnderTest.Truthy();
expect(truthy.asymmetricMatch(function () {
})).toBe(true);
expect(truthy.asymmetricMatch(function() {})).toBe(true);
});
it("is true for an Object", function () {
it('is true for an Object', function() {
var truthy = new jasmineUnderTest.Truthy();
expect(truthy.asymmetricMatch({})).toBe(true);
});
it("is true for a truthful Boolean", function () {
it('is true for a truthful Boolean', function() {
var truthy = new jasmineUnderTest.Truthy();
expect(truthy.asymmetricMatch(true)).toBe(true);
expect(truthy.asymmetricMatch(false)).toBe(false);
});
it("is true for an empty object", function () {
it('is true for an empty object', function() {
var truthy = new jasmineUnderTest.Truthy();
expect(truthy.asymmetricMatch({})).toBe(true);
});
it("is true for an empty array", function () {
it('is true for an empty array', function() {
var truthy = new jasmineUnderTest.Truthy();
expect(truthy.asymmetricMatch([])).toBe(true);
});
it("is true for a date", function () {
it('is true for a date', function() {
var truthy = new jasmineUnderTest.Truthy();
expect(truthy.asymmetricMatch(new Date())).toBe(true);
});
it("is true for a infiniti", function () {
it('is true for a infiniti', function() {
var truthy = new jasmineUnderTest.Truthy();
expect(truthy.asymmetricMatch(Infinity)).toBe(true);
expect(truthy.asymmetricMatch(-Infinity)).toBe(true);
});
});