jasmine-core 1.3.1 → 2.0.0.rc2

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

@@ -1,38 +0,0 @@
-describe("MockClock", function () {
-
-  beforeEach(function() {
-    jasmine.Clock.useMock();    
-  });
-
-  describe("setTimeout", function () {
-    it("should mock the clock when useMock is in a beforeEach", function() {
-      var expected = false;
-      setTimeout(function() {
-        expected = true;
-      }, 30000);
-      expect(expected).toBe(false);
-      jasmine.Clock.tick(30001);
-      expect(expected).toBe(true);
-    });
-  });
-
-  describe("setInterval", function () {
-    it("should mock the clock when useMock is in a beforeEach", function() {
-      var interval = 0;
-      setInterval(function() {
-        interval++;
-      }, 30000);
-      expect(interval).toEqual(0);
-      jasmine.Clock.tick(30001);
-      expect(interval).toEqual(1);
-      jasmine.Clock.tick(30001);
-      expect(interval).toEqual(2);
-      jasmine.Clock.tick(1);
-      expect(interval).toEqual(2);
-    });
-  });
-
-  it("shouldn't complain if you call jasmine.Clock.useMock() more than once", function() {
-    jasmine.Clock.useMock();
-  });
-});

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

@@ -1,45 +0,0 @@
-describe("jasmine.MultiReporter", function() {
-  var multiReporter, fakeReporter1, fakeReporter2;
-
-  beforeEach(function() {
-    multiReporter = new jasmine.MultiReporter();
-    fakeReporter1 = jasmine.createSpyObj("fakeReporter1", ["reportSpecResults"]);
-    fakeReporter2 = jasmine.createSpyObj("fakeReporter2", ["reportSpecResults", "reportRunnerStarting"]);
-    multiReporter.addReporter(fakeReporter1);
-    multiReporter.addReporter(fakeReporter2);
-  });
-
-  it("should support all the method calls that jasmine.Reporter supports", function() {
-    var delegate = {};
-    multiReporter.addReporter(delegate);
-
-    this.addMatchers({
-      toDelegateMethod: function(methodName) {
-        delegate[methodName] = jasmine.createSpy(methodName);
-        this.actual[methodName]("whatever argument");
-
-        return delegate[methodName].wasCalled && 
-               delegate[methodName].mostRecentCall.args.length == 1 && 
-               delegate[methodName].mostRecentCall.args[0] == "whatever argument";
-      }
-    });
-
-    expect(multiReporter).toDelegateMethod('reportRunnerStarting');
-    expect(multiReporter).toDelegateMethod('reportRunnerResults');
-    expect(multiReporter).toDelegateMethod('reportSuiteResults');
-    expect(multiReporter).toDelegateMethod('reportSpecStarting');
-    expect(multiReporter).toDelegateMethod('reportSpecResults');
-    expect(multiReporter).toDelegateMethod('log');
-  });
-
-  it("should delegate to any and all subreporters", function() {
-    multiReporter.reportSpecResults('blah', 'foo');
-    expect(fakeReporter1.reportSpecResults).toHaveBeenCalledWith('blah', 'foo');
-    expect(fakeReporter2.reportSpecResults).toHaveBeenCalledWith('blah', 'foo');
-  });
-
-  it("should quietly skip delegating to any subreporters which lack the given method", function() {
-    multiReporter.reportRunnerStarting('blah', 'foo');
-    expect(fakeReporter2.reportRunnerStarting).toHaveBeenCalledWith('blah', 'foo');
-  });
-});

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

@@ -1,54 +0,0 @@
-describe('jasmine.NestedResults', function() {
-  it('#addResult increments counters', function() {
-    // Leaf case
-    var results = new jasmine.NestedResults();
-
-    results.addResult(new jasmine.ExpectationResult({
-      matcherName: "foo", passed: true, message: 'Passed.', actual: 'bar', expected: 'bar'}
-    ));
-
-    expect(results.getItems().length).toEqual(1);
-    expect(results.totalCount).toEqual(1);
-    expect(results.passedCount).toEqual(1);
-    expect(results.failedCount).toEqual(0);
-
-    results.addResult(new jasmine.ExpectationResult({
-      matcherName: "baz", passed: false, message: 'FAIL.', actual: "corge", expected: "quux"
-    }));
-
-    expect(results.getItems().length).toEqual(2);
-    expect(results.totalCount).toEqual(2);
-    expect(results.passedCount).toEqual(1);
-    expect(results.failedCount).toEqual(1);
-  });
-
-  it('should roll up counts for nested results', function() {
-    // Branch case
-    var leafResultsOne = new jasmine.NestedResults();
-    leafResultsOne.addResult(new jasmine.ExpectationResult({
-      matcherName: "toSomething", passed: true, message: 'message', actual: '', expected:''
-    }));
-
-    leafResultsOne.addResult(new jasmine.ExpectationResult({
-      matcherName: "toSomethingElse", passed: false, message: 'message', actual: 'a', expected: 'b'
-    }));
-
-    var leafResultsTwo = new jasmine.NestedResults();
-    leafResultsTwo.addResult(new jasmine.ExpectationResult({
-      matcherName: "toSomething", passed: true, message: 'message', actual: '', expected: ''
-    }));
-    leafResultsTwo.addResult(new jasmine.ExpectationResult({
-      matcherName: "toSomethineElse", passed: false, message: 'message', actual: 'c', expected: 'd'
-    }));
-
-    var branchResults = new jasmine.NestedResults();
-    branchResults.addResult(leafResultsOne);
-    branchResults.addResult(leafResultsTwo);
-
-    expect(branchResults.getItems().length).toEqual(2);
-    expect(branchResults.totalCount).toEqual(4);
-    expect(branchResults.passedCount).toEqual(2);
-    expect(branchResults.failedCount).toEqual(2);
-  });
-
-});

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

@@ -1,23 +0,0 @@
-describe("jasmine.Queue", function() {
-  it("should not call itself recursively, so we don't get stack overflow errors", function() {
-    var queue = new jasmine.Queue(new jasmine.Env());
-    queue.add(new jasmine.Block(null, function() {}));
-    queue.add(new jasmine.Block(null, function() {}));
-    queue.add(new jasmine.Block(null, function() {}));
-    queue.add(new jasmine.Block(null, function() {}));
-
-    var nestCount = 0;
-    var maxNestCount = 0;
-    var nextCallCount = 0;
-    queue.next_ = function() {
-      nestCount++;
-      if (nestCount > maxNestCount) maxNestCount = nestCount;
-
-      jasmine.Queue.prototype.next_.apply(queue, arguments);
-      nestCount--;
-    };
-
-    queue.start();
-    expect(maxNestCount).toEqual(1);
-  });
-});

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

@@ -1,56 +0,0 @@
-describe('jasmine.Reporter', function() {
-  var env;
-
-
-  beforeEach(function() {
-    env = new jasmine.Env();
-    env.updateInterval = 0;
-  });
-
-  it('should get called from the test runner', function() {
-    env.describe('Suite for JSON Reporter with Callbacks', function () {
-      env.it('should be a test', function() {
-        this.runs(function () {
-          this.expect(true).toEqual(true);
-        });
-      });
-      env.it('should be a failing test', function() {
-        this.runs(function () {
-          this.expect(false).toEqual(true);
-        });
-      });
-    });
-    env.describe('Suite for JSON Reporter with Callbacks 2', function () {
-      env.it('should be a test', function() {
-        this.runs(function () {
-          this.expect(true).toEqual(true);
-        });
-      });
-
-    });
-
-    var foo = 0;
-    var bar = 0;
-    var baz = 0;
-
-    env.addReporter({
-      reportSpecResults: function() {
-        foo++;
-      },
-      reportSuiteResults: function() {
-        bar++;
-      },
-      reportRunnerResults: function() {
-        baz++;
-      }
-    });
-
-    var runner = env.currentRunner();
-    runner.execute();
-
-    expect(foo).toEqual(3); // 'foo was expected to be 3, was ' + foo);
-    expect(bar).toEqual(2); // 'bar was expected to be 2, was ' + bar);
-    expect(baz).toEqual(1); // 'baz was expected to be 1, was ' + baz);
-  });
-
-});

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

@@ -1,280 +0,0 @@
-describe('RunnerTest', function() {
-  var fakeTimer;
-  var env;
-
-  beforeEach(function() {
-    env = new jasmine.Env();
-    env.updateInterval = 0;
-
-    fakeTimer = new jasmine.FakeTimer();
-    env.setTimeout = fakeTimer.setTimeout;
-    env.clearTimeout = fakeTimer.clearTimeout;
-    env.setInterval = fakeTimer.setInterval;
-    env.clearInterval = fakeTimer.clearInterval;
-  });
-
-  describe('beforeEach', function() {
-    it('should run before each spec for all suites', function () {
-      var foo;
-      env.beforeEach(function () {
-        foo = 0;
-      });
-
-      env.describe('suite 1', function () {
-        env.it('test 1-1', function() {
-          foo++;
-          this.expect(foo).toEqual(1);
-        });
-        env.it('test 1-2', function() {
-          foo++;
-          this.expect(foo).toEqual(1);
-        });
-      });
-
-      env.describe('suite 2', function () {
-        env.it('test 2-1', function() {
-          foo++;
-          this.expect(foo).toEqual(1);
-        });
-      });
-
-      env.currentRunner().execute();
-
-      var runnerResults = env.currentRunner().results();
-      expect(runnerResults.totalCount).toEqual(3);
-      expect(runnerResults.passedCount).toEqual(3);
-    });
-
-
-    it('should provide all specs', function () {
-      var foo;
-      env.beforeEach(function () {
-        foo = 0;
-      });
-
-      env.describe('suite 1', function () {
-        env.it('test 1-1', function() {
-          foo++;
-          this.expect(foo).toEqual(1);
-        });
-        env.it('test 1-2', function() {
-          foo++;
-          this.expect(foo).toEqual(1);
-        });
-      });
-
-      env.describe('suite 2', function () {
-        env.it('test 2-1', function() {
-          foo++;
-          this.expect(foo).toEqual(1);
-        });
-      });
-
-      env.currentRunner().execute();
-
-
-      expect(env.currentRunner().specs().length).toEqual(3);
-    });
-  });
-
-  describe('afterEach', function() {
-    it('should run after each spec for all suites', function () {
-      var foo = 3;
-      env.afterEach(function () {
-        foo = foo - 1;
-      });
-
-      env.describe('suite 1', function () {
-        env.it('test 1-1', function() {
-          this.expect(foo).toEqual(3);
-        });
-        env.it('test 1-2', function() {
-          this.expect(foo).toEqual(2);
-        });
-      });
-
-      env.describe('suite 2', function () {
-        env.it('test 2-1', function() {
-          this.expect(foo).toEqual(1);
-        });
-      });
-
-      env.currentRunner().execute();
-
-      var runnerResults = env.currentRunner().results();
-      expect(runnerResults.totalCount).toEqual(3);
-      expect(runnerResults.passedCount).toEqual(3);
-    });
-
-    it('should run after a failing spec', function () {
-      var afterEach = jasmine.createSpy();
-      env.afterEach(afterEach);
-
-      env.describe('suite', function () {
-        env.it('fails', function () {
-          this.explodes();
-        });
-      }).execute();
-
-      expect(afterEach).toHaveBeenCalled();
-    });
-  });
-
-
-  it('should run child suites and specs and generate results when execute is called', function() {
-    env.describe('one suite description', function () {
-      env.it('should be a test', function() {
-        this.runs(function () {
-          this.expect(true).toEqual(true);
-        });
-      });
-    });
-
-    env.describe('another suite description', function () {
-      env.it('should be another test', function() {
-        this.runs(function () {
-          this.expect(true).toEqual(false);
-        });
-      });
-    });
-
-    env.currentRunner().execute();
-
-    var runnerResults = env.currentRunner().results();
-    expect(runnerResults.totalCount).toEqual(2);
-    expect(runnerResults.passedCount).toEqual(1);
-    expect(runnerResults.failedCount).toEqual(1);
-  });
-
-
-  it('should ignore suites that have been x\'d', function() {
-    env.xdescribe('one suite description', function () {
-      env.it('should be a test', function() {
-        this.runs(function () {
-          this.expect(true).toEqual(true);
-        });
-      });
-    });
-
-    env.describe('another suite description', function () {
-      env.it('should be another test', function() {
-        this.runs(function () {
-          this.expect(true).toEqual(false);
-        });
-      });
-    });
-
-    env.currentRunner().execute();
-
-    var runnerResults = env.currentRunner().results();
-    expect(runnerResults.totalCount).toEqual(1);
-    expect(runnerResults.passedCount).toEqual(0);
-    expect(runnerResults.failedCount).toEqual(1);
-  });
-
-  it('should roll up results from all specs', function() {
-    env.describe('one suite description', function () {
-      env.it('should be a test', function() {
-        this.runs(function () {
-          this.expect(true).toEqual(true);
-        });
-      });
-    });
-
-    env.describe('another suite description', function () {
-      env.it('should be another test', function() {
-        this.runs(function () {
-          this.expect(true).toEqual(false);
-        });
-      });
-    });
-
-    env.currentRunner().execute();
-
-    var results = env.currentRunner().results();
-    expect(results.totalCount).toEqual(2);
-    expect(results.passedCount).toEqual(1);
-    expect(results.failedCount).toEqual(1);
-  });
-
-  describe('reporting', function () {
-    var fakeReporter;
-    beforeEach(function () {
-      fakeReporter = jasmine.createSpyObj("fakeReporter", ["log", "reportRunnerStarting", "reportRunnerResults"]);
-      env.addReporter(fakeReporter);
-    });
-
-    it('should report runner results when the runner has completed running', function() {
-      env.describe('one suite description', function () {
-        env.it('should be a test', function() {
-          this.runs(function () {
-            this.expect(true).toEqual(true);
-          });
-        });
-      });
-
-      env.describe('another suite description', function () {
-        env.it('should be another test', function() {
-          this.waits(200);
-          this.runs(function () {
-            this.expect(true).toEqual(false);
-          });
-        });
-      });
-
-      env.currentRunner().execute();
-      expect(fakeReporter.reportRunnerResults).not.toHaveBeenCalled();
-      fakeTimer.tick(200);
-      //This blows up the JSApiReporter.
-      //expect(fakeReporter.reportRunnerResults).toHaveBeenCalledWith(env.currentRunner);
-      expect(fakeReporter.reportRunnerResults).toHaveBeenCalled();
-      expect(fakeReporter.reportRunnerResults.mostRecentCall.args[0].results()).toEqual(env.currentRunner().results());
-    });
-  });
-
-  it("should report when the tests start running", function() {
-    var fakeReporter = jasmine.createSpyObj("fakeReporter", ["log", "reportRunnerStarting"]);
-    env.addReporter(fakeReporter);
-
-
-    var runner = new jasmine.Runner(env);
-    runner.arbitraryVariable = 'foo';
-    spyOn(runner.queue, 'start');
-    expect(fakeReporter.reportRunnerStarting).not.toHaveBeenCalled();
-    runner.execute();
-    expect(fakeReporter.reportRunnerStarting).toHaveBeenCalled();
-    var reportedRunner = fakeReporter.reportRunnerStarting.mostRecentCall.args[0];
-    expect(reportedRunner.arbitraryVariable).toEqual('foo');
-    expect(runner.queue.start).toHaveBeenCalled();
-  });
-
-  describe("when suites are nested", function() {
-    var suite1, suite2, suite3;
-
-    function suiteNames(suites) {
-      var suiteDescriptions = [];
-      for (var i = 0; i < suites.length; i++) {
-        suiteDescriptions.push(suites[i].getFullName());
-      }
-      return suiteDescriptions;
-    }
-
-    beforeEach(function() {
-      suite1 = env.describe("suite 1", function() {
-        suite2 = env.describe("suite 2", function() {
-        });
-      });
-      suite3 = env.describe("suite 3", function() {});
-    });
-
-    it("#suites should return a flat array of all suites, including nested suites", function() {
-      var suites = env.currentRunner().suites();
-      expect(suiteNames(suites)).toEqual([suite1.getFullName(), suite2.getFullName(), suite3.getFullName()]);
-    });
-
-    it("#topLevelSuites should return a flat array of all top-level suites only", function() {
-      var suites = env.currentRunner().topLevelSuites();
-      expect(suiteNames(suites)).toEqual([suite1.getFullName(), suite3.getFullName()]);
-    });
-  });
-});