openlayers/test/spec/ol/parser/polyline.test.js

goog.provide('ol.test.parser.polyline');

describe('ol.parser.polyline', function() {

  var flat_points = [38.50000, -120.20000,
                     40.70000, -120.95000,
                     43.25200, -126.45300];

  describe('encodeFlatCoordinates', function() {
    it('returns expected value', function() {
      var encodeFlatCoordinates = ol.parser.polyline.encodeFlatCoordinates;

      // from the "Encoded Polyline Algorithm Format" page at Google
      expect(encodeFlatCoordinates(
          flat_points)).toEqual('_p~iF~ps|U_ulLnnqC_mqNvxq`@');
    });
  });

  describe('decodeFlatCoordinates', function() {
    it('returns expected value', function() {
      var decodeFlatCoordinates = ol.parser.polyline.decodeFlatCoordinates;

      // from the "Encoded Polyline Algorithm Format" page at Google
      expect(decodeFlatCoordinates(
          '_p~iF~ps|U_ulLnnqC_mqNvxq`@')).toEqual(flat_points);
    });
  });

  describe('encodeFloat', function() {
    it('returns expected value', function() {
      var encodeFloat = ol.parser.polyline.encodeFloat;

      expect(encodeFloat(0.00000)).toEqual('?');
      expect(encodeFloat(-0.00001)).toEqual('@');
      expect(encodeFloat(0.00001)).toEqual('A');
      expect(encodeFloat(-0.00002)).toEqual('B');
      expect(encodeFloat(0.00002)).toEqual('C');
      expect(encodeFloat(0.00015)).toEqual(']');
      expect(encodeFloat(-0.00016)).toEqual('^');

      expect(encodeFloat(-0.1, 10)).toEqual('@');
      expect(encodeFloat(0.1, 10)).toEqual('A');

      expect(encodeFloat(16 * 32 / 1e5)).toEqual('__@');
      expect(encodeFloat(16 * 32 * 32 / 1e5)).toEqual('___@');

      // from the "Encoded Polyline Algorithm Format" page at Google
      expect(encodeFloat(-179.9832104)).toEqual('`~oia@');
    });
  });

  describe('decodeFloat', function() {
    it('returns expected value', function() {
      var decodeFloat = ol.parser.polyline.decodeFloat;

      expect(decodeFloat('?')).toEqual(0.00000);
      expect(decodeFloat('@')).toEqual(-0.00001);
      expect(decodeFloat('A')).toEqual(0.00001);
      expect(decodeFloat('B')).toEqual(-0.00002);
      expect(decodeFloat('C')).toEqual(0.00002);
      expect(decodeFloat(']')).toEqual(0.00015);
      expect(decodeFloat('^')).toEqual(-0.00016);

      expect(decodeFloat('@', 10)).toEqual(-0.1);
      expect(decodeFloat('A', 10)).toEqual(0.1);

      expect(decodeFloat('__@')).toEqual(16 * 32 / 1e5);
      expect(decodeFloat('___@')).toEqual(16 * 32 * 32 / 1e5);

      // from the "Encoded Polyline Algorithm Format" page at Google
      expect(decodeFloat('`~oia@')).toEqual(-179.98321);
    });
  });

  describe('encodeSignedInteger', function() {
    it('returns expected value', function() {
      var encodeSignedInteger = ol.parser.polyline.encodeSignedInteger;

      expect(encodeSignedInteger(0)).toEqual('?');
      expect(encodeSignedInteger(-1)).toEqual('@');
      expect(encodeSignedInteger(1)).toEqual('A');
      expect(encodeSignedInteger(-2)).toEqual('B');
      expect(encodeSignedInteger(2)).toEqual('C');
      expect(encodeSignedInteger(15)).toEqual(']');
      expect(encodeSignedInteger(-16)).toEqual('^');

      expect(encodeSignedInteger(16)).toEqual('_@');
      expect(encodeSignedInteger(16 * 32)).toEqual('__@');
      expect(encodeSignedInteger(16 * 32 * 32)).toEqual('___@');
    });
  });

  describe('decodeSignedInteger', function() {
    it('returns expected value', function() {
      var decodeSignedInteger = ol.parser.polyline.decodeSignedInteger;

      expect(decodeSignedInteger('?')).toEqual(0);
      expect(decodeSignedInteger('@')).toEqual(-1);
      expect(decodeSignedInteger('A')).toEqual(1);
      expect(decodeSignedInteger('B')).toEqual(-2);
      expect(decodeSignedInteger('C')).toEqual(2);
      expect(decodeSignedInteger(']')).toEqual(15);
      expect(decodeSignedInteger('^')).toEqual(-16);

      expect(decodeSignedInteger('_@')).toEqual(16);
      expect(decodeSignedInteger('__@')).toEqual(16 * 32);
      expect(decodeSignedInteger('___@')).toEqual(16 * 32 * 32);
    });
  });

  describe('encodeUnsignedInteger', function() {
    it('returns expected value', function() {
      var encodeUnsignedInteger = ol.parser.polyline.encodeUnsignedInteger;

      expect(encodeUnsignedInteger(0)).toEqual('?');
      expect(encodeUnsignedInteger(1)).toEqual('@');
      expect(encodeUnsignedInteger(2)).toEqual('A');
      expect(encodeUnsignedInteger(30)).toEqual(']');
      expect(encodeUnsignedInteger(31)).toEqual('^');
      expect(encodeUnsignedInteger(32)).toEqual('_@');

      expect(encodeUnsignedInteger(32 * 32)).toEqual('__@');
      expect(encodeUnsignedInteger(5 * 32 * 32)).toEqual('__D');
      expect(encodeUnsignedInteger(32 * 32 * 32)).toEqual('___@');
    });
  });

  describe('decodeUnsignedInteger', function() {
    it('returns expected value', function() {
      var decodeUnsignedInteger = ol.parser.polyline.decodeUnsignedInteger;

      expect(decodeUnsignedInteger('?')).toEqual(0);
      expect(decodeUnsignedInteger('@')).toEqual(1);
      expect(decodeUnsignedInteger('A')).toEqual(2);
      expect(decodeUnsignedInteger(']')).toEqual(30);
      expect(decodeUnsignedInteger('^')).toEqual(31);
      expect(decodeUnsignedInteger('_@')).toEqual(32);

      expect(decodeUnsignedInteger('__@')).toEqual(32 * 32);
      expect(decodeUnsignedInteger('__D')).toEqual(5 * 32 * 32);
      expect(decodeUnsignedInteger('___@')).toEqual(32 * 32 * 32);
    });
  });
});

goog.require('ol.parser.polyline');