jasmine-core 2.5.0 → 2.99.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (55) hide show
  1. checksums.yaml +4 -4
  2. data/lib/console/console.js +1 -1
  3. data/lib/jasmine-core/boot/boot.js +4 -1
  4. data/lib/jasmine-core/boot.js +5 -2
  5. data/lib/jasmine-core/jasmine-html.js +95 -31
  6. data/lib/jasmine-core/jasmine.css +1 -0
  7. data/lib/jasmine-core/jasmine.js +3635 -1684
  8. data/lib/jasmine-core/node_boot.js +1 -1
  9. data/lib/jasmine-core/spec/core/CallTrackerSpec.js +10 -0
  10. data/lib/jasmine-core/spec/core/ClearStackSpec.js +137 -0
  11. data/lib/jasmine-core/spec/core/ClockSpec.js +94 -14
  12. data/lib/jasmine-core/spec/core/DelayedFunctionSchedulerSpec.js +26 -8
  13. data/lib/jasmine-core/spec/core/EnvSpec.js +142 -10
  14. data/lib/jasmine-core/spec/core/ExpectationSpec.js +52 -7
  15. data/lib/jasmine-core/spec/core/GlobalErrorsSpec.js +110 -0
  16. data/lib/jasmine-core/spec/core/PrettyPrintSpec.js +132 -4
  17. data/lib/jasmine-core/spec/core/QueueRunnerSpec.js +333 -23
  18. data/lib/jasmine-core/spec/core/ReportDispatcherSpec.js +16 -1
  19. data/lib/jasmine-core/spec/core/SpecSpec.js +30 -8
  20. data/lib/jasmine-core/spec/core/SpyRegistrySpec.js +225 -1
  21. data/lib/jasmine-core/spec/core/SpySpec.js +44 -2
  22. data/lib/jasmine-core/spec/core/SpyStrategySpec.js +28 -5
  23. data/lib/jasmine-core/spec/core/SuiteSpec.js +14 -19
  24. data/lib/jasmine-core/spec/core/UserContextSpec.js +54 -0
  25. data/lib/jasmine-core/spec/core/UtilSpec.js +71 -0
  26. data/lib/jasmine-core/spec/core/asymmetric_equality/AnySpec.js +32 -0
  27. data/lib/jasmine-core/spec/core/asymmetric_equality/AnythingSpec.js +32 -0
  28. data/lib/jasmine-core/spec/core/asymmetric_equality/ArrayContainingSpec.js +13 -0
  29. data/lib/jasmine-core/spec/core/asymmetric_equality/ArrayWithExactContentsSpec.js +47 -0
  30. data/lib/jasmine-core/spec/core/asymmetric_equality/ObjectContainingSpec.js +13 -0
  31. data/lib/jasmine-core/spec/core/integration/CustomMatchersSpec.js +48 -0
  32. data/lib/jasmine-core/spec/core/integration/EnvSpec.js +339 -38
  33. data/lib/jasmine-core/spec/core/integration/SpecRunningSpec.js +156 -3
  34. data/lib/jasmine-core/spec/core/matchers/DiffBuilderSpec.js +47 -0
  35. data/lib/jasmine-core/spec/core/matchers/NullDiffBuilderSpec.js +13 -0
  36. data/lib/jasmine-core/spec/core/matchers/ObjectPathSpec.js +43 -0
  37. data/lib/jasmine-core/spec/core/matchers/matchersUtilSpec.js +231 -8
  38. data/lib/jasmine-core/spec/core/matchers/nothingSpec.js +8 -0
  39. data/lib/jasmine-core/spec/core/matchers/toBeCloseToSpec.js +42 -0
  40. data/lib/jasmine-core/spec/core/matchers/toBeNegativeInfinitySpec.js +31 -0
  41. data/lib/jasmine-core/spec/core/matchers/toBePositiveInfinitySpec.js +31 -0
  42. data/lib/jasmine-core/spec/core/matchers/toEqualSpec.js +780 -4
  43. data/lib/jasmine-core/spec/core/matchers/toHaveBeenCalledBeforeSpec.js +99 -0
  44. data/lib/jasmine-core/spec/core/matchers/toThrowErrorSpec.js +37 -0
  45. data/lib/jasmine-core/spec/helpers/BrowserFlags.js +4 -0
  46. data/lib/jasmine-core/spec/helpers/asyncAwait.js +27 -0
  47. data/lib/jasmine-core/spec/helpers/checkForMap.js +37 -0
  48. data/lib/jasmine-core/spec/helpers/checkForSet.js +41 -0
  49. data/lib/jasmine-core/spec/helpers/checkForSymbol.js +28 -0
  50. data/lib/jasmine-core/spec/helpers/checkForTypedArrays.js +20 -0
  51. data/lib/jasmine-core/spec/html/HtmlReporterSpec.js +105 -23
  52. data/lib/jasmine-core/spec/html/SpyRegistryHtmlSpec.js +34 -0
  53. data/lib/jasmine-core/spec/npmPackage/npmPackageSpec.js +1 -1
  54. data/lib/jasmine-core/version.rb +1 -1
  55. metadata +19 -4
@@ -172,6 +172,22 @@ describe("jasmine spec running", function () {
172
172
  it("should run multiple befores and afters ordered so functions declared later are treated as more specific", function(done) {
173
173
  var actions = [];
174
174
 
175
+ env.beforeAll(function() {
176
+ actions.push('runner beforeAll1');
177
+ });
178
+
179
+ env.afterAll(function() {
180
+ actions.push('runner afterAll1');
181
+ });
182
+
183
+ env.beforeAll(function() {
184
+ actions.push('runner beforeAll2');
185
+ });
186
+
187
+ env.afterAll(function() {
188
+ actions.push('runner afterAll2');
189
+ });
190
+
175
191
  env.beforeEach(function () {
176
192
  actions.push('runner beforeEach1');
177
193
  });
@@ -212,6 +228,8 @@ describe("jasmine spec running", function () {
212
228
 
213
229
  var assertions = function() {
214
230
  var expected = [
231
+ "runner beforeAll1",
232
+ "runner beforeAll2",
215
233
  "runner beforeEach1",
216
234
  "runner beforeEach2",
217
235
  "beforeEach1",
@@ -220,7 +238,9 @@ describe("jasmine spec running", function () {
220
238
  "afterEach2",
221
239
  "afterEach1",
222
240
  "runner afterEach2",
223
- "runner afterEach1"
241
+ "runner afterEach1",
242
+ "runner afterAll2",
243
+ "runner afterAll1"
224
244
  ];
225
245
  expect(actions).toEqual(expected);
226
246
  done();
@@ -475,7 +495,7 @@ describe("jasmine spec running", function () {
475
495
  env.execute();
476
496
  });
477
497
 
478
- it('focused runnables unfocus ancestor focused suites', function() {
498
+ it('focused runnables unfocus ancestor focused suites', function(done) {
479
499
  var actions = [];
480
500
 
481
501
  env.fdescribe('focused suite', function() {
@@ -518,7 +538,29 @@ describe("jasmine spec running", function () {
518
538
  env.execute();
519
539
  });
520
540
 
521
- it("should allow top level suites to be disabled", function() {
541
+ it("shouldn't run before/after functions in disabled suites", function(done) {
542
+ var shouldNotRun = jasmine.createSpy("shouldNotRun"),
543
+ suite = env.xdescribe('A disabled Suite', function() {
544
+ // None of the before/after functions should run.
545
+ env.beforeAll(shouldNotRun);
546
+ env.beforeEach(shouldNotRun);
547
+ env.afterEach(shouldNotRun);
548
+ env.afterAll(shouldNotRun);
549
+
550
+ env.it('spec inside a disabled suite', shouldNotRun);
551
+ });
552
+
553
+ var assertions = function() {
554
+ expect(shouldNotRun).not.toHaveBeenCalled();
555
+ done();
556
+ };
557
+
558
+ env.addReporter({jasmineDone: assertions});
559
+
560
+ env.execute();
561
+ });
562
+
563
+ it("should allow top level suites to be disabled", function(done) {
522
564
  var specInADisabledSuite = jasmine.createSpy("specInADisabledSuite"),
523
565
  otherSpec = jasmine.createSpy("otherSpec");
524
566
 
@@ -794,4 +836,115 @@ describe("jasmine spec running", function () {
794
836
  env.execute();
795
837
  });
796
838
 
839
+ describe("When throwOnExpectationFailure is set", function() {
840
+ it("skips to cleanup functions after an error", function(done) {
841
+ var actions = [];
842
+
843
+ env.describe('Something', function() {
844
+ env.beforeEach(function() {
845
+ actions.push('outer beforeEach');
846
+ throw new Error("error");
847
+ });
848
+
849
+ env.afterEach(function() {
850
+ actions.push('outer afterEach');
851
+ });
852
+
853
+ env.describe('Inner', function() {
854
+ env.beforeEach(function() {
855
+ actions.push('inner beforeEach');
856
+ });
857
+
858
+ env.afterEach(function() {
859
+ actions.push('inner afterEach');
860
+ });
861
+
862
+ env.it('does it' , function() {
863
+ actions.push('inner it');
864
+ });
865
+ });
866
+ });
867
+
868
+ env.throwOnExpectationFailure(true);
869
+
870
+ var assertions = function() {
871
+ expect(actions).toEqual([
872
+ 'outer beforeEach',
873
+ 'inner afterEach',
874
+ 'outer afterEach'
875
+ ]);
876
+ done();
877
+ };
878
+
879
+ env.addReporter({jasmineDone: assertions});
880
+
881
+ env.execute();
882
+ });
883
+
884
+ it("skips to cleanup functions after done.fail is called", function(done) {
885
+ var actions = [];
886
+
887
+ env.describe('Something', function() {
888
+ env.beforeEach(function(done) {
889
+ actions.push('beforeEach');
890
+ done.fail('error');
891
+ actions.push('after done.fail');
892
+ });
893
+
894
+ env.afterEach(function() {
895
+ actions.push('afterEach');
896
+ });
897
+
898
+ env.it('does it' , function() {
899
+ actions.push('it');
900
+ });
901
+ });
902
+
903
+ env.throwOnExpectationFailure(true);
904
+
905
+ var assertions = function() {
906
+ expect(actions).toEqual([
907
+ 'beforeEach',
908
+ 'afterEach'
909
+ ]);
910
+ done();
911
+ };
912
+
913
+ env.addReporter({jasmineDone: assertions});
914
+
915
+ env.execute();
916
+ });
917
+
918
+ it("skips to cleanup functions when an async function times out", function(done) {
919
+ var actions = [];
920
+
921
+ env.describe('Something', function() {
922
+ env.beforeEach(function(innerDone) {
923
+ actions.push('beforeEach');
924
+ }, 1);
925
+
926
+ env.afterEach(function() {
927
+ actions.push('afterEach');
928
+ });
929
+
930
+ env.it('does it' , function() {
931
+ actions.push('it');
932
+ });
933
+ });
934
+
935
+ env.throwOnExpectationFailure(true);
936
+
937
+ var assertions = function() {
938
+ expect(actions).toEqual([
939
+ 'beforeEach',
940
+ 'afterEach'
941
+ ]);
942
+ done();
943
+ };
944
+
945
+ env.addReporter({jasmineDone: assertions});
946
+
947
+ env.execute();
948
+ });
949
+ });
797
950
  });
@@ -0,0 +1,47 @@
1
+ describe("DiffBuilder", function() {
2
+ it("records the actual and expected objects", function() {
3
+ var diffBuilder = jasmineUnderTest.DiffBuilder();
4
+ diffBuilder.record({x: 'actual'}, {x: 'expected'});
5
+
6
+ expect(diffBuilder.getMessage()).toEqual("Expected Object({ x: 'actual' }) to equal Object({ x: 'expected' }).");
7
+ });
8
+
9
+ it("prints the path at which the difference was found", function() {
10
+ var diffBuilder = jasmineUnderTest.DiffBuilder();
11
+
12
+ diffBuilder.withPath('foo', function() {
13
+ diffBuilder.record({x: 'actual'}, {x: 'expected'});
14
+ });
15
+
16
+ expect(diffBuilder.getMessage()).toEqual("Expected $.foo = Object({ x: 'actual' }) to equal Object({ x: 'expected' }).");
17
+ });
18
+
19
+ it("prints multiple messages, separated by newlines", function() {
20
+ var diffBuilder = jasmineUnderTest.DiffBuilder();
21
+
22
+ diffBuilder.withPath('foo', function() {
23
+ diffBuilder.record(1, 2);
24
+ });
25
+
26
+ var message =
27
+ "Expected $.foo = 1 to equal 2.\n" +
28
+ "Expected 3 to equal 4.";
29
+
30
+ diffBuilder.record(3, 4);
31
+ expect(diffBuilder.getMessage()).toEqual(message);
32
+ });
33
+
34
+ it("allows customization of the message", function() {
35
+ var diffBuilder = jasmineUnderTest.DiffBuilder();
36
+
37
+ function darthVaderFormatter(actual, expected, path) {
38
+ return "I find your lack of " + expected + " disturbing. (was " + actual + ", at " + path + ")"
39
+ }
40
+
41
+ diffBuilder.withPath('x', function() {
42
+ diffBuilder.record('bar', 'foo', darthVaderFormatter);
43
+ });
44
+
45
+ expect(diffBuilder.getMessage()).toEqual("I find your lack of foo disturbing. (was bar, at $.x)");
46
+ });
47
+ });
@@ -0,0 +1,13 @@
1
+ describe('NullDiffBuilder', function() {
2
+ it('responds to withPath() by calling the passed function', function() {
3
+ var spy = jasmine.createSpy('callback');
4
+ jasmineUnderTest.NullDiffBuilder().withPath('does not matter', spy);
5
+ expect(spy).toHaveBeenCalled();
6
+ });
7
+
8
+ it('responds to record()', function() {
9
+ expect(function() {
10
+ jasmineUnderTest.NullDiffBuilder().record('does not matter');
11
+ }).not.toThrow();
12
+ })
13
+ });
@@ -0,0 +1,43 @@
1
+ describe('ObjectPath', function() {
2
+ var ObjectPath = jasmineUnderTest.ObjectPath;
3
+
4
+ it('represents the path to a node in an object tree', function() {
5
+ expect(new ObjectPath(['foo', 'bar']).toString()).toEqual('$.foo.bar');
6
+ });
7
+
8
+ it('has a depth', function() {
9
+ expect(new ObjectPath().depth()).toEqual(0);
10
+ expect(new ObjectPath(['foo']).depth()).toEqual(1);
11
+ });
12
+
13
+ it('renders numbers as array access', function() {
14
+ expect(new ObjectPath(['foo', 0]).toString()).toEqual('$.foo[0]');
15
+ });
16
+
17
+ it('renders properties that are valid identifiers with dot notation', function() {
18
+ expect(new ObjectPath(['foo123']).toString()).toEqual('$.foo123');
19
+ expect(new ObjectPath(['x_y']).toString()).toEqual('$.x_y');
20
+ expect(new ObjectPath(['A$B']).toString()).toEqual('$.A$B');
21
+ });
22
+
23
+ it('renders properties with non-identifier-safe characters with square bracket notation', function() {
24
+ expect(new ObjectPath(['a b c']).toString()).toEqual("$['a b c']");
25
+ expect(new ObjectPath(['1hello']).toString()).toEqual("$['1hello']");
26
+ });
27
+
28
+ it('renders as the empty string when empty', function() {
29
+ expect(new ObjectPath().toString()).toEqual('');
30
+ });
31
+
32
+ it('stringifies properties that are not strings or numbers', function() {
33
+ expect(new ObjectPath([{}]).toString()).toEqual("$['[object Object]']");
34
+ });
35
+
36
+ it('can be created based on another path', function() {
37
+ var root = new ObjectPath();
38
+ var path = root.add('foo');
39
+
40
+ expect(path.toString()).toEqual('$.foo');
41
+ expect(root.toString()).toEqual('');
42
+ })
43
+ });
@@ -61,13 +61,17 @@ describe("matchersUtil", function() {
61
61
  expect(jasmineUnderTest.matchersUtil.equals(foo, [undefined])).toBe(true);
62
62
  });
63
63
 
64
- it("fails for Arrays that are not equivalent", function() {
64
+ it("fails for Arrays that have different lengths", function() {
65
65
  expect(jasmineUnderTest.matchersUtil.equals([1, 2], [1, 2, 3])).toBe(false);
66
66
  });
67
67
 
68
+ it("fails for Arrays that have different elements", function() {
69
+ expect(jasmineUnderTest.matchersUtil.equals([1, 2, 3], [1, 5, 3])).toBe(false);
70
+ });
71
+
68
72
  it("fails for Arrays whose contents are equivalent, but have differing properties", function() {
69
73
  var one = [1,2,3],
70
- two = [1,2,3];
74
+ two = [1,2,3];
71
75
 
72
76
  one.foo = 'bar';
73
77
  two.foo = 'baz';
@@ -77,7 +81,7 @@ describe("matchersUtil", function() {
77
81
 
78
82
  it("passes for Arrays with equivalent contents and properties", function() {
79
83
  var one = [1,2,3],
80
- two = [1,2,3];
84
+ two = [1,2,3];
81
85
 
82
86
  one.foo = 'bar';
83
87
  two.foo = 'bar';
@@ -118,7 +122,7 @@ describe("matchersUtil", function() {
118
122
 
119
123
  it("passes for Objects that are equivalent (with cycles)", function() {
120
124
  var actual = { a: "foo" },
121
- expected = { a: "foo" };
125
+ expected = { a: "foo" };
122
126
 
123
127
  actual.b = actual;
124
128
  expected.b = actual;
@@ -136,6 +140,13 @@ describe("matchersUtil", function() {
136
140
  expect(jasmineUnderTest.matchersUtil.equals(actual, expected)).toBe(false);
137
141
  });
138
142
 
143
+ it("fails for Objects that have the same number of keys, but different keys/values", function () {
144
+ var expected = { a: undefined },
145
+ actual = { b: 1 };
146
+
147
+ expect(jasmineUnderTest.matchersUtil.equals(actual, expected)).toBe(false);
148
+ })
149
+
139
150
  it("fails when comparing an empty object to an empty array (issue #114)", function() {
140
151
  var emptyObject = {},
141
152
  emptyArray = [];
@@ -155,6 +166,16 @@ describe("matchersUtil", function() {
155
166
 
156
167
  expect(jasmineUnderTest.matchersUtil.equals(a,b)).toBe(true);
157
168
  });
169
+
170
+ it("passes for equivalent Promises (GitHub issue #1314)", function() {
171
+ if (typeof Promise === 'undefined') { return; }
172
+
173
+ var p1 = new Promise(function () {}),
174
+ p2 = new Promise(function () {});
175
+
176
+ expect(jasmineUnderTest.matchersUtil.equals(p1, p1)).toBe(true);
177
+ expect(jasmineUnderTest.matchersUtil.equals(p1, p2)).toBe(false);
178
+ });
158
179
 
159
180
  describe("when running in a browser", function() {
160
181
  function isNotRunningInBrowser() {
@@ -321,15 +342,25 @@ describe("matchersUtil", function() {
321
342
 
322
343
  it("passes for an asymmetric equality tester that returns true when a custom equality tester return false", function() {
323
344
  var asymmetricTester = { asymmetricMatch: function(other) { return true; } },
324
- symmetricTester = function(a, b) { return false; };
345
+ symmetricTester = function(a, b) { return false; };
325
346
 
326
347
  expect(jasmineUnderTest.matchersUtil.equals(asymmetricTester, true, [symmetricTester])).toBe(true);
327
348
  expect(jasmineUnderTest.matchersUtil.equals(true, asymmetricTester, [symmetricTester])).toBe(true);
328
349
  });
329
350
 
351
+ it("passes custom equality matchers to asymmetric equality testers", function() {
352
+ var tester = function(a, b) {};
353
+ var asymmetricTester = { asymmetricMatch: jasmine.createSpy('asymmetricMatch') };
354
+ asymmetricTester.asymmetricMatch.and.returnValue(true);
355
+ var other = {};
356
+
357
+ expect(jasmineUnderTest.matchersUtil.equals(asymmetricTester, other, [tester])).toBe(true);
358
+ expect(asymmetricTester.asymmetricMatch).toHaveBeenCalledWith(other, [tester]);
359
+ });
360
+
330
361
  it("passes when an Any is compared to an Any that checks for the same type", function() {
331
362
  var any1 = new jasmineUnderTest.Any(Function),
332
- any2 = new jasmineUnderTest.Any(Function);
363
+ any2 = new jasmineUnderTest.Any(Function);
333
364
 
334
365
  expect(jasmineUnderTest.matchersUtil.equals(any1, any2)).toBe(true);
335
366
  });
@@ -338,7 +369,7 @@ describe("matchersUtil", function() {
338
369
  if (jasmine.getEnv().ieVersion < 9) { return; }
339
370
 
340
371
  var objA = Object.create(null),
341
- objB = Object.create(null);
372
+ objB = Object.create(null);
342
373
 
343
374
  objA.name = 'test';
344
375
  objB.name = 'test';
@@ -350,13 +381,205 @@ describe("matchersUtil", function() {
350
381
  if (jasmine.getEnv().ieVersion < 9) { return; }
351
382
 
352
383
  var objA = Object.create(null),
353
- objB = Object.create(null);
384
+ objB = Object.create(null);
354
385
 
355
386
  objA.name = 'test';
356
387
  objB.test = 'name';
357
388
 
358
389
  expect(jasmineUnderTest.matchersUtil.equals(objA, objB)).toBe(false);
359
390
  });
391
+
392
+ it("passes when comparing two empty sets", function() {
393
+ jasmine.getEnv().requireFunctioningSets();
394
+ expect(jasmineUnderTest.matchersUtil.equals(new Set(), new Set())).toBe(true);
395
+ });
396
+
397
+ it("passes when comparing identical sets", function() {
398
+ jasmine.getEnv().requireFunctioningSets();
399
+
400
+ var setA = new Set();
401
+ setA.add(6);
402
+ setA.add(5);
403
+ var setB = new Set();
404
+ setB.add(6);
405
+ setB.add(5);
406
+
407
+ expect(jasmineUnderTest.matchersUtil.equals(setA, setB)).toBe(true);
408
+ });
409
+
410
+ it("passes when comparing identical sets with different insertion order and simple elements", function() {
411
+ jasmine.getEnv().requireFunctioningSets();
412
+
413
+ var setA = new Set();
414
+ setA.add(3);
415
+ setA.add(6);
416
+ var setB = new Set();
417
+ setB.add(6);
418
+ setB.add(3);
419
+
420
+ expect(jasmineUnderTest.matchersUtil.equals(setA, setB)).toBe(true);
421
+ });
422
+
423
+ it("passes when comparing identical sets with different insertion order and complex elements 1", function() {
424
+ jasmine.getEnv().requireFunctioningSets();
425
+
426
+ var setA1 = new Set();
427
+ setA1.add(['a',3]);
428
+ setA1.add([6,1]);
429
+ var setA2 = new Set();
430
+ setA1.add(['y',3]);
431
+ setA1.add([6,1]);
432
+ var setA = new Set();
433
+ setA.add(setA1);
434
+ setA.add(setA2);
435
+
436
+
437
+ var setB1 = new Set();
438
+ setB1.add([6,1]);
439
+ setB1.add(['a',3]);
440
+ var setB2 = new Set();
441
+ setB1.add([6,1]);
442
+ setB1.add(['y',3]);
443
+ var setB = new Set();
444
+ setB.add(setB1);
445
+ setB.add(setB2);
446
+
447
+ expect(jasmineUnderTest.matchersUtil.equals(setA, setB)).toBe(true);
448
+ });
449
+
450
+ it("passes when comparing identical sets with different insertion order and complex elements 2", function() {
451
+ jasmine.getEnv().requireFunctioningSets();
452
+
453
+ var setA = new Set();
454
+ setA.add([[1,2], [3,4]]);
455
+ setA.add([[5,6], [7,8]]);
456
+ var setB = new Set();
457
+ setB.add([[5,6], [7,8]]);
458
+ setB.add([[1,2], [3,4]]);
459
+
460
+ expect(jasmineUnderTest.matchersUtil.equals(setA, setB)).toBe(true);
461
+ });
462
+
463
+ it("fails for sets with different elements", function() {
464
+ jasmine.getEnv().requireFunctioningSets();
465
+ var setA = new Set();
466
+ setA.add(6);
467
+ setA.add(3);
468
+ setA.add(5);
469
+ var setB = new Set();
470
+ setB.add(6);
471
+ setB.add(4);
472
+ setB.add(5);
473
+
474
+ expect(jasmineUnderTest.matchersUtil.equals(setA, setB)).toBe(false);
475
+ });
476
+
477
+ it("fails for sets of different size", function() {
478
+ jasmine.getEnv().requireFunctioningSets();
479
+ var setA = new Set();
480
+ setA.add(6);
481
+ setA.add(3);
482
+ var setB = new Set();
483
+ setB.add(6);
484
+ setB.add(4);
485
+ setB.add(5);
486
+
487
+ expect(jasmineUnderTest.matchersUtil.equals(setA, setB)).toBe(false);
488
+ });
489
+
490
+ it("passes when comparing two empty maps", function() {
491
+ jasmine.getEnv().requireFunctioningMaps();
492
+ expect(jasmineUnderTest.matchersUtil.equals(new Map(), new Map())).toBe(true);
493
+ });
494
+
495
+ it("passes when comparing identical maps", function() {
496
+ jasmine.getEnv().requireFunctioningMaps();
497
+ var mapA = new Map();
498
+ mapA.set(6, 5);
499
+ var mapB = new Map();
500
+ mapB.set(6, 5);
501
+ expect(jasmineUnderTest.matchersUtil.equals(mapA, mapB)).toBe(true);
502
+ });
503
+
504
+ it("passes when comparing identical maps with different insertion order", function() {
505
+ jasmine.getEnv().requireFunctioningMaps();
506
+ var mapA = new Map();
507
+ mapA.set("a", 3);
508
+ mapA.set(6, 1);
509
+ var mapB = new Map();
510
+ mapB.set(6, 1);
511
+ mapB.set("a", 3);
512
+ expect(jasmineUnderTest.matchersUtil.equals(mapA, mapB)).toBe(true);
513
+ });
514
+
515
+ it("fails for maps with different elements", function() {
516
+ jasmine.getEnv().requireFunctioningMaps();
517
+ var mapA = new Map();
518
+ mapA.set(6, 3);
519
+ mapA.set(5, 1);
520
+ var mapB = new Map();
521
+ mapB.set(6, 4);
522
+ mapB.set(5, 1);
523
+
524
+ expect(jasmineUnderTest.matchersUtil.equals(mapA, mapB)).toBe(false);
525
+ });
526
+
527
+ it("fails for maps of different size", function() {
528
+ jasmine.getEnv().requireFunctioningMaps();
529
+ var mapA = new Map();
530
+ mapA.set(6, 3);
531
+ var mapB = new Map();
532
+ mapB.set(6, 4);
533
+ mapB.set(5, 1);
534
+ expect(jasmineUnderTest.matchersUtil.equals(mapA, mapB)).toBe(false);
535
+ });
536
+
537
+ describe("when running in an environment with array polyfills", function() {
538
+ // IE 8 doesn't support `definePropery` on non-DOM nodes
539
+ if (jasmine.getEnv().ieVersion < 9) { return; }
540
+
541
+ var findIndexDescriptor = Object.getOwnPropertyDescriptor(Array.prototype, 'findIndex');
542
+ if (!findIndexDescriptor) {
543
+ return;
544
+ }
545
+
546
+ beforeEach(function() {
547
+ Object.defineProperty(Array.prototype, 'findIndex', {
548
+ enumerable: true,
549
+ value: function (predicate) {
550
+ if (this === null) {
551
+ throw new TypeError('Array.prototype.findIndex called on null or undefined');
552
+ }
553
+
554
+ if (typeof predicate !== 'function') {
555
+ throw new TypeError('predicate must be a function');
556
+ }
557
+
558
+ var list = Object(this);
559
+ var length = list.length >>> 0;
560
+ var thisArg = arguments[1];
561
+ var value;
562
+
563
+ for (var i = 0; i < length; i++) {
564
+ value = list[i];
565
+ if (predicate.call(thisArg, value, i, list)) {
566
+ return i;
567
+ }
568
+ }
569
+
570
+ return -1;
571
+ }
572
+ });
573
+ });
574
+
575
+ afterEach(function() {
576
+ Object.defineProperty(Array.prototype, 'findIndex', findIndexDescriptor);
577
+ });
578
+
579
+ it("passes when there's an array polyfill", function() {
580
+ expect(['foo']).toEqual(['foo']);
581
+ });
582
+ });
360
583
  });
361
584
 
362
585
  describe("contains", function() {
@@ -0,0 +1,8 @@
1
+ describe('nothing', function() {
2
+ it('should pass', function() {
3
+ var matcher = jasmineUnderTest.matchers.nothing(),
4
+ result = matcher.compare();
5
+
6
+ expect(result.pass).toBe(true);
7
+ });
8
+ });
@@ -8,6 +8,9 @@ describe("toBeCloseTo", function() {
8
8
 
9
9
  result = matcher.compare(0, 0.001);
10
10
  expect(result.pass).toBe(true);
11
+
12
+ result = matcher.compare(0, 0.005);
13
+ expect(result.pass).toBe(true);
11
14
  });
12
15
 
13
16
  it("fails when not within two decimal places by default", function() {
@@ -16,6 +19,9 @@ describe("toBeCloseTo", function() {
16
19
 
17
20
  result = matcher.compare(0, 0.01);
18
21
  expect(result.pass).toBe(false);
22
+
23
+ result = matcher.compare(0, 0.05);
24
+ expect(result.pass).toBe(false);
19
25
  });
20
26
 
21
27
  it("accepts an optional precision argument", function() {
@@ -25,8 +31,36 @@ describe("toBeCloseTo", function() {
25
31
  result = matcher.compare(0, 0.1, 0);
26
32
  expect(result.pass).toBe(true);
27
33
 
34
+ result = matcher.compare(0, 0.5, 0);
35
+ expect(result.pass).toBe(true);
36
+
28
37
  result = matcher.compare(0, 0.0001, 3);
29
38
  expect(result.pass).toBe(true);
39
+
40
+ result = matcher.compare(0, 0.0005, 3);
41
+ expect(result.pass).toBe(true);
42
+
43
+ result = matcher.compare(0, 0.00001, 4);
44
+ expect(result.pass).toBe(true);
45
+
46
+ result = matcher.compare(0, 0.00005, 4);
47
+ expect(result.pass).toBe(true);
48
+ });
49
+
50
+ it("fails when one of the arguments is null", function() {
51
+ var matcher = jasmineUnderTest.matchers.toBeCloseTo();
52
+
53
+ expect(function() {
54
+ matcher.compare(null, null);
55
+ }).toThrowError('Cannot use toBeCloseTo with null. Arguments evaluated to: expect(null).toBeCloseTo(null).');
56
+
57
+ expect(function() {
58
+ matcher.compare(0, null);
59
+ }).toThrowError('Cannot use toBeCloseTo with null. Arguments evaluated to: expect(0).toBeCloseTo(null).');
60
+
61
+ expect(function() {
62
+ matcher.compare(null, 0);
63
+ }).toThrowError('Cannot use toBeCloseTo with null. Arguments evaluated to: expect(null).toBeCloseTo(0).');
30
64
  });
31
65
 
32
66
  it("rounds expected values", function() {
@@ -42,7 +76,15 @@ describe("toBeCloseTo", function() {
42
76
  result = matcher.compare(1.23, 1.225);
43
77
  expect(result.pass).toBe(true);
44
78
 
79
+ result = matcher.compare(1.23, 1.235);
80
+ expect(result.pass).toBe(true);
81
+
82
+ // 1.2249999 will be rounded to 1.225
45
83
  result = matcher.compare(1.23, 1.2249999);
84
+ expect(result.pass).toBe(true);
85
+
86
+ // 1.2249999 will be rounded to 1.224
87
+ result = matcher.compare(1.23, 1.2244999);
46
88
  expect(result.pass).toBe(false);
47
89
 
48
90
  result = matcher.compare(1.23, 1.234);