How to use

values

function

in

Array

// 用来给字体指定唯一标识
// 字体的 ID 根据 font-family 以及其他 font-* 属性来生成
// @see https://github.com/aui/font-spider/issues/32
function getFontId (name, options) {

  var values = getFontId.keys.map(function (key, index) {

    var value = options[key] || getFontId.values[index];

    if (typeof value !== 'string') {
      value = getFontId.values[index];
    } else if (getFontId.alias[key]) {
      value = value.replace.apply(value, getFontId.alias[key]);
    }

    return value;
  });

  values.unshift(name);

  var id = values.join('-');
  id = crypto.createHash('md5').update(id).digest('hex');

  return id;
}

it('returns a next-able object', function () {
  var array = ['val1', 'val2'];
  var iterator = array.values();

  proclaim.isInstanceOf(iterator.next, Function);
  proclaim.deepEqual(iterator.next(), {
    value: 'val1',
    done: false
  });
});

/**
   * @see Array#values
   * @returns {Iterator.<T>}
   */
  values(){
    return this._items.values();
  }

describe('DependencyTag', () => {
      it('discriminate tags', () => {
        let values = DependencyTag.values();
        let codes = values.map((c) => c.tagname);

        _.range(100).forEach(() => {
          let filtered = codes.filter(() => _.random(0, 1) == 1);
          for (const tag of values) {
            expect(Util.contains(filtered, tag)).toBe(filtered.includes(tag.tagname));
          }
        });

        for (const code of codes) {
          expect(DependencyTag.withName(code)).toBe(DependencyTag[code]);
        }
      });
    });

/* globals proclaim, Symbol */

it('is an alias to Array.prototype.values', function () {
  proclaim.deepEqual(Array.prototype[Symbol.iterator], Array.prototype.values);
});

/**
  * @param {Uint8Array[]} chunks
  */
 constructor(chunks) {
  // @ts-ignore
  super(new BlobStreamController(chunks.values()), {type: 'bytes'});
  /** @private */
  this._chunks = chunks;
 }

expect(
    POS.values().every((tag) => jsmorph.hasTag(tag.tagname) === jsmorph.reference.hasTag(tag.tagname))
  ).toBe(true);

it('has correct name', function () {
  try {
    proclaim.hasName(Array.prototype.values, 'values');
  } catch (e) {
    // Chrome 40 implements the Symbol.iterator function for Arrays but has it named ArrayValues.
    try {
      proclaim.equal([].values.name, 'ArrayValues');
    } catch (er) {
      // Firefox 44 has it named [Symbol.iterator].
      proclaim.equal([].values.name, '[Symbol.iterator]');
    }
  }
});

/**
   * Iterator
   */
  [Symbol.iterator]() {
    return this._values.values();
  }

/* globals proclaim */

it('is a function', function () {
  proclaim.isFunction(Array.prototype.values);
});

columns() {
    return Column.values;
  }

[Symbol.iterator]() {
  return this._tokens.values();
 }

it('has correct arity', function () {
  proclaim.arity(Array.prototype.values, 0);
});

it('finally returns a done object', function () {
  var array = ['val1', 'val2'];
  var iterator = array.values();
  iterator.next();
  iterator.next();
  proclaim.deepEqual(iterator.next(), {
    value: undefined,
    done: true
  });
});

describe('CoarseEntityType', () => {
      it('discriminate tags', () => {
        let values = CoarseEntityType.values();
        let codes = values.map((c) => c.tagname);

        _.range(100).forEach(() => {
          let filtered = codes.filter(() => _.random(0, 1) == 1);
          for (const tag of values) {
            expect(Util.contains(filtered, tag)).toBe(filtered.includes(tag.tagname));
          }
        });

        for (const code of codes) {
          expect(CoarseEntityType.withName(code)).toBe(CoarseEntityType[code]);
        }
      });
    });