// TODO: Fix these unit tests!
describe('Env', function() {
  var env;
  beforeEach(function() {
    env = new jasmineUnderTest.Env();
  });

  afterEach(function() {
    env.cleanup_();
  });

  describe('#pending', function() {
    it('throws the Pending Spec exception', function() {
      expect(function() {
        env.pending();
      }).toThrow(jasmineUnderTest.Spec.pendingSpecExceptionMessage);
    });

    it('throws the Pending Spec exception with a custom message', function() {
      expect(function() {
        env.pending('custom message');
      }).toThrow(
        jasmineUnderTest.Spec.pendingSpecExceptionMessage + 'custom message'
      );
    });
  });

  describe('#topSuite', function() {
    it('returns an object that describes the tree of suites and specs', function() {
      var suite;
      spyOn(env, 'deprecated');

      env.it('a top level spec');
      env.describe('a suite', function() {
        env.it('a spec');
        env.describe('a nested suite', function() {
          env.it('a nested spec');
        });
      });

      suite = env.topSuite();
      expect(suite.description).toEqual('Jasmine__TopLevel__Suite');
      expect(suite.getFullName()).toEqual('');
      expect(suite.children.length).toEqual(2);

      expect(suite.children[0].description).toEqual('a top level spec');
      expect(suite.children[0].getFullName()).toEqual('a top level spec');
      expect(suite.children[0].children).toBeFalsy();

      expect(suite.children[1].description).toEqual('a suite');
      expect(suite.children[1].getFullName()).toEqual('a suite');
      expect(suite.children[1].parentSuite).toBe(suite);
      expect(suite.children[1].children.length).toEqual(2);

      expect(suite.children[1].children[0].description).toEqual('a spec');
      expect(suite.children[1].children[0].getFullName()).toEqual(
        'a suite a spec'
      );
      expect(suite.children[1].children[0].children).toBeFalsy();

      expect(suite.children[1].children[1].description).toEqual(
        'a nested suite'
      );
      expect(suite.children[1].children[1].getFullName()).toEqual(
        'a suite a nested suite'
      );
      expect(suite.children[1].children[1].parentSuite).toBe(suite.children[1]);
      expect(suite.children[1].children[1].children.length).toEqual(1);

      expect(suite.children[1].children[1].children[0].description).toEqual(
        'a nested spec'
      );
      expect(suite.children[1].children[1].children[0].getFullName()).toEqual(
        'a suite a nested suite a nested spec'
      );
      expect(suite.children[1].children[1].children[0].children).toBeFalsy();
    });

    it('does not deprecate access to public Suite and Spec members', function() {
      jasmine.getEnv().requireProxy();
      var suite;
      spyOn(env, 'deprecated');

      env.it('a top level spec');
      env.describe('a suite', function() {
        env.it('a spec');
      });

      suite = env.topSuite();
      suite.id;
      suite.description;
      suite.getFullName();
      suite.children;
      suite.parentSuite;
      suite.children[0].id;
      suite.children[0].description;
      suite.children[0].getFullName();
      suite.children[0].children;

      suite.children[1].id;
      suite.children[1].description;
      suite.children[1].getFullName();
      suite.children[1].parentSuite;
      suite.children[1].children;

      expect(env.deprecated).not.toHaveBeenCalled();
    });

    it('deprecates access to internal Spec members via it(), fit(), and xit()', function() {
      jasmine.getEnv().requireProxy();
      spyOn(env, 'deprecated');

      ['it', 'fit', 'xit'].forEach(function(method) {
        var spec = env[method]('a spec', function() {});
        expect(env.deprecated).not.toHaveBeenCalled();

        spec.pend();
        expect(env.deprecated)
          .withContext('via ' + method)
          .toHaveBeenCalledWith(
            'Access to private Spec members (in this case `pend`) is not ' +
              'supported and will break in a future release. See ' +
              '<https://jasmine.github.io/api/edge/Spec.html> for correct usage.'
          );
        env.deprecated.calls.reset();

        spec.expectationFactory = {};
        expect(env.deprecated)
          .withContext('via ' + method)
          .toHaveBeenCalledWith(
            'Access to private Spec members (in this case `expectationFactory`) is not ' +
              'supported and will break in a future release. See ' +
              '<https://jasmine.github.io/api/edge/Spec.html> for correct usage.'
          );
        env.deprecated.calls.reset();

        spec.expectationFactory = {};
        expect(env.deprecated)
          .withContext('via ' + method)
          .toHaveBeenCalledWith(
            'Access to private Spec members (in this case `expectationFactory`) is not ' +
              'supported and will break in a future release. See ' +
              '<https://jasmine.github.io/api/edge/Spec.html> for correct usage.'
          );
        env.deprecated.calls.reset();
      });
    });

    it('deprecates access to internal Spec and Suite members via describe(), fdescribe(), and xdescribe()', function() {
      jasmine.getEnv().requireProxy();
      spyOn(env, 'deprecated');

      ['describe', 'fdescribe', 'xdescribe'].forEach(function(method) {
        var suite = env[method]('a suite', function() {
          env.it('a spec');
        });

        suite.expectationFactory;
        expect(env.deprecated)
          .withContext('via ' + method)
          .toHaveBeenCalledWith(
            'Access to private Suite ' +
              'members (in this case `expectationFactory`) is ' +
              'not supported and will break in a future release. See ' +
              '<https://jasmine.github.io/api/edge/Suite.html> for correct usage.'
          );
        env.deprecated.calls.reset();

        suite.expectationFactory = {};
        expect(env.deprecated)
          .withContext('via ' + method)
          .toHaveBeenCalledWith(
            'Access to private Suite ' +
              'members (in this case `expectationFactory`) is ' +
              'not supported and will break in a future release. See ' +
              '<https://jasmine.github.io/api/edge/Suite.html> for correct usage.'
          );
        env.deprecated.calls.reset();

        suite.status();
        expect(env.deprecated)
          .withContext('via ' + method)
          .toHaveBeenCalledWith(
            'Access to private Suite ' +
              'members (in this case `status`) is ' +
              'not supported and will break in a future release. See ' +
              '<https://jasmine.github.io/api/edge/Suite.html> for correct usage.'
          );
        env.deprecated.calls.reset();
      });
    });

    it('deprecates access to internal Suite and Spec members via topSuite', function() {
      jasmine.getEnv().requireProxy();
      var topSuite, expectationFactory, spec;

      env.it('a top level spec');
      spyOn(env, 'deprecated');
      topSuite = env.topSuite();

      topSuite.expectationFactory;
      expect(env.deprecated).toHaveBeenCalledWith(
        'Access to private Suite ' +
          'members (in this case `expectationFactory`) is ' +
          'not supported and will break in a future release. See ' +
          '<https://jasmine.github.io/api/edge/Suite.html> for correct usage.'
      );
      env.deprecated.calls.reset();

      topSuite.expectationFactory = expectationFactory;
      expect(env.deprecated).toHaveBeenCalledWith(
        'Access to private Suite ' +
          'members (in this case `expectationFactory`) is ' +
          'not supported and will break in a future release. See ' +
          '<https://jasmine.github.io/api/edge/Suite.html> for correct usage.'
      );

      topSuite.status();
      expect(env.deprecated).toHaveBeenCalledWith(
        'Access to private Suite ' +
          'members (in this case `status`) is ' +
          'not supported and will break in a future release. See ' +
          '<https://jasmine.github.io/api/edge/Suite.html> for correct usage.'
      );

      spec = topSuite.children[0];
      spec.pend();
      expect(env.deprecated).toHaveBeenCalledWith(
        'Access to private Spec ' +
          'members (in this case `pend`) ' +
          'is not supported and will break in a future release. See ' +
          '<https://jasmine.github.io/api/edge/Spec.html> for correct usage.'
      );

      expectationFactory = spec.expectationFactory;
      expect(env.deprecated).toHaveBeenCalledWith(
        'Access to private Spec ' +
          'members (in this case `expectationFactory`) ' +
          'is not supported and will break in a future release. See ' +
          '<https://jasmine.github.io/api/edge/Spec.html> for correct usage.'
      );
      env.deprecated.calls.reset();

      spec.expectationFactory = expectationFactory;
      expect(env.deprecated).toHaveBeenCalledWith(
        'Access to private Spec ' +
          'members (in this case `expectationFactory`) ' +
          'is not supported and will break in a future release. See ' +
          '<https://jasmine.github.io/api/edge/Spec.html> for correct usage.'
      );
    });
  });

  it('accepts its own current configureation', function() {
    env.configure(env.configuration());
  });

  it('can configure specs to throw errors on expectation failures', function() {
    env.configure({ stopSpecOnExpectationFailure: true });

    spyOn(jasmineUnderTest, 'Spec');
    env.it('foo', function() {});
    expect(jasmineUnderTest.Spec).toHaveBeenCalledWith(
      jasmine.objectContaining({
        throwOnExpectationFailure: true
      })
    );
  });

  it('can configure suites to throw errors on expectation failures', function() {
    env.configure({ stopSpecOnExpectationFailure: true });

    spyOn(jasmineUnderTest, 'Suite');
    env.describe('foo', function() {});
    expect(jasmineUnderTest.Suite).toHaveBeenCalledWith(
      jasmine.objectContaining({
        throwOnExpectationFailure: true
      })
    );
  });

  it('ignores configuration properties that are present but undefined', function() {
    spyOn(env, 'deprecated');
    var initialConfig = {
      random: true,
      seed: '123',
      failFast: true,
      failSpecWithNoExpectations: true,
      oneFailurePerSpec: true,
      stopSpecOnExpectationFailure: true,
      stopOnSpecFailure: true,
      hideDisabled: true
    };
    env.configure(initialConfig);

    env.configure({
      random: undefined,
      seed: undefined,
      failFast: undefined,
      failSpecWithNoExpectations: undefined,
      oneFailurePerSpec: undefined,
      stopSpecOnExpectationFailure: undefined,
      stopOnSpecFailure: undefined,
      hideDisabled: undefined
    });

    expect(env.configuration()).toEqual(
      jasmine.objectContaining(initialConfig)
    );
  });

  it('sets stopOnSpecFailure when failFast is set, and vice versa', function() {
    spyOn(env, 'deprecated');
    env.configure({ failFast: true });
    expect(env.configuration()).toEqual(
      jasmine.objectContaining({
        failFast: true,
        stopOnSpecFailure: true
      })
    );

    env.configure({ stopOnSpecFailure: false });
    expect(env.configuration()).toEqual(
      jasmine.objectContaining({
        failFast: false,
        stopOnSpecFailure: false
      })
    );
  });

  it('rejects a single call that sets stopOnSpecFailure and failFast to different values', function() {
    spyOn(env, 'deprecated');
    expect(function() {
      env.configure({ failFast: true, stopOnSpecFailure: false });
    }).toThrowError(
      'stopOnSpecFailure and failFast are aliases for each ' +
        "other. Don't set failFast if you also set stopOnSpecFailure."
    );
  });

  it('deprecates the failFast config property', function() {
    spyOn(env, 'deprecated');
    env.configure({ failFast: true });
    expect(env.deprecated).toHaveBeenCalledWith(
      'The `failFast` config property is deprecated and will be removed in a ' +
        'future version of Jasmine. Please use `stopOnSpecFailure` instead.',
      { ignoreRunnable: true }
    );
  });

  it('sets stopSpecOnExpectationFailure when oneFailurePerSpec is set, and vice versa', function() {
    spyOn(env, 'deprecated');
    env.configure({ oneFailurePerSpec: true });
    expect(env.configuration()).toEqual(
      jasmine.objectContaining({
        oneFailurePerSpec: true,
        stopSpecOnExpectationFailure: true
      })
    );

    env.configure({ stopSpecOnExpectationFailure: false });
    expect(env.configuration()).toEqual(
      jasmine.objectContaining({
        oneFailurePerSpec: false,
        stopSpecOnExpectationFailure: false
      })
    );
  });

  it('rejects a single call that sets stopSpecOnExpectationFailure and oneFailurePerSpec to different values', function() {
    spyOn(env, 'deprecated');
    expect(function() {
      env.configure({
        oneFailurePerSpec: true,
        stopSpecOnExpectationFailure: false
      });
    }).toThrowError(
      'stopSpecOnExpectationFailure and oneFailurePerSpec are ' +
        "aliases for each other. Don't set oneFailurePerSpec if you also set " +
        'stopSpecOnExpectationFailure.'
    );
  });

  it('deprecates the oneFailurePerSpec config property', function() {
    spyOn(env, 'deprecated');
    env.configure({ oneFailurePerSpec: true });
    expect(env.deprecated).toHaveBeenCalledWith(
      'The `oneFailurePerSpec` config property is deprecated and will be ' +
        'removed in a future version of Jasmine. Please use ' +
        '`stopSpecOnExpectationFailure` instead.',
      { ignoreRunnable: true }
    );
  });

  describe('promise library', function() {
    it('can be configured without a custom library', function() {
      env.configure({});
      env.configure({ Promise: undefined });
    });

    it('can be configured with a custom library', function() {
      spyOn(env, 'deprecated');
      var myLibrary = {
        resolve: jasmine.createSpy(),
        reject: jasmine.createSpy()
      };
      env.configure({ Promise: myLibrary });
      expect(env.deprecated).toHaveBeenCalledWith(
        'The `Promise` config property is deprecated. Future versions of ' +
          'Jasmine will create native promises even if the `Promise` config ' +
          'property is set. Please remove it.'
      );
    });

    it('cannot be configured with an invalid promise library', function() {
      var myLibrary = {};

      expect(function() {
        env.configure({ Promise: myLibrary });
      }).toThrowError(
        'Custom promise library missing `resolve`/`reject` functions'
      );
    });
  });

  it('defaults to multiple failures for specs', function() {
    spyOn(jasmineUnderTest, 'Spec');
    env.it('bar', function() {});
    expect(jasmineUnderTest.Spec).toHaveBeenCalledWith(
      jasmine.objectContaining({
        throwOnExpectationFailure: false
      })
    );
  });

  it('defaults to multiple failures for suites', function() {
    spyOn(jasmineUnderTest, 'Suite');
    env.describe('foo', function() {});
    expect(jasmineUnderTest.Suite).toHaveBeenCalledWith(
      jasmine.objectContaining({
        throwOnExpectationFailure: false
      })
    );
  });

  describe('#describe', function() {
    it('throws an error when given arguments', function() {
      expect(function() {
        env.describe('done method', function(done) {});
      }).toThrowError('describe does not expect any arguments');
    });

    it('throws an error when it receives a non-fn argument', function() {
      // Some versions of PhantomJS return [object DOMWindow] when
      // Object.prototype.toString.apply is called with `undefined` or `null`.
      // In a similar fashion, IE8 gives [object Object] for both `undefined`
      // and `null`. We mostly just want these tests to check that using
      // anything other than a function throws an error.
      expect(function() {
        env.describe('undefined arg', undefined);
      }).toThrowError(
        /describe expects a function argument; received \[object (Undefined|DOMWindow|Object)\]/
      );
      expect(function() {
        env.describe('null arg', null);
      }).toThrowError(
        /describe expects a function argument; received \[object (Null|DOMWindow|Object)\]/
      );

      expect(function() {
        env.describe('array arg', []);
      }).toThrowError(
        'describe expects a function argument; received [object Array]'
      );
      expect(function() {
        env.describe('object arg', {});
      }).toThrowError(
        'describe expects a function argument; received [object Object]'
      );

      expect(function() {
        env.describe('fn arg', function() {
          env.it('has a spec', function() {});
        });
      }).not.toThrowError(
        'describe expects a function argument; received [object Function]'
      );
    });

    it('logs a deprecation when it has no children', function() {
      spyOn(env, 'deprecated');
      env.describe('no children', function() {});
      expect(env.deprecated).toHaveBeenCalledWith(
        'describe with no children' +
          ' (describe() or it()) is deprecated and will be removed in a future ' +
          'version of Jasmine. Please either remove the describe or add ' +
          'children to it.'
      );
    });
  });

  describe('#it', function() {
    it('throws an error when it receives a non-fn argument', function() {
      expect(function() {
        env.it('undefined arg', null);
      }).toThrowError(
        /it expects a function argument; received \[object (Null|DOMWindow|Object)\]/
      );
    });

    it('does not throw when it is not given a fn argument', function() {
      expect(function() {
        env.it('pending spec');
      }).not.toThrow();
    });

    it('accepts an async function', function() {
      jasmine.getEnv().requireAsyncAwait();
      expect(function() {
        env.it('async', jasmine.getEnv().makeAsyncAwaitFunction());
      }).not.toThrow();
    });

    it('throws an error when the timeout value is too large for setTimeout', function() {
      expect(function() {
        env.it('huge timeout', function() {}, 2147483648);
      }).toThrowError('Timeout value cannot be greater than 2147483647');
    });
  });

  describe('#xit', function() {
    it('calls spec.exclude with "Temporarily disabled with xit"', function() {
      var excludeSpy = jasmine.createSpy();
      spyOn(env, 'it_').and.returnValue({
        exclude: excludeSpy
      });
      env.xit('foo', function() {});
      expect(excludeSpy).toHaveBeenCalledWith('Temporarily disabled with xit');
    });

    it('throws an error when it receives a non-fn argument', function() {
      expect(function() {
        env.xit('undefined arg', null);
      }).toThrowError(
        /xit expects a function argument; received \[object (Null|DOMWindow|Object)\]/
      );
    });

    it('does not throw when it is not given a fn argument', function() {
      expect(function() {
        env.xit('pending spec');
      }).not.toThrow();
    });

    it('accepts an async function', function() {
      jasmine.getEnv().requireAsyncAwait();
      expect(function() {
        env.xit('async', jasmine.getEnv().makeAsyncAwaitFunction());
      }).not.toThrow();
    });
  });

  describe('#fit', function() {
    it('throws an error when it receives a non-fn argument', function() {
      expect(function() {
        env.fit('undefined arg', undefined);
      }).toThrowError(
        /fit expects a function argument; received \[object (Undefined|DOMWindow|Object)\]/
      );
    });

    it('throws an error when the timeout value is too large for setTimeout', function() {
      expect(function() {
        env.fit('huge timeout', function() {}, 2147483648);
      }).toThrowError('Timeout value cannot be greater than 2147483647');
    });
  });

  describe('#beforeEach', function() {
    it('throws an error when it receives a non-fn argument', function() {
      expect(function() {
        env.beforeEach(undefined);
      }).toThrowError(
        /beforeEach expects a function argument; received \[object (Undefined|DOMWindow|Object)\]/
      );
    });

    it('accepts an async function', function() {
      jasmine.getEnv().requireAsyncAwait();
      expect(function() {
        env.beforeEach(jasmine.getEnv().makeAsyncAwaitFunction());
      }).not.toThrow();
    });

    it('throws an error when the timeout value is too large for setTimeout', function() {
      expect(function() {
        env.beforeEach(function() {}, 2147483648);
      }).toThrowError('Timeout value cannot be greater than 2147483647');
    });
  });

  describe('#beforeAll', function() {
    it('throws an error when it receives a non-fn argument', function() {
      expect(function() {
        env.beforeAll(undefined);
      }).toThrowError(
        /beforeAll expects a function argument; received \[object (Undefined|DOMWindow|Object)\]/
      );
    });

    it('accepts an async function', function() {
      jasmine.getEnv().requireAsyncAwait();
      expect(function() {
        env.beforeAll(jasmine.getEnv().makeAsyncAwaitFunction());
      }).not.toThrow();
    });

    it('throws an error when the timeout value is too large for setTimeout', function() {
      expect(function() {
        env.beforeAll(function() {}, 2147483648);
      }).toThrowError('Timeout value cannot be greater than 2147483647');
    });
  });

  describe('#afterEach', function() {
    it('throws an error when it receives a non-fn argument', function() {
      expect(function() {
        env.afterEach(undefined);
      }).toThrowError(
        /afterEach expects a function argument; received \[object (Undefined|DOMWindow|Object)\]/
      );
    });

    it('accepts an async function', function() {
      jasmine.getEnv().requireAsyncAwait();
      expect(function() {
        env.afterEach(jasmine.getEnv().makeAsyncAwaitFunction());
      }).not.toThrow();
    });

    it('throws an error when the timeout value is too large for setTimeout', function() {
      expect(function() {
        env.afterEach(function() {}, 2147483648);
      }).toThrowError('Timeout value cannot be greater than 2147483647');
    });
  });

  describe('#afterAll', function() {
    it('throws an error when it receives a non-fn argument', function() {
      expect(function() {
        env.afterAll(undefined);
      }).toThrowError(
        /afterAll expects a function argument; received \[object (Undefined|DOMWindow|Object)\]/
      );
    });

    it('accepts an async function', function() {
      jasmine.getEnv().requireAsyncAwait();
      expect(function() {
        env.afterAll(jasmine.getEnv().makeAsyncAwaitFunction());
      }).not.toThrow();
    });

    it('throws an error when the timeout value is too large for setTimeout', function() {
      expect(function() {
        env.afterAll(function() {}, 2147483648);
      }).toThrowError('Timeout value cannot be greater than 2147483647');
    });
  });

  describe('when not constructed with suppressLoadErrors: true', function() {
    it('installs a global error handler on construction', function() {
      var globalErrors = jasmine.createSpyObj('globalErrors', [
        'install',
        'uninstall',
        'pushListener',
        'popListener'
      ]);
      spyOn(jasmineUnderTest, 'GlobalErrors').and.returnValue(globalErrors);
      env.cleanup_();
      env = new jasmineUnderTest.Env();
      expect(globalErrors.install).toHaveBeenCalled();
    });
  });

  describe('when constructed with suppressLoadErrors: true', function() {
    it('does not install a global error handler until execute is called', function() {
      var globalErrors = jasmine.createSpyObj('globalErrors', [
        'install',
        'uninstall',
        'pushListener',
        'popListener'
      ]);
      spyOn(jasmineUnderTest, 'GlobalErrors').and.returnValue(globalErrors);
      env.cleanup_();
      env = new jasmineUnderTest.Env({ suppressLoadErrors: true });
      expect(globalErrors.install).not.toHaveBeenCalled();
      env.execute();
      expect(globalErrors.install).toHaveBeenCalled();
    });
  });

  it('creates an expectationFactory that uses the current custom equality testers and object formatters', function(done) {
    function customEqualityTester() {}
    function customObjectFormatter() {}
    function prettyPrinter() {}
    var RealSpec = jasmineUnderTest.Spec,
      specInstance,
      expectationFactory;
    spyOn(jasmineUnderTest, 'MatchersUtil');
    spyOn(jasmineUnderTest, 'makePrettyPrinter').and.returnValue(prettyPrinter);
    spyOn(jasmineUnderTest, 'Spec').and.callFake(function(options) {
      expectationFactory = options.expectationFactory;
      specInstance = new RealSpec(options);
      return specInstance;
    });

    env.it('spec', function() {
      env.addCustomEqualityTester(customEqualityTester);
      env.addCustomObjectFormatter(customObjectFormatter);
      expectationFactory('actual', specInstance);
    });

    env.execute(null, function() {
      expect(jasmineUnderTest.makePrettyPrinter).toHaveBeenCalledWith([
        customObjectFormatter
      ]);
      expect(jasmineUnderTest.MatchersUtil).toHaveBeenCalledWith({
        customTesters: [customEqualityTester],
        pp: prettyPrinter
      });
      done();
    });
  });

  it('creates an asyncExpectationFactory that uses the current custom equality testers and object formatters', function(done) {
    function customEqualityTester() {}
    function customObjectFormatter() {}
    function prettyPrinter() {}
    var RealSpec = jasmineUnderTest.Spec,
      specInstance,
      asyncExpectationFactory;
    spyOn(jasmineUnderTest, 'MatchersUtil');
    spyOn(jasmineUnderTest, 'makePrettyPrinter').and.returnValue(prettyPrinter);
    spyOn(jasmineUnderTest, 'Spec').and.callFake(function(options) {
      asyncExpectationFactory = options.asyncExpectationFactory;
      specInstance = new RealSpec(options);
      return specInstance;
    });

    env.it('spec', function() {
      env.addCustomEqualityTester(customEqualityTester);
      env.addCustomObjectFormatter(customObjectFormatter);
      asyncExpectationFactory('actual', specInstance);
    });

    env.execute(null, function() {
      expect(jasmineUnderTest.makePrettyPrinter).toHaveBeenCalledWith([
        customObjectFormatter
      ]);
      expect(jasmineUnderTest.MatchersUtil).toHaveBeenCalledWith({
        customTesters: [customEqualityTester],
        pp: prettyPrinter
      });
      done();
    });
  });

  it("deprecates access to 'this' in describes", function() {
    jasmine.getEnv().requireProxy();
    var msg =
        "Access to 'this' in describe functions (and in arrow " +
        'functions inside describe functions) is deprecated.',
      ran = false;
    spyOn(env, 'deprecated');

    env.describe('a suite', function() {
      expect(this.description).toEqual('a suite');
      expect(env.deprecated).toHaveBeenCalledWith(msg);
      env.deprecated.calls.reset();

      this.foo = 1;
      expect(env.deprecated).toHaveBeenCalledWith(msg);
      expect(this.foo).toEqual(1);
      env.deprecated.calls.reset();

      expect(this.getFullName()).toEqual('a suite');
      expect(env.deprecated).toHaveBeenCalledWith(msg);
      env.deprecated.calls.reset();

      env.it('has a spec');
      ran = true;
    });

    expect(ran).toBeTrue();
  });

  // TODO: Remove this in the next major version. Suites were never meant to be
  // exposed via describe 'this' in >= 2.0, and user code should not rely on it.
  // This spec is just here to make sure we don't break user code that *does*
  // rely on it in older browsers (without Proxy) while deprecating it.
  it("sets 'this' to the Suite in describes", function() {
    var suiteThis;
    spyOn(env, 'deprecated');

    env.describe('a suite', function() {
      suiteThis = this;
      env.it('has a spec');
    });

    expect(suiteThis).toBeInstanceOf(jasmineUnderTest.Suite);
  });

  describe('#execute', function() {
    it('returns a promise when the environment supports promises', function() {
      jasmine.getEnv().requirePromises();
      expect(env.execute()).toBeInstanceOf(Promise);
    });

    it('returns a promise when a custom promise constructor is provided', function() {
      function CustomPromise() {}
      CustomPromise.resolve = function() {};
      CustomPromise.reject = function() {};

      spyOn(env, 'deprecated');
      env.configure({ Promise: CustomPromise });
      expect(env.execute()).toBeInstanceOf(CustomPromise);
    });

    it('returns undefined when promises are unavailable', function() {
      jasmine.getEnv().requireNoPromises();
      expect(env.execute()).toBeUndefined();
    });

    it('should reset the topSuite when run twice', function() {
      jasmine.getEnv().requirePromises();
      spyOn(jasmineUnderTest.Suite.prototype, 'reset');
      return env
        .execute() // 1
        .then(function() {
          return env.execute(); // 2
        })
        .then(function() {
          var id;
          expect(
            jasmineUnderTest.Suite.prototype.reset
          ).toHaveBeenCalledOnceWith();
          id = jasmineUnderTest.Suite.prototype.reset.calls.thisFor(0).id;
          expect(id).toBeTruthy();
          expect(id).toEqual(env.topSuite().id);
        });
    });
  });
});