discourse-ember-source 3.5.1.1 → 3.5.1.2

data/dist/es/ember-utils/tests/cache_test.js

@@ -1,77 +0,0 @@
-import { Cache } from '..';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'Cache',
-  class extends AbstractTestCase {
-    ['@test basic'](assert) {
-      let cache = new Cache(100, key => key.toUpperCase());
-
-      assert.equal(cache.get('foo'), 'FOO');
-      assert.equal(cache.get('bar'), 'BAR');
-      assert.equal(cache.get('foo'), 'FOO');
-    }
-
-    ['@test explicit sets'](assert) {
-      let cache = new Cache(100, key => key.toUpperCase());
-
-      assert.equal(cache.get('foo'), 'FOO');
-
-      assert.equal(cache.set('foo', 'FOO!!!'), 'FOO!!!');
-
-      assert.equal(cache.get('foo'), 'FOO!!!');
-
-      assert.strictEqual(cache.set('foo', undefined), undefined);
-
-      assert.strictEqual(cache.get('foo'), undefined);
-    }
-
-    ['@test caches computation correctly'](assert) {
-      let count = 0;
-      let cache = new Cache(100, key => {
-        count++;
-        return key.toUpperCase();
-      });
-
-      assert.equal(count, 0);
-      cache.get('foo');
-      assert.equal(count, 1);
-      cache.get('bar');
-      assert.equal(count, 2);
-      cache.get('bar');
-      assert.equal(count, 2);
-      cache.get('foo');
-      assert.equal(count, 2);
-    }
-
-    ['@test handles undefined value correctly'](assert) {
-      let count = 0;
-      let cache = new Cache(100, () => {
-        count++;
-      });
-
-      assert.equal(count, 0);
-      assert.strictEqual(cache.get('foo'), undefined);
-      assert.equal(count, 1);
-      assert.strictEqual(cache.get('bar'), undefined);
-      assert.equal(count, 2);
-      assert.strictEqual(cache.get('bar'), undefined);
-      assert.equal(count, 2);
-      assert.strictEqual(cache.get('foo'), undefined);
-      assert.equal(count, 2);
-    }
-
-    ['@test continues working after reaching cache limit'](assert) {
-      let cache = new Cache(3, key => key.toUpperCase());
-
-      cache.get('a');
-      cache.get('b');
-      cache.get('c');
-
-      assert.equal(cache.get('d'), 'D');
-      assert.equal(cache.get('a'), 'A');
-      assert.equal(cache.get('b'), 'B');
-      assert.equal(cache.get('c'), 'C');
-    }
-  }
-);

data/dist/es/ember-utils/tests/can_invoke_test.js

@@ -1,46 +0,0 @@
-import { canInvoke } from '..';
-import { moduleFor, AbstractTestCase as TestCase } from 'internal-test-helpers';
-
-let obj;
-
-moduleFor(
-  'Ember.canInvoke',
-  class extends TestCase {
-    constructor() {
-      super();
-
-      obj = {
-        foobar: 'foobar',
-        aMethodThatExists() {},
-      };
-    }
-
-    teardown() {
-      obj = undefined;
-    }
-
-    ["@test should return false if the object doesn't exist"](assert) {
-      assert.equal(canInvoke(undefined, 'aMethodThatDoesNotExist'), false);
-    }
-
-    ['@test should return true for falsy values that have methods'](assert) {
-      assert.equal(canInvoke(false, 'valueOf'), true);
-      assert.equal(canInvoke('', 'charAt'), true);
-      assert.equal(canInvoke(0, 'toFixed'), true);
-    }
-
-    ['@test should return true if the method exists on the object'](assert) {
-      assert.equal(canInvoke(obj, 'aMethodThatExists'), true);
-    }
-
-    ["@test should return false if the method doesn't exist on the object"](assert) {
-      assert.equal(canInvoke(obj, 'aMethodThatDoesNotExist'), false);
-    }
-
-    ['@test should return false if the property exists on the object but is a non-function'](
-      assert
-    ) {
-      assert.equal(canInvoke(obj, 'foobar'), false);
-    }
-  }
-);

data/dist/es/ember-utils/tests/checkHasSuper_test.js

@@ -1,17 +0,0 @@
-import { isChrome, isFirefox } from 'ember-browser-environment';
-import { checkHasSuper } from '..';
-import { moduleFor, AbstractTestCase as TestCase } from 'internal-test-helpers';
-
-// Only run this test on browsers that we are certain should have function
-// source available.  This allows the test suite to continue to pass on other
-// platforms that correctly (for them) fall back to the "always wrap" code.
-if (isChrome || isFirefox) {
-  moduleFor(
-    'checkHasSuper',
-    class extends TestCase {
-      ['@test does not super wrap needlessly [GH #12462]'](assert) {
-        assert.notOk(checkHasSuper(function() {}), 'empty function does not have super');
-      }
-    }
-  );
-}

data/dist/es/ember-utils/tests/generate_guid_test.js

@@ -1,13 +0,0 @@
-import { generateGuid } from '..';
-import { moduleFor, AbstractTestCase as TestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'Ember.generateGuid',
-  class extends TestCase {
-    ['@test Prefix'](assert) {
-      let a = {};
-
-      assert.ok(generateGuid(a, 'tyrell').indexOf('tyrell') > -1, 'guid can be prefixed');
-    }
-  }
-);

data/dist/es/ember-utils/tests/guid_for_test.js

@@ -1,101 +0,0 @@
-import { guidFor } from '..';
-import { moduleFor, AbstractTestCase as TestCase } from 'internal-test-helpers';
-
-function sameGuid(assert, a, b, message) {
-  assert.equal(guidFor(a), guidFor(b), message);
-}
-
-function diffGuid(assert, a, b, message) {
-  assert.ok(guidFor(a) !== guidFor(b), message);
-}
-
-function nanGuid(assert, obj) {
-  let type = typeof obj;
-  assert.ok(isNaN(parseInt(guidFor(obj), 0)), 'guids for ' + type + "don't parse to numbers");
-}
-
-moduleFor(
-  'guidFor',
-  class extends TestCase {
-    ['@test Object'](assert) {
-      let a = {};
-      let b = {};
-
-      sameGuid(assert, a, a, 'same object always yields same guid');
-      diffGuid(assert, a, b, 'different objects yield different guids');
-      nanGuid(assert, a);
-    }
-
-    ['@test strings'](assert) {
-      let a = 'string A';
-      let aprime = 'string A';
-      let b = 'String B';
-
-      sameGuid(assert, a, a, 'same string always yields same guid');
-      sameGuid(assert, a, aprime, 'identical strings always yield the same guid');
-      diffGuid(assert, a, b, 'different strings yield different guids');
-      nanGuid(assert, a);
-    }
-
-    ['@test numbers'](assert) {
-      let a = 23;
-      let aprime = 23;
-      let b = 34;
-
-      sameGuid(assert, a, a, 'same numbers always yields same guid');
-      sameGuid(assert, a, aprime, 'identical numbers always yield the same guid');
-      diffGuid(assert, a, b, 'different numbers yield different guids');
-      nanGuid(assert, a);
-    }
-
-    ['@test symbols'](assert) {
-      if (typeof Symbol === 'undefined') {
-        assert.ok(true, 'symbols are not supported on this browser');
-        return;
-      }
-
-      let a = Symbol('a');
-      let b = Symbol('b');
-
-      sameGuid(assert, a, a, 'same symbols always yields same guid');
-      diffGuid(assert, a, b, 'different symbols yield different guids');
-      nanGuid(assert, a);
-    }
-
-    ['@test booleans'](assert) {
-      let a = true;
-      let aprime = true;
-      let b = false;
-
-      sameGuid(assert, a, a, 'same booleans always yields same guid');
-      sameGuid(assert, a, aprime, 'identical booleans always yield the same guid');
-      diffGuid(assert, a, b, 'different boolean yield different guids');
-      nanGuid(assert, a);
-      nanGuid(assert, b);
-    }
-
-    ['@test null and undefined'](assert) {
-      let a = null;
-      let aprime = null;
-      let b;
-
-      sameGuid(assert, a, a, 'null always returns the same guid');
-      sameGuid(assert, b, b, 'undefined always returns the same guid');
-      sameGuid(assert, a, aprime, 'different nulls return the same guid');
-      diffGuid(assert, a, b, 'null and undefined return different guids');
-      nanGuid(assert, a);
-      nanGuid(assert, b);
-    }
-
-    ['@test arrays'](assert) {
-      let a = ['a', 'b', 'c'];
-      let aprime = ['a', 'b', 'c'];
-      let b = ['1', '2', '3'];
-
-      sameGuid(assert, a, a, 'same instance always yields same guid');
-      diffGuid(assert, a, aprime, 'identical arrays always yield the same guid');
-      diffGuid(assert, a, b, 'different arrays yield different guids');
-      nanGuid(assert, a);
-    }
-  }
-);

data/dist/es/ember-utils/tests/inspect_test.js

@@ -1,146 +0,0 @@
-import { HAS_NATIVE_SYMBOL, inspect } from '..';
-import { moduleFor, AbstractTestCase as TestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'Ember.inspect',
-  class extends TestCase {
-    ['@test strings'](assert) {
-      assert.equal(inspect('foo'), '"foo"');
-    }
-
-    ['@test numbers'](assert) {
-      assert.equal(inspect(2.6), '2.6');
-    }
-
-    ['@test null'](assert) {
-      assert.equal(inspect(null), 'null');
-    }
-
-    ['@test undefined'](assert) {
-      assert.equal(inspect(undefined), 'undefined');
-    }
-
-    ['@test true'](assert) {
-      assert.equal(inspect(true), 'true');
-    }
-
-    ['@test false'](assert) {
-      assert.equal(inspect(false), 'false');
-    }
-
-    ['@test object'](assert) {
-      assert.equal(inspect({}), '{ }');
-      assert.equal(inspect({ foo: 'bar' }), '{ foo: "bar" }');
-      let obj = {
-        foo() {
-          return this;
-        },
-      };
-      // IE 11 doesn't have function name
-      if (obj.foo.name) {
-        assert.equal(inspect(obj), `{ foo: [Function:foo] }`);
-      } else {
-        assert.equal(inspect(obj), `{ foo: [Function] }`);
-      }
-    }
-
-    ['@test objects without a prototype'](assert) {
-      let prototypelessObj = Object.create(null);
-      prototypelessObj.a = 1;
-      prototypelessObj.b = [Object.create(null)];
-      assert.equal(inspect({ foo: prototypelessObj }), '{ foo: { a: 1, b: [ { } ] } }');
-    }
-
-    ['@test array'](assert) {
-      assert.equal(inspect([1, 2, 3]), '[ 1, 2, 3 ]');
-    }
-
-    ['@test array list limit'](assert) {
-      let a = [];
-      for (let i = 0; i < 120; i++) {
-        a.push(1);
-      }
-      assert.equal(inspect(a), `[ ${a.slice(0, 100).join(', ')}, ... 20 more items ]`);
-    }
-
-    ['@test object list limit'](assert) {
-      let obj = {};
-      let pairs = [];
-      for (let i = 0; i < 120; i++) {
-        obj['key' + i] = i;
-        pairs.push(`key${i}: ${i}`);
-      }
-      assert.equal(inspect(obj), `{ ${pairs.slice(0, 100).join(', ')}, ... 20 more keys }`);
-    }
-
-    ['@test depth limit'](assert) {
-      assert.equal(
-        inspect([[[['here', { a: 1 }, [1]]]]]),
-        '[ [ [ [ "here", [Object], [Array] ] ] ] ]'
-      );
-    }
-
-    ['@test odd key'](assert) {
-      assert.equal(
-        inspect({
-          [`Hello world!
-How are you?`]: 1,
-        }),
-        '{ "Hello world!\\nHow are you?": 1 }'
-      );
-    }
-
-    ['@test node call'](assert) {
-      let obj = { a: 1 };
-      obj.inspect = inspect;
-      let depth = 2;
-      let options = {};
-      assert.equal(obj.inspect(depth, options), obj);
-    }
-
-    ['@test cycle'](assert) {
-      let obj = {};
-      obj.a = obj;
-      let arr = [obj];
-      arr.push(arr);
-      assert.equal(inspect(arr), '[ { a: [Circular] }, [Circular] ]');
-    }
-
-    ['@test custom toString'](assert) {
-      class Component {
-        static toString() {
-          return '@ember/component';
-        }
-
-        toString() {
-          return `<${this.constructor}:ember234>`;
-        }
-      }
-
-      assert.equal(
-        inspect([new Component(), Component]),
-        '[ <@ember/component:ember234>, @ember/component ]'
-      );
-    }
-
-    ['@test regexp'](assert) {
-      assert.equal(inspect(/regexp/), '/regexp/');
-    }
-
-    ['@test date'](assert) {
-      let inspected = inspect(new Date('Sat Apr 30 2011 13:24:11'));
-      assert.ok(inspected.match(/Sat Apr 30/), 'The inspected date has its date');
-      assert.ok(inspected.match(/2011/), 'The inspected date has its year');
-      assert.ok(inspected.match(/13:24:11/), 'The inspected date has its time');
-    }
-
-    ['@test inspect outputs the toString() representation of Symbols'](assert) {
-      if (HAS_NATIVE_SYMBOL) {
-        let symbol = Symbol('test');
-        assert.equal(inspect(symbol), 'Symbol(test)');
-      } else {
-        assert.expect(0);
-      }
-    }
-  }
-);

data/dist/es/ember-utils/tests/is_proxy_test.js

@@ -1,18 +0,0 @@
-import { isProxy, setProxy } from '..';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'ember-utils isProxy',
-  class extends AbstractTestCase {
-    ['@test basic'](assert) {
-      let proxy = {};
-      setProxy(proxy);
-
-      assert.equal(isProxy(proxy), true);
-
-      assert.equal(isProxy({}), false);
-      assert.equal(isProxy(undefined), false);
-      assert.equal(isProxy(null), false);
-    }
-  }
-);

data/dist/es/ember-utils/tests/make_array_test.js

@@ -1,41 +0,0 @@
-import { makeArray } from '..';
-import { moduleFor, AbstractTestCase as TestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'Ember.makeArray',
-  class extends TestCase {
-    ['@test undefined'](assert) {
-      assert.deepEqual(makeArray(), []);
-      assert.deepEqual(makeArray(undefined), []);
-    }
-
-    ['@test null'](assert) {
-      assert.deepEqual(makeArray(null), []);
-    }
-
-    ['@test string'](assert) {
-      assert.deepEqual(makeArray('lindsay'), ['lindsay']);
-    }
-
-    ['@test number'](assert) {
-      assert.deepEqual(makeArray(0), [0]);
-      assert.deepEqual(makeArray(1), [1]);
-    }
-
-    ['@test array'](assert) {
-      assert.deepEqual(makeArray([1, 2, 42]), [1, 2, 42]);
-    }
-
-    ['@test true'](assert) {
-      assert.deepEqual(makeArray(true), [true]);
-    }
-
-    ['@test false'](assert) {
-      assert.deepEqual(makeArray(false), [false]);
-    }
-
-    ['@test object'](assert) {
-      assert.deepEqual(makeArray({}), [{}]);
-    }
-  }
-);