@wemap/geo 1.0.4 → 2.7.0

package/src/coordinates/WGS84.spec.js

@@ -0,0 +1,268 @@
+import chai from 'chai';
+import chaiAlmost from 'chai-almost';
+
+import WGS84 from './WGS84';
+import Level from './Level';
+import Constants from '../Constants';
+
+const expect = chai.expect;
+chai.use(chaiAlmost());
+
+describe('WGS84', () => {
+
+    it('creation', () => {
+
+        expect(() => new WGS84()).throw(Error);
+
+        expect(() => new WGS84(45)).throw(Error);
+        expect(() => new WGS84(45, 5)).not.throw(Error);
+        expect(() => new WGS84(-93, 5)).throw(Error);
+        expect(() => new WGS84(45, 202)).throw(Error);
+
+        expect(() => new WGS84(45, 5, true)).throw(Error);
+        expect(() => new WGS84(45, 5, false)).throw(Error);
+        expect(() => new WGS84(45, 5, null)).not.throw(Error);
+        expect(() => new WGS84(45, 5, 0)).not.throw(Error);
+        expect(() => new WGS84(45, 5, Number.POSITIVE_INFINITY)).throw(Error);
+
+        expect(() => new WGS84(45, 5, null, null)).not.throw(Error);
+        expect(() => new WGS84(45, 5, null, true)).throw(Error);
+        expect(() => new WGS84(45, 5, null, new Level(1))).not.throw(Error);
+        expect(() => new WGS84(45, 5, null, new Level(1, 2))).not.throw(Error);
+        expect(() => new WGS84(45, 5, 0, new Level(1))).not.throw(Error);
+
+        const level = new Level(2);
+        const position = new WGS84(45, 5, 0, level);
+        expect(position.lat).equals(45);
+        expect(position.lng).equals(5);
+        expect(position.alt).equals(0);
+        expect(position.level).equals(level);
+
+    });
+
+    it('update', () => {
+        const position = new WGS84(0, 0);
+        position.lat = 45;
+        position.lng = 5;
+        position.alt = 0;
+        position.level = new Level(2);
+        expect(position.lat).equals(45);
+        expect(position.lng).equals(5);
+        expect(position.alt).equals(0);
+        expect(Level.equalsTo(position.level, new Level(2))).true;
+        expect(position._ecef).equals(null);
+        expect(position.ecef).is.not.null;
+    });
+
+    it('clone', () => {
+        const level = new Level(0);
+        const position = new WGS84(45, 5, 0, level);
+        const clonePosition = position.clone();
+
+        expect(clonePosition.lat).equals(45);
+        expect(clonePosition.lng).equals(5);
+        expect(clonePosition.alt).equals(0);
+        expect(Level.equalsTo(clonePosition.level, level)).true;
+        expect(clonePosition.level).not.equals(level);
+    });
+
+    it('equalsTo', () => {
+        let position;
+
+        position = new WGS84(0, 0);
+        expect(WGS84.equalsTo(position, new WGS84(0, 0))).true;
+        expect(WGS84.equalsTo(position, new WGS84(0, 0, 0))).false;
+        expect(WGS84.equalsTo(position, new WGS84(0, 0, null, new Level(0)))).false;
+        expect(WGS84.equalsTo(position, new WGS84(0, 0, null, null))).true;
+
+
+        position = new WGS84(45, 5, 0, new Level(0));
+        expect(WGS84.equalsTo(position, new WGS84(45, 5, 0, new Level(0)))).true;
+        expect(WGS84.equalsTo(position, new WGS84(45, 5, 1, new Level(0)))).false;
+        expect(WGS84.equalsTo(position, new WGS84(45, 5, 0, new Level(1)))).false;
+        expect(WGS84.equalsTo(position, {
+            lat: 45,
+            lng: 5
+        })).false;
+        expect(WGS84.equalsTo({
+            lat: 45,
+            lng: 5
+        }, position)).false;
+        expect(WGS84.equalsTo(position, null)).false;
+        expect(WGS84.equalsTo(null, position)).false;
+        expect(WGS84.equalsTo(null, null)).true;
+
+        expect(position.equalsTo(new WGS84(45, 5, 0, new Level(0)))).true;
+        expect(position.equalsTo(new WGS84(45, 5, 0, new Level(1)))).false;
+    });
+
+    it('toString', () => {
+        expect(new WGS84(45, 5).toString()).equals('[45.0000000, 5.0000000]');
+        expect(new WGS84(45, 5, 0).toString()).equals('[45.0000000, 5.0000000, 0.00]');
+        expect(new WGS84(45, 5, 1).toString()).equals('[45.0000000, 5.0000000, 1.00]');
+        expect(new WGS84(45, 5, null, new Level(0)).toString())
+            .equals('[45.0000000, 5.0000000, [0]]');
+        expect(new WGS84(45, 5, null, new Level(1)).toString())
+            .equals('[45.0000000, 5.0000000, [1]]');
+        expect(new WGS84(45, 5, 2, new Level(1)).toString())
+            .equals('[45.0000000, 5.0000000, 2.00, [1]]');
+        expect(new WGS84(45, 5, 2, new Level(1, 2)).toString())
+            .equals('[45.0000000, 5.0000000, 2.00, [1;2]]');
+    });
+
+
+    it('move/destination', () => {
+        let position;
+
+        position = new WGS84(0, 0, 0, new Level(0)).move(100000, 0);
+        expect(WGS84.equalsTo(position, new WGS84(0.8983152841195214, 0, 0, new Level(0)))).true;
+
+        position = new WGS84(0, 0, 0, new Level(0)).move(100000, Math.PI / 2);
+        expect(WGS84.equalsTo(position, new WGS84(0, 0.8983152841195212, 0, new Level(0)))).true;
+
+        position = new WGS84(0, 0, 0).move(100000, 0, 10);
+        expect(WGS84.equalsTo(position, new WGS84(0.8983152841195214, 0, 10))).true;
+
+        expect(() => new WGS84(0, 0).move(100000, 0, 10)).throw(Error);
+
+        const level = new Level(1);
+        position = new WGS84(0, 0, null, level);
+        const newPosition = position.destinationPoint(100000, 0);
+        expect(newPosition).not.equals(position);
+        expect(newPosition.level).not.equal(position.level);
+        expect(WGS84.equalsTo(newPosition, new WGS84(0.8983152841195214, 0, null, level))).true;
+    });
+
+
+    it('ecef', () => {
+        let position;
+
+        position = new WGS84(45, 5, 10);
+        expect(position.ecef).deep.equals(
+            [4492868.9655526765, 393075.10119330435, 4510030.995104634]
+        );
+        expect(WGS84.equalsTo(WGS84.fromECEF(position.ecef), position)).true;
+        expect(position.enuToEcefRotation).deep.equals(
+            [0.6241639651811595, 0.2585371795226045, 0.2821438218554906, 0.6811554412633039]
+        );
+        expect(position.ecefToEnuRotation).deep.equals(
+            [0.6241639651811595, -0.2585371795226045, -0.2821438218554906, -0.6811554412633039]
+        );
+
+        position = new WGS84(-15, 25, 1200);
+        expect(position.ecef).deep.equals([5584638.098155466, 2604159.5131940604, -1651093.9107271794]);
+        expect(WGS84.equalsTo(WGS84.fromECEF(position.ecef), position)).true;
+        expect(position.enuToEcefRotation).deep.equals(
+            [0.32708727738303844, 0.42626843901912514, 0.6691074207087071, 0.5134241817667833]
+        );
+        expect(position.ecefToEnuRotation).deep.equals(
+            [0.32708727738303844, -0.42626843901912514, -0.6691074207087071, -0.5134241817667833]
+        );
+
+    });
+
+
+    it('getSegmentProjection', () => {
+        let p1, p2, projection;
+
+        p1 = new WGS84(0, 0);
+
+        projection = new WGS84(45, 5).getSegmentProjection(p1, p1);
+        expect(projection).is.null;
+
+        p2 = new WGS84(0, 30);
+
+        projection = new WGS84(45, 5).getSegmentProjection(p1, p2);
+        expect(WGS84.equalsTo(projection, new WGS84(0, 5))).true;
+
+        projection = new WGS84(-10, 30).getSegmentProjection(p1, p2);
+        expect(WGS84.equalsTo(projection, new WGS84(0, 30))).true;
+
+        projection = new WGS84(10, 50).getSegmentProjection(p1, p2);
+        expect(projection).is.null;
+
+        p1 = new WGS84(0, 0);
+        p2 = new WGS84(30, 10);
+
+        projection = new WGS84(10, -30).getSegmentProjection(p1, p2);
+        expect(WGS84.equalsTo(projection, new WGS84(1.5735557770204767, 0.473398796436419))).true;
+
+        projection = new WGS84(0, 10).getSegmentProjection(p1, p2);
+        expect(WGS84.equalsTo(projection, new WGS84(2.7840283663153627, 0.8380346611000419))).true;
+
+        projection = new WGS84(45, 5).getSegmentProjection(p1, p2);
+        expect(projection).is.null;
+
+        p1 = new WGS84(0, 0, 10);
+        p2 = new WGS84(0, 30, 15);
+
+        projection = new WGS84(45, 5, 0).getSegmentProjection(p1, p2);
+        expect(WGS84.equalsTo(projection, new WGS84(0, 5, 12.5))).true;
+
+    });
+
+    it('distance', () => {
+
+        expect(WGS84.distanceBetween(new WGS84(0, 0), new WGS84(0, 5)))
+            .closeTo(556597.4539663679, Constants.EPS_MM);
+        expect(WGS84.distanceBetween(new WGS84(0, 0), new WGS84(10, 5)))
+            .closeTo(1243322.1397654496, Constants.EPS_MM);
+        expect(WGS84.distanceBetween(new WGS84(10, 10), new WGS84(10.003, 9.9995)))
+            .closeTo(338.4269853899686, Constants.EPS_MM);
+
+    });
+
+    it('bearing', () => {
+
+        expect(WGS84.bearingTo(new WGS84(0, 0), new WGS84(0, 5)))
+            .closeTo(1.5707963267948966, 1e-5);
+        expect(WGS84.bearingTo(new WGS84(0, 0), new WGS84(10, 5)))
+            .closeTo(0.4590649881870773, 1e-5);
+        expect(WGS84.bearingTo(new WGS84(10, 10), new WGS84(10.003, 9.9995)))
+            .closeTo(-0.16268256717197785, 1e-5);
+
+    });
+
+    it('json', () => {
+
+        expect(new WGS84(0, 0).toJson()).to.deep.equal({
+            lat: 0,
+            lng: 0
+        });
+
+        expect(new WGS84(5, -10, 2).toJson()).to.deep.equal({
+            lat: 5,
+            lng: -10,
+            alt: 2
+        });
+
+        expect(new WGS84(5, -10, null, new Level(1, 2)).toJson()).to.deep.equal({
+            lat: 5,
+            lng: -10,
+            level: '1;2'
+        });
+
+        expect(new WGS84(5, -10, 3, new Level(1, 2)).toJson()).to.deep.equal({
+            lat: 5,
+            lng: -10,
+            alt: 3,
+            level: '1;2'
+        });
+
+        let position;
+
+        position = new WGS84(0, 0);
+        expect(WGS84.equalsTo(WGS84.fromJson(position.toJson()), position)).true;
+
+        position = new WGS84(5, -10, 2);
+        expect(WGS84.equalsTo(WGS84.fromJson(position.toJson()), position)).true;
+
+        position = new WGS84(5, -10, null, new Level(1, 2));
+        expect(WGS84.equalsTo(WGS84.fromJson(position.toJson()), position)).true;
+
+        position = new WGS84(5, -10, 3, new Level(1, 2));
+        expect(WGS84.equalsTo(WGS84.fromJson(position.toJson()), position)).true;
+
+    });
+
+});

package/src/coordinates/WGS84UserPosition.js

@@ -1,20 +1,89 @@
-import WGS84 from './WGS84';
-import Level from './Level';
+import isNumber from 'lodash.isnumber';
+import isFinite from 'lodash.isfinite';
+import isString from 'lodash.isstring';
 
-const MESSAGE_TYPE = 'WGS84UserPosition';
+import WGS84 from './WGS84';
+import Constants from '../Constants';
 
 /**
  * A WGS84 User Position is a WGS84 position with specific data related to user (bearing, provider, time, accuracy)
  */
 class WGS84UserPosition extends WGS84 {
 
-    constructor(lat, lng, alt = null, level = null, time = null,
-        accuracy = null, bearing = null, provider = null) {
+    _time = null;
+    _accuracy = null;
+    _bearing = null;
+    _provider = null;
+
+    constructor(lat, lng, alt, level, time,
+        accuracy, bearing, provider) {
         super(lat, lng, alt, level);
-        this.bearing = bearing;
-        this.provider = provider;
         this.time = time;
         this.accuracy = accuracy;
+        this.bearing = bearing;
+        this.provider = provider;
+    }
+
+    get time() {
+        return this._time;
+    }
+
+    set time(time) {
+        if (isNumber(time) && isFinite(time) && time >= 0) {
+            this._time = time;
+        } else {
+            if (typeof time !== 'undefined' && time !== null) {
+                throw new Error('time argument is not a positive number');
+            }
+            this._time = null;
+        }
+    }
+
+
+    get accuracy() {
+        return this._accuracy;
+    }
+
+    set accuracy(accuracy) {
+        if (isNumber(accuracy) && isFinite(accuracy) && accuracy >= 0) {
+            this._accuracy = accuracy;
+        } else {
+            if (typeof accuracy !== 'undefined' && accuracy !== null) {
+                throw new Error('accuracy argument is not a positive number');
+            }
+            this._accuracy = null;
+        }
+    }
+
+
+    get bearing() {
+        return this._bearing;
+    }
+
+    set bearing(bearing) {
+        if (isNumber(bearing) && isFinite(bearing)) {
+            this._bearing = bearing % (2 * Math.PI);
+        } else {
+            if (typeof bearing !== 'undefined' && bearing !== null) {
+                throw new Error('bearing argument is not a number');
+            }
+            this._bearing = null;
+        }
+    }
+
+    get provider() {
+        return this._provider;
+    }
+
+    set provider(provider) {
+        if (isString(provider)) {
+            this._provider = provider;
+        } else {
+            if (typeof provider !== 'undefined' && provider !== null) {
+                throw new Error('provider is not a string');
+            }
+            this._provider = null;
+        }
     }
 
     // Create a WGS84UserPosition with lat, lng, alt from WGS84 coordinates and
@@ -25,28 +94,72 @@ class WGS84UserPosition extends WGS84 {
     }
 
     clone() {
-        return new WGS84UserPosition(this.lat, this.lng, this.alt, this.level,
-            this.time, this.accuracy, this.bearing, this.provider);
+        const cloned = WGS84UserPosition.fromWGS84(super.clone());
+        cloned.time = this.time;
+        cloned.accuracy = this.accuracy;
+        cloned.bearing = this.bearing;
+        cloned.provider = this.provider;
+        return cloned;
     }
 
-    static get MESSAGE_TYPE() {
-        return MESSAGE_TYPE;
+
+    /**
+     * Compares two WGS84UserPosition
+     * @param {WGS84UserPosition} pos1 position 1
+     * @param {WGS84UserPosition} pos2 position 2
+     * @param {Number} eps latitude and longitude epsilon in degrees (default: 1e-8 [~1mm at lat=0])
+     * @param {Number} epsAlt altitude epsilon in meters (default: 1e-3 [= 1mm])
+     */
+    static equalsTo(pos1, pos2, eps = Constants.EPS_DEG_MM, epsAlt = Constants.EPS_MM) {
+
+        // Handle null comparison
+        if (pos1 === null && pos1 === pos2) {
+            return true;
+        }
+
+        if (!(pos1 instanceof WGS84UserPosition) || !(pos2 instanceof WGS84UserPosition)) {
+            return false;
+        }
+
+        if (!super.equalsTo(pos1, pos2, eps, epsAlt)) {
+            return false;
+        }
+
+        return pos1.time === pos2.time
+            && pos1.accuracy === pos2.accuracy
+            && pos1.bearing === pos2.bearing
+            && pos1.provider === pos2.provider;
+    }
+
+    equalsTo(other) {
+        return WGS84UserPosition.equalsTo(this, other);
     }
 
-    toMessage() {
-        const message = super.toMessage();
-        message.type = MESSAGE_TYPE;
-        message.time = this.time;
-        message.bearing = this.bearing;
-        message.provider = this.provider;
-        message.accuracy = this.accuracy;
-        return message;
+
+    toJson() {
+        const output = super.toJson();
+        if (this.time !== null) {
+            output.time = this.time;
+        }
+        if (this.accuracy !== null) {
+            output.accuracy = this.accuracy;
+        }
+        if (this.bearing !== null) {
+            output.bearing = this.bearing;
+        }
+        if (this.provider !== null) {
+            output.provider = this.provider;
+        }
+        return output;
     }
 
-    static fromMessage(message) {
-        return new WGS84UserPosition(message.lat, message.lng, message.alt,
-            Level.fromString(message.level),
-            message.time, message.accuracy, message.bearing, message.provider);
+    static fromJson(json) {
+        const position = WGS84UserPosition.fromWGS84(WGS84.fromJson(json));
+        position.time = json.time;
+        position.accuracy = json.accuracy;
+        position.bearing = json.bearing;
+        position.provider = json.provider;
+        return position;
     }
 }
 

package/src/coordinates/WGS84UserPosition.spec.js

@@ -0,0 +1,247 @@
+/* eslint-disable max-statements */
+import chai from 'chai';
+import chaiAlmost from 'chai-almost';
+
+import WGS84UserPosition from './WGS84UserPosition';
+import Level from './Level';
+import WGS84 from './WGS84';
+
+const expect = chai.expect;
+chai.use(chaiAlmost());
+
+describe('WGS84UserPosition', () => {
+
+    it('creation', () => {
+
+        expect(() => new WGS84UserPosition()).throw(Error);
+
+        expect(() => new WGS84UserPosition(45)).throw(Error);
+        expect(() => new WGS84UserPosition(45, 5)).not.throw(Error);
+        expect(() => new WGS84UserPosition(45, 5, null)).not.throw(Error);
+        expect(() => new WGS84UserPosition(45, 5, null, null)).not.throw(Error);
+
+        expect(() => new WGS84UserPosition(45, 5, null, null, null)).not.throw(Error);
+        expect(() => new WGS84UserPosition(45, 5, null, null, 0)).not.throw(Error);
+        expect(() => new WGS84UserPosition(45, 5, null, null, 10)).not.throw(Error);
+        expect(() => new WGS84UserPosition(45, 5, null, null, -10)).throw(Error);
+        expect(() => new WGS84UserPosition(45, 5, null, null, Number.POSITIVE_INFINITY)).throw(Error);
+
+        expect(() => new WGS84UserPosition(45, 5, null, null, null, null)).not.throw(Error);
+        expect(() => new WGS84UserPosition(45, 5, null, null, null, 0)).not.throw(Error);
+        expect(() => new WGS84UserPosition(45, 5, null, null, null, 10)).not.throw(Error);
+        expect(() => new WGS84UserPosition(45, 5, null, null, null, -10)).throw(Error);
+        expect(() => new WGS84UserPosition(45, 5, null, null, null, Number.POSITIVE_INFINITY)).throw(Error);
+
+        expect(() => new WGS84UserPosition(45, 5, null, null, null,
+            null, null)).not.throw(Error);
+        expect(() => new WGS84UserPosition(45, 5, null, null, null,
+            null, 0)).not.throw(Error);
+        expect(() => new WGS84UserPosition(45, 5, null, null, null,
+            null, 10)).not.throw(Error);
+        expect(() => new WGS84UserPosition(45, 5, null, null, null,
+            null, -10)).not.throw(Error);
+        expect(() => new WGS84UserPosition(45, 5, null, null, null,
+            null, Number.POSITIVE_INFINITY)).throw(Error);
+
+        expect(() => new WGS84UserPosition(45, 5, null, null, null,
+            null, null, null)).not.throw(Error);
+        expect(() => new WGS84UserPosition(45, 5, null, null, null,
+            null, null, 0)).throw(Error);
+        expect(() => new WGS84UserPosition(45, 5, null, null, null,
+            null, null, 10)).throw(Error);
+        expect(() => new WGS84UserPosition(45, 5, null, null, null,
+            null, null, 'foo')).not.throw(Error);
+
+        const position = new WGS84UserPosition(45, 5, 0, new Level(2), 123456, 10, Math.PI, 'foo');
+        expect(position.lat).equals(45);
+        expect(position.lng).equals(5);
+        expect(position.alt).equals(0);
+        expect(Level.equalsTo(position.level, new Level(2))).true;
+        expect(position.time).equals(123456);
+        expect(position.accuracy).equals(10);
+        expect(position.bearing).equals(Math.PI);
+        expect(position.provider).equals('foo');
+
+    });
+
+    it('update', () => {
+        const position = new WGS84UserPosition(0, 0);
+        position.lat = 45;
+        position.lng = 5;
+        position.alt = 0;
+        position.level = new Level(2);
+        position.time = 123456;
+        position.accuracy = 10;
+        position.bearing = Math.PI;
+        position.provider = 'foo';
+        expect(position.lat).equals(45);
+        expect(position.lng).equals(5);
+        expect(position.alt).equals(0);
+        expect(Level.equalsTo(position.level, new Level(2))).true;
+        expect(position.time).equals(123456);
+        expect(position.accuracy).equals(10);
+        expect(position.bearing).equals(Math.PI);
+        expect(position.provider).equals('foo');
+
+    });
+
+    it('fromWGS84', () => {
+        const level = new Level(2);
+        const wgs84 = new WGS84(45, 5, 0, level, 123456);
+        const position = WGS84UserPosition.fromWGS84(wgs84);
+        expect(position).instanceOf(WGS84UserPosition);
+        expect(position.lat).equals(45);
+        expect(position.lng).equals(5);
+        expect(position.alt).equals(0);
+        expect(Level.equalsTo(position.level, level)).true;
+        expect(position.time).is.null;
+        expect(position.accuracy).is.null;
+        expect(position.bearing).is.null;
+        expect(position.provider).is.null;
+    });
+
+
+    it('clone', () => {
+        const level = new Level(2);
+        const position = new WGS84UserPosition(45, 5, 0, level, 123456, 10, Math.PI, 'foo');
+        const clonePosition = position.clone();
+
+        expect(clonePosition.lat).equals(45);
+        expect(clonePosition.lng).equals(5);
+        expect(clonePosition.alt).equals(0);
+        expect(Level.equalsTo(clonePosition.level, level)).true;
+        expect(clonePosition.level).not.equals(level);
+        expect(clonePosition.time).equals(123456);
+        expect(clonePosition.accuracy).equals(10);
+        expect(clonePosition.bearing).equals(Math.PI);
+        expect(clonePosition.provider).equals('foo');
+    });
+
+
+    it('equalsTo', () => {
+        let position, position2;
+
+        expect(WGS84UserPosition.equalsTo(null, null)).true;
+
+        position = new WGS84UserPosition(0, 0);
+        expect(WGS84UserPosition.equalsTo(position, new WGS84UserPosition(0, 0))).true;
+        expect(WGS84UserPosition.equalsTo(position, new WGS84(0, 0))).false;
+
+        position = new WGS84UserPosition(45, 5, 0, new Level(2), 123456, 10, Math.PI, 'foo');
+        expect(WGS84UserPosition.equalsTo(position,
+            new WGS84UserPosition(45, 5, 0, new Level(2), 123456, 10, Math.PI, 'foo')
+        )).true;
+
+        position2 = position.clone();
+        position2.lat = 0;
+        expect(WGS84UserPosition.equalsTo(position, position2)).false;
+
+        position2 = position.clone();
+        position2.lng = 0;
+        expect(WGS84UserPosition.equalsTo(position, position2)).false;
+
+        position2 = position.clone();
+        position2.alt = 10;
+        expect(WGS84UserPosition.equalsTo(position, position2)).false;
+
+        position2 = position.clone();
+        position2.level = null;
+        expect(WGS84UserPosition.equalsTo(position, position2)).false;
+
+        position2 = position.clone();
+        position2.time = 0;
+        expect(WGS84UserPosition.equalsTo(position, position2)).false;
+
+        position2 = position.clone();
+        position2.accuracy = 0;
+        expect(WGS84UserPosition.equalsTo(position, position2)).false;
+
+        position2 = position.clone();
+        position2.bearing = 0;
+        expect(WGS84UserPosition.equalsTo(position, position2)).false;
+
+        position2 = position.clone();
+        position2.provider = 'foobar';
+        expect(WGS84UserPosition.equalsTo(position, position2)).false;
+
+        expect(position.equalsTo(
+            new WGS84UserPosition(45, 5, 0, new Level(2), 123456, 10, Math.PI, 'foo')
+        )).true;
+        expect(position.equalsTo(
+            new WGS84UserPosition(45, 5, 0, new Level(2), 123456, 0, Math.PI, 'foo')
+        )).false;
+    });
+
+    it('json', () => {
+        let position;
+
+        position = new WGS84UserPosition(5, -10);
+        expect(position.toJson()).to.deep.equal({
+            lat: 5,
+            lng: -10
+        });
+
+        position = new WGS84UserPosition(5, -10);
+        position.alt = 2;
+        expect(position.toJson()).to.deep.equal({
+            lat: 5,
+            lng: -10,
+            alt: 2
+        });
+
+        position = new WGS84UserPosition(5, -10);
+        position.level = new Level(2);
+        expect(position.toJson()).to.deep.equal({
+            lat: 5,
+            lng: -10,
+            level: '2'
+        });
+
+        position = new WGS84UserPosition(5, -10);
+        position.time = 10;
+        expect(position.toJson()).to.deep.equal({
+            lat: 5,
+            lng: -10,
+            time: 10
+        });
+
+        position = new WGS84UserPosition(5, -10);
+        position.accuracy = 10;
+        expect(position.toJson()).to.deep.equal({
+            lat: 5,
+            lng: -10,
+            accuracy: 10
+        });
+
+        position = new WGS84UserPosition(5, -10);
+        position.bearing = Math.PI;
+        expect(position.toJson()).to.deep.equal({
+            lat: 5,
+            lng: -10,
+            bearing: Math.PI
+        });
+
+        position = new WGS84UserPosition(5, -10);
+        position.provider = 'foo';
+        expect(position.toJson()).to.deep.equal({
+            lat: 5,
+            lng: -10,
+            provider: 'foo'
+        });
+
+
+        position = new WGS84UserPosition(5, -10);
+        expect(WGS84UserPosition.equalsTo(
+            WGS84UserPosition.fromJson(position.toJson()),
+            position)
+        ).true;
+
+        position = new WGS84UserPosition(45, 5, 0, new Level(2), 123456, 10, Math.PI, 'foo');
+        expect(WGS84UserPosition.equalsTo(
+            WGS84UserPosition.fromJson(position.toJson()),
+            position)
+        ).true;
+
+    });
+
+});