@sports-alliance/sports-lib 7.0.7 → 7.0.9

package/lib/esm/specs/activities-parsing.integration.spec.js

@@ -1,1847 +0,0 @@
-import * as fs from 'fs';
-import { SportsLib } from '../index';
-import { DataHeartRate } from '../data/data.heart-rate';
-import { DataLongitudeDegrees } from '../data/data.longitude-degrees';
-import { DataLatitudeDegrees } from '../data/data.latitude-degrees';
-import { DataDistance } from '../data/data.distance';
-import { DataSpeed } from '../data/data.speed';
-import { DataCadence } from '../data/data.cadence';
-import { DataPower } from '../data/data.power';
-import { DataAltitude } from '../data/data.altitude';
-import { ActivityTypes } from '../activities/activity.types';
-import { DataAscent } from '../data/data.ascent';
-import { SpecUtils } from './spec-utils';
-import { DataTimerTime } from '../data/data.timer-time';
-import { DataPause } from '../data/data.pause';
-import { DataEnergy } from '../data/data.energy';
-import { DataHeartRateAvg } from '../data/data.heart-rate-avg';
-import { DataCadenceMax } from '../data/data.cadence-max';
-import { DataPowerAvg } from '../data/data.power-avg';
-import { DataCadenceAvg } from '../data/data.cadence-avg';
-import { DataSpeedAvg } from '../data/data.speed-avg';
-import { DataPowerMax } from '../data/data.power-max';
-import { DataDescent } from '../data/data.descent';
-import { DataHeartRateMax } from '../data/data.heart-rate-max';
-import { DataPoolLength } from '../data/data.pool-length';
-import { DataTotalCycles } from '../data/data-total-cycles';
-import { DataActiveLengths } from '../data/data-active-lengths';
-import { DataPaceAvg } from '../data/data.pace-avg';
-import { DataTemperatureAvg } from '../data/data.temperature-avg';
-import { DataMovingTime } from '../data/data.moving-time';
-import xmldom from '@xmldom/xmldom';
-import { DataGradeAdjustedPaceAvg } from '../data/data.grade-adjusted-pace-avg';
-import { DataActiveLap } from '../data/data-active-lap';
-import { DataSWOLF25m } from '../data/data.swolf-25m';
-import { DataSWOLF50m } from '../data/data.swolf-50m';
-import { DataLeftBalance } from '../data/data.left-balance';
-import { DataRightBalance } from '../data/data.right-balance';
-import { DataPowerTorqueEffectivenessLeft } from '../data/data.power-torque-effectiveness-left';
-import { DataPowerTorqueEffectivenessRight } from '../data/data.power-torque-effectiveness-right';
-import { DataPowerPedalSmoothnessRight } from '../data/data.power-pedal-smoothness-right';
-import { DataPowerPedalSmoothnessLeft } from '../data/data.power-pedal-smoothness-left';
-import { DataPowerNormalized } from '../data/data.power-normalized';
-import { DataPowerIntensityFactor } from '../data/data.power-intensity-factor';
-import { DataPowerTrainingStressScore } from '../data/data.power-training-stress-score';
-import { DataPowerWork } from '../data/data.power-work';
-import { DataCyclingStandingTime } from '../data/data.cycling-standing-time';
-import { DataCyclingSeatedTime } from '../data/data.cycling-seated-time';
-import { DataVerticalOscillation } from '../data/data.vertical-oscillation';
-import { DataVerticalRatio } from '../data/data.vertical-ratio';
-import { DataStanceTime } from '../data/data.stance-time';
-import { DataStanceTimeBalanceRight } from '../data/data-stance-time-balance-right';
-import { DataStanceTimeBalanceLeft } from '../data/data-stance-time-balance-left';
-import { DataAvgStrideLength } from '../data/data.avg-stride-length';
-import { DataAerobicTrainingEffect } from '../data/data-aerobic-training-effect';
-import { DataAnaerobicTrainingEffect } from '../data/data-anaerobic-training-effect';
-import { DataAltitudeSmooth } from '../data/data.altitude-smooth';
-import { DataGrade } from '../data/data.grade';
-import { ActivityParsingOptions } from '../activities/activity-parsing-options';
-import { standardDeviation } from '../events/utilities/helpers';
-describe('FIT/TCX/GPX activity parsing compliance', () => {
-    const domParser = new xmldom.DOMParser();
-    /*  it('Template: should parse FIT activity file', done => {
-      // Given FIT Source: https://connect.garmin.com/modern/activity/xxxxxxxx OR https://www.strava.com/activities/xxxxxxx (should be "public")
-      const path = '/path/to/your/file.fit';
-      const buffer = fs.readFileSync(path);
-  
-      // When
-      const eventInterfacePromise = SportsLib.importFromFit(buffer);
-  
-      // Then
-      eventInterfacePromise.then((event: EventInterface) => {
-        const activity = event.getFirstActivity();
-        done();
-      });
-    });*/
-    /*  it('Template: should parse TCX activity file', done => {
-      // Given TCX Source: https://connect.garmin.com/modern/activity/xxxxxxxx OR https://www.strava.com/activities/xxxxxxx (should be "public")
-      const path = '/path/to/your/file.tcx';
-      const doc = domParser.parseFromString(fs.readFileSync(path).toString(), 'application/xml');
-  
-      // When
-      const eventInterfacePromise = SportsLib.importFromTCX(doc);
-  
-      // Then
-      eventInterfacePromise.then((event: EventInterface) => {
-        const activity = event.getFirstActivity();
-        done();
-      });
-    });*/
-    /*  it('Template: should parse GPX activity file', done => {
-      // Given GPX Source: https://connect.garmin.com/modern/activity/xxxxxxxx OR https://www.strava.com/activities/xxxxxxx (should be "public")
-      const path = '/path/to/your/file.gpx';
-      const gpxString = fs.readFileSync(path).toString();
-  
-      // When
-      const eventInterfacePromise = SportsLib.importFromGPX(gpxString, xmldom.DOMParser);
-  
-      // Then
-      eventInterfacePromise.then((event: EventInterface) => {
-        const activity = event.getFirstActivity();
-        done();
-      });
-    });*/
-    describe('Swimming', () => {
-        describe('FIT', () => {
-            it('should parse swimming pool FIT file (1)', done => {
-                // Given FIT Source:  https://connect.garmin.com/modern/activity/6688025408 OR https://www.strava.com/activities/4232464474
-                const path = __dirname + '/fixtures/swim/fit/6688025408.fit';
-                const buffer = fs.readFileSync(path);
-                // When
-                const eventInterfacePromise = SportsLib.importFromFit(buffer);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    const activity = event.getFirstActivity();
-                    expect(activity.creator.name).toEqual('Garmin Forerunner 935');
-                    expect(activity.creator.productId).toEqual(2691);
-                    const movingTime = activity.getStat(DataMovingTime.type).getValue();
-                    const timerTime = activity.getStat(DataTimerTime.type).getValue();
-                    const pauseTime = activity.getStat(DataPause.type).getValue();
-                    const elapsedTime = activity.getDuration().getValue();
-                    expect(activity.type).toEqual(ActivityTypes.Swimming);
-                    expect(activity.getStat(DataDistance.type).getValue()).toEqual(2300);
-                    expect(activity.getStat(DataEnergy.type).getValue()).toEqual(458);
-                    expect(activity.getStat(DataCadenceAvg.type).getValue()).toEqual(20);
-                    expect(activity.getStat(DataCadenceMax.type).getValue()).toEqual(23);
-                    expect(activity.getStat(DataHeartRateAvg.type).getValue()).toEqual(126);
-                    expect(activity.getStat(DataHeartRateMax.type).getValue()).toEqual(146);
-                    expect(activity.getStat(DataPoolLength.type).getValue()).toEqual(50);
-                    expect(activity.getStat(DataActiveLengths.type).getValue()).toEqual(46);
-                    expect(activity.getStat(DataSWOLF25m.type).getValue()).toEqual(36.7);
-                    expect(activity.getStat(DataSWOLF50m.type).getValue()).toEqual(73.4);
-                    expect(activity.getStat(DataTotalCycles.type).getValue()).toEqual(806);
-                    const laps = activity.getLaps();
-                    expect(laps.length).toEqual(36);
-                    expect(laps[0].getStat(DataActiveLap.type).getValue()).toBeTruthy();
-                    expect(laps[1].getStat(DataActiveLap.type).getValue()).toBeFalsy();
-                    expect(laps[1].lapId).toEqual(2);
-                    expect(activity.hasStreamData(DataSpeed.type)).toBeTruthy();
-                    expect(activity.hasStreamData(DataHeartRate.type)).toBeTruthy();
-                    expect(activity.hasStreamData(DataCadence.type)).toBeTruthy();
-                    expect(activity.hasStreamData(DataDistance.type)).toBeTruthy();
-                    SpecUtils.assertNearEqualTime(SpecUtils.speedToSwimPace(activity.getStat(DataSpeedAvg.type).getValue()), '01:50');
-                    SpecUtils.assertNearEqualTime(movingTime, '44:06');
-                    SpecUtils.assertNearEqualTime(timerTime, '01:06:03');
-                    SpecUtils.assertNearEqualTime(elapsedTime, '01:06:23');
-                    SpecUtils.assertEqual(pauseTime, elapsedTime - movingTime, 1);
-                    done();
-                }).catch((e) => done(e));
-            });
-            it('should parse swimming pool FIT file (2)', done => {
-                // Given FIT Source:  https://connect.garmin.com/modern/activity/6021532030 OR https://www.strava.com/activities/5258304128
-                const path = __dirname + '/fixtures/swim/fit/6021532030.fit';
-                const buffer = fs.readFileSync(path);
-                // When
-                const eventInterfacePromise = SportsLib.importFromFit(buffer);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    const activity = event.getFirstActivity();
-                    expect(activity.type).toEqual(ActivityTypes.Swimming);
-                    expect(activity.getStat(DataDistance.type).getValue()).toEqual(780);
-                    expect(activity.getStat(DataEnergy.type).getValue()).toEqual(235);
-                    expect(activity.getStat(DataCadenceAvg.type).getValue()).toEqual(26);
-                    expect(activity.getStat(DataCadenceMax.type).getValue()).toEqual(28);
-                    expect(activity.getStat(DataPoolLength.type).getValue()).toEqual(20);
-                    expect(activity.getStat(DataActiveLengths.type).getValue()).toEqual(39);
-                    expect(activity.getStat(DataSWOLF25m.type).getValue()).toEqual(63.9);
-                    expect(activity.getStat(DataSWOLF50m.type).getValue()).toEqual(127.7);
-                    expect(activity.getStat(DataTotalCycles.type).getValue()).toEqual(596);
-                    SpecUtils.assertNearEqualTime(SpecUtils.speedToSwimPace(activity.getStat(DataSpeedAvg.type).getValue()), '02:58');
-                    const movingTime = activity.getStat(DataMovingTime.type).getValue();
-                    const timerTime = activity.getStat(DataTimerTime.type).getValue();
-                    const pauseTime = activity.getStat(DataPause.type).getValue();
-                    const elapsedTime = activity.getDuration().getValue();
-                    SpecUtils.assertNearEqualTime(movingTime, '23:09');
-                    SpecUtils.assertNearEqualTime(timerTime, '23:09');
-                    SpecUtils.assertNearEqualTime(elapsedTime, '23:31');
-                    SpecUtils.assertEqual(pauseTime, elapsedTime - movingTime, 1);
-                    done();
-                }).catch((e) => done(e));
-            });
-            it('should parse swimming pool FIT file (3)', done => {
-                // Given FIT Source: https://connect.garmin.com/modern/activity/6860712481 OR https://www.strava.com/activities/5376106733
-                const path = __dirname + '/fixtures/swim/fit/6860712481.fit';
-                const buffer = fs.readFileSync(path);
-                // When
-                const eventInterfacePromise = SportsLib.importFromFit(buffer);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    const activity = event.getFirstActivity();
-                    expect(activity.type).toEqual(ActivityTypes.Swimming);
-                    expect(activity.getStat(DataDistance.type).getValue()).toEqual(2000);
-                    expect(activity.getStat(DataEnergy.type).getValue()).toEqual(401);
-                    expect(activity.getStat(DataCadenceAvg.type).getValue()).toEqual(28);
-                    expect(activity.getStat(DataHeartRateAvg.type).getValue()).toEqual(131);
-                    expect(activity.getStat(DataHeartRateMax.type).getValue()).toEqual(157);
-                    expect(activity.getStat(DataPoolLength.type).getValue()).toEqual(25);
-                    expect(activity.getStat(DataActiveLengths.type).getValue()).toEqual(80);
-                    expect(activity.getStat(DataSWOLF25m.type).getValue()).toEqual(46.1);
-                    expect(activity.getStat(DataSWOLF50m.type).getValue()).toEqual(92.2);
-                    expect(activity.getStat(DataTotalCycles.type).getValue()).toEqual(984);
-                    // TODO Check streams based on laps for swims performed in a pool
-                    SpecUtils.assertNearEqualTime(SpecUtils.speedToSwimPace(activity.getStat(DataSpeedAvg.type).getValue()), '02:06');
-                    const movingTime = activity.getStat(DataMovingTime.type).getValue();
-                    const timerTime = activity.getStat(DataTimerTime.type).getValue();
-                    const pauseTime = activity.getStat(DataPause.type).getValue();
-                    const elapsedTime = activity.getDuration().getValue();
-                    SpecUtils.assertNearEqualTime(movingTime, '41:25');
-                    SpecUtils.assertNearEqualTime(timerTime, '47:27');
-                    SpecUtils.assertNearEqualTime(elapsedTime, '49:43');
-                    SpecUtils.assertEqual(pauseTime, elapsedTime - movingTime, 1);
-                    done();
-                }).catch((e) => done(e));
-            });
-            it('should parse swimming pool FIT file (4)', done => {
-                // Given FIT Source: https://connect.garmin.com/modern/activity/7617306288 OR https://www.strava.com/activities/6076695527
-                const path = __dirname + '/fixtures/swim/fit/7617306288.fit';
-                const buffer = fs.readFileSync(path);
-                // When
-                const eventInterfacePromise = SportsLib.importFromFit(buffer);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    const activity = event.getFirstActivity();
-                    expect(activity.type).toEqual(ActivityTypes.Swimming);
-                    expect(activity.getStat(DataDistance.type).getValue()).toEqual(150);
-                    SpecUtils.assertNearEqualTime(SpecUtils.speedToSwimPace(activity.getStat(DataSpeedAvg.type).getValue()), '01:54');
-                    expect(activity.getLaps().length).toEqual(6);
-                    done();
-                }).catch((e) => done(e));
-            });
-            it('should parse swimming open water FIT file (1)', done => {
-                // Given https://connect.garmin.com/modern/activity/6788312639/1 OR https://www.strava.com/activities/5305763421
-                const path = __dirname + '/fixtures/swim/fit/6788312639-1.fit';
-                const buffer = fs.readFileSync(path);
-                // When
-                const eventInterfacePromise = SportsLib.importFromFit(buffer);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    const activity = event.getFirstActivity();
-                    expect(activity.type).toEqual(ActivityTypes.OpenWaterSwimming);
-                    expect(activity.getStat(DataDistance.type).getValue()).toEqual(1505.03);
-                    expect(activity.getStat(DataEnergy.type).getValue()).toEqual(403);
-                    expect(activity.getStat(DataCadenceAvg.type).getValue()).toEqual(32);
-                    expect(activity.getStat(DataCadenceMax.type).getValue()).toEqual(48);
-                    expect(activity.getStat(DataHeartRateAvg.type).getValue()).toEqual(158);
-                    expect(activity.getStat(DataHeartRateMax.type).getValue()).toEqual(170);
-                    expect(activity.getStat(DataTotalCycles.type).getValue()).toEqual(993);
-                    expect(activity.getStat(DataSWOLF25m.type).getValue()).toEqual(47.5);
-                    expect(activity.getStat(DataSWOLF50m.type).getValue()).toEqual(95);
-                    SpecUtils.assertNearEqualTime(SpecUtils.speedToSwimPace(activity.getStat(DataSpeedAvg.type).getValue()), '02:04');
-                    const movingTime = activity.getStat(DataMovingTime.type).getValue();
-                    const timerTime = activity.getStat(DataTimerTime.type).getValue();
-                    const pauseTime = activity.getStat(DataPause.type).getValue();
-                    const elapsedTime = activity.getDuration().getValue();
-                    SpecUtils.assertNearEqualTime(movingTime, '24:28');
-                    SpecUtils.assertNearEqualTime(timerTime, '31:06');
-                    SpecUtils.assertNearEqualTime(elapsedTime, '31:06');
-                    SpecUtils.assertEqual(pauseTime, elapsedTime - movingTime, 1);
-                    done();
-                }).catch((e) => done(e));
-            });
-        });
-        describe('TCX', () => {
-            it('should parse swimming pool TCX file (1)', done => {
-                // Given TCX Source: https://connect.garmin.com/modern/activity/6832570127 OR https://www.strava.com/activities/5347012220
-                // Given FIT Source: https://connect.garmin.com/modern/activity/6688025408 OR https://www.strava.com/activities/4232464474
-                const path = __dirname + '/fixtures/swim/tcx/6688025408.tcx';
-                const doc = domParser.parseFromString(fs.readFileSync(path).toString(), 'application/xml');
-                // When
-                const eventInterfacePromise = SportsLib.importFromTCX(doc);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    const activity = event.getFirstActivity();
-                    // expect(activity.type).toEqual(ActivityTypes.Swimming); // TODO To be auto-detected by sports-data-science library (work in progress)
-                    expect(activity.getStat(DataDistance.type).getValue()).toEqual(2300);
-                    expect(activity.getStat(DataEnergy.type).getValue()).toEqual(458);
-                    expect(activity.getStat(DataHeartRateAvg.type).getValue()).toEqual(119);
-                    expect(activity.getStat(DataHeartRateMax.type).getValue()).toEqual(146);
-                    const laps = activity.getLaps();
-                    expect(laps.length).toEqual(36);
-                    expect(laps[0].getStat(DataActiveLap.type).getValue()).toBeTruthy();
-                    expect(laps[1].getStat(DataActiveLap.type).getValue()).toBeFalsy();
-                    expect(laps[1].lapId).toEqual(2);
-                    SpecUtils.assertNearEqualTime(SpecUtils.speedToSwimPace(activity.getStat(DataSpeedAvg.type).getValue()), '01:50');
-                    const movingTime = activity.getStat(DataMovingTime.type).getValue();
-                    const timerTime = activity.getStat(DataTimerTime.type).getValue();
-                    const pauseTime = activity.getStat(DataPause.type).getValue();
-                    const elapsedTime = activity.getDuration().getValue();
-                    SpecUtils.assertNearEqualTime(movingTime, '44:06');
-                    SpecUtils.assertNearEqualTime(timerTime, '01:06:03');
-                    SpecUtils.assertNearEqualTime(elapsedTime, '01:06:23');
-                    SpecUtils.assertEqual(pauseTime, elapsedTime - movingTime);
-                    done();
-                }).catch((e) => done(e));
-            });
-            it('should parse swimming pool TCX file (2)', done => {
-                // Given TCX Source: https://connect.garmin.com/modern/activity/6861441616 or https://www.strava.com/activities/5378130384
-                // Given FIT Source: https://connect.garmin.com/modern/activity/6860712481 OR https://www.strava.com/activities/5376106733
-                const path = __dirname + '/fixtures/swim/tcx/6860712481.tcx';
-                const doc = domParser.parseFromString(fs.readFileSync(path).toString(), 'application/xml');
-                // When
-                const eventInterfacePromise = SportsLib.importFromTCX(doc);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    const activity = event.getFirstActivity();
-                    // expect(activity.type).toEqual(ActivityTypes.Swimming); // TODO To be auto-detected by sports-data-science library (work in progress)
-                    expect(activity.getStat(DataDistance.type).getValue()).toEqual(2000);
-                    expect(activity.getStat(DataEnergy.type).getValue()).toEqual(401);
-                    expect(activity.getStat(DataTotalCycles.type).getValue()).toEqual(984);
-                    expect(activity.getStat(DataHeartRateAvg.type).getValue()).toEqual(128);
-                    expect(activity.getStat(DataHeartRateMax.type).getValue()).toEqual(156);
-                    SpecUtils.assertNearEqualTime(SpecUtils.speedToSwimPace(activity.getStat(DataSpeedAvg.type).getValue()), '02:05');
-                    const movingTime = activity.getStat(DataMovingTime.type).getValue();
-                    const timerTime = activity.getStat(DataTimerTime.type).getValue();
-                    const pauseTime = activity.getStat(DataPause.type).getValue();
-                    const elapsedTime = activity.getDuration().getValue();
-                    SpecUtils.assertNearEqualTime(movingTime, '41:25');
-                    SpecUtils.assertNearEqualTime(timerTime, '47:27');
-                    SpecUtils.assertNearEqualTime(elapsedTime, '47:27');
-                    SpecUtils.assertEqual(pauseTime, elapsedTime - movingTime, 1);
-                    done();
-                }).catch((e) => done(e));
-            });
-        });
-        describe('GPX', () => {
-            it('should parse swimming open water GPX file (1)', done => {
-                // Given GPX Source: https://connect.garmin.com/modern/activity/6867388194 OR https://www.strava.com/activities/5382390985
-                // Given FIT Source: https://connect.garmin.com/modern/activity/4623204522/1 OR https://www.strava.com/activities/5352030147
-                const path = __dirname + '/fixtures/swim/gpx/4623204522-1.gpx';
-                const gpxString = fs.readFileSync(path).toString();
-                // When
-                const eventInterfacePromise = SportsLib.importFromGPX(gpxString, xmldom.DOMParser);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    // Swim
-                    const swimActivity = event.getFirstActivity();
-                    // expect(swimActivity.type).toEqual(ActivityTypes.OpenWaterSwimming); // TODO To be auto-detected by sports-data-science library (work in progress)
-                    expect(swimActivity.getStreamData(DataSpeed.type).length).toEqual(3689);
-                    expect(swimActivity.startDate.toISOString()).toEqual('2018-10-13T17:05:01.000Z');
-                    expect(swimActivity.endDate.toISOString()).toEqual('2018-10-13T18:06:29.000Z');
-                    expect(swimActivity.getStat(DataDistance.type).getValue()).toBeCloseTo(3869, 0);
-                    expect(swimActivity.getStat(DataCadenceAvg.type).getValue()).toEqual(36);
-                    expect(swimActivity.getStat(DataCadenceMax.type).getValue()).toEqual(39);
-                    expect(swimActivity.getStat(DataHeartRateAvg.type).getValue()).toEqual(74);
-                    expect(swimActivity.getStat(DataHeartRateMax.type).getValue()).toEqual(115);
-                    SpecUtils.assertNearEqualTime(SpecUtils.speedToSwimPace(swimActivity.getStat(DataSpeedAvg.type).getValue()), '01:31', 2);
-                    // Verifying time data
-                    const movingTime = swimActivity.getStat(DataMovingTime.type).getValue();
-                    const timerTime = swimActivity.getStat(DataTimerTime.type).getValue();
-                    const pauseTime = swimActivity.getStat(DataPause.type).getValue();
-                    const elapsedTime = swimActivity.getDuration().getValue();
-                    SpecUtils.assertNearEqualTime(movingTime, '01:00:35', 1);
-                    SpecUtils.assertNearEqualTime(timerTime, '01:01:29');
-                    SpecUtils.assertNearEqualTime(elapsedTime, '01:01:29');
-                    SpecUtils.assertEqual(pauseTime, elapsedTime - movingTime, 1);
-                    done();
-                }).catch((e) => done(e));
-            });
-            it('should parse swimming open water GPX file (2)', done => {
-                // Given GPX Source: https://connect.garmin.com/modern/activity/6867446668 OR https://www.strava.com/activities/5382426315
-                // Given FIT Source: https://connect.garmin.com/modern/activity/6090674952 OR https://www.strava.com/activities/5366783958
-                const path = __dirname + '/fixtures/swim/gpx/6090674952.gpx';
-                const gpxString = fs.readFileSync(path).toString();
-                // When
-                const eventInterfacePromise = SportsLib.importFromGPX(gpxString, xmldom.DOMParser);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    const swimActivity = event.getFirstActivity();
-                    // expect(swimActivity.type).toEqual(ActivityTypes.OpenWaterSwimming);  // TODO To be auto-detected by sports-data-science library (work in progress)
-                    expect(swimActivity.startDate.toISOString()).toEqual('2021-01-04T16:22:18.000Z');
-                    expect(swimActivity.endDate.toISOString()).toEqual('2021-01-04T17:37:05.000Z');
-                    expect(swimActivity.getStat(DataDistance.type).getValue()).toBeCloseTo(2537, 0);
-                    expect(swimActivity.getStat(DataHeartRateAvg.type).getValue()).toEqual(145);
-                    expect(swimActivity.getStat(DataHeartRateMax.type).getValue()).toEqual(184);
-                    SpecUtils.assertNearEqualTime(SpecUtils.speedToSwimPace(swimActivity.getStat(DataSpeedAvg.type).getValue()), '02:29');
-                    // Verifying time data
-                    const movingTime = swimActivity.getStat(DataMovingTime.type).getValue();
-                    const timerTime = swimActivity.getStat(DataTimerTime.type).getValue();
-                    const pauseTime = swimActivity.getStat(DataPause.type).getValue();
-                    const elapsedTime = swimActivity.getDuration().getValue();
-                    SpecUtils.assertNearEqualTime(movingTime, '55:43', 1);
-                    SpecUtils.assertNearEqualTime(timerTime, '01:14:47');
-                    SpecUtils.assertNearEqualTime(elapsedTime, '01:14:47');
-                    SpecUtils.assertEqual(pauseTime, elapsedTime - movingTime, 1);
-                    done();
-                }).catch((e) => done(e));
-            });
-        });
-    });
-    describe('Running', () => {
-        describe('FIT', () => {
-            it('should parse running FIT file (1)', done => {
-                // Given FIT Source: https://connect.garmin.com/modern/activity/2067489619 OR https://www.strava.com/activities/1221143311
-                const path = __dirname + '/fixtures/runs/fit/2067489619.fit';
-                const buffer = fs.readFileSync(path);
-                // When
-                const eventInterfacePromise = SportsLib.importFromFit(buffer);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    const activity = event.getFirstActivity();
-                    expect(activity.creator.name).toEqual('Garmin VivoActive HR');
-                    expect(activity.creator.manufacturer).toEqual('garmin');
-                    expect(activity.type).toEqual(ActivityTypes.Running);
-                    expect(activity.getStat(DataDistance.type).getValue()).toEqual(4489.39);
-                    expect(activity.getStat(DataCadenceAvg.type).getValue()).toEqual(58);
-                    expect(activity.getStat(DataCadenceMax.type).getValue()).toEqual(88);
-                    expect(activity.getStat(DataTotalCycles.type).getValue()).toEqual(2782);
-                    expect(activity.getStat(DataHeartRateAvg.type).getValue()).toEqual(130);
-                    expect(activity.getStat(DataHeartRateMax.type).getValue()).toEqual(179);
-                    expect(activity.getStat(DataPaceAvg.type).getValue()).toBeGreaterThanOrEqual(activity.getStat(DataGradeAdjustedPaceAvg.type).getValue());
-                    SpecUtils.assertNearEqualTime(activity.getStat(DataPaceAvg.type).getValue(), '10:28', 1);
-                    SpecUtils.assertNearEqualTime(activity.getStat(DataGradeAdjustedPaceAvg.type).getValue(), '09:11', 1);
-                    const movingTime = activity.getStat(DataMovingTime.type).getValue();
-                    const timerTime = activity.getStat(DataTimerTime.type).getValue();
-                    const pauseTime = activity.getStat(DataPause.type).getValue();
-                    const elapsedTime = activity.getDuration().getValue();
-                    SpecUtils.assertNearEqualTime(movingTime, '45:42');
-                    SpecUtils.assertNearEqualTime(timerTime, '47:00');
-                    SpecUtils.assertNearEqualTime(elapsedTime, '47:04');
-                    SpecUtils.assertEqual(pauseTime, elapsedTime - movingTime, 1);
-                    done();
-                }).catch((e) => done(e));
-            });
-            it('should parse running FIT file (2)', done => {
-                // Given FIT Source: https://connect.garmin.com/modern/activity/6782987395 OR https://www.strava.com/activities/2451375851
-                const path = __dirname + '/fixtures/runs/fit/6782987395.fit';
-                const buffer = fs.readFileSync(path);
-                // When
-                const eventInterfacePromise = SportsLib.importFromFit(buffer);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    const activity = event.getFirstActivity();
-                    expect(activity.type).toEqual(ActivityTypes.Running);
-                    expect(activity.getStat(DataDistance.type).getValue()).toEqual(14004.85);
-                    expect(activity.getStat(DataCadenceAvg.type).getValue()).toEqual(79);
-                    expect(activity.getStat(DataCadenceMax.type).getValue()).toEqual(111);
-                    expect(activity.getStat(DataHeartRateAvg.type).getValue()).toEqual(137);
-                    expect(activity.getStat(DataHeartRateMax.type).getValue()).toEqual(167);
-                    expect(activity.getStat(DataPaceAvg.type).getValue()).toBeGreaterThanOrEqual(activity.getStat(DataGradeAdjustedPaceAvg.type).getValue());
-                    SpecUtils.assertNearEqualTime(activity.getStat(DataPaceAvg.type).getValue(), '05:56', 1);
-                    SpecUtils.assertNearEqualTime(activity.getStat(DataGradeAdjustedPaceAvg.type).getValue(), '05:19', 1);
-                    const laps = activity.getLaps();
-                    expect(laps.length).toEqual(2);
-                    expect(laps[0].getStat(DataActiveLap.type).getValue()).toBeTruthy();
-                    expect(laps[1].getStat(DataActiveLap.type).getValue()).toBeTruthy();
-                    const movingTime = activity.getStat(DataMovingTime.type).getValue();
-                    const timerTime = activity.getStat(DataTimerTime.type).getValue();
-                    const pauseTime = activity.getStat(DataPause.type).getValue();
-                    const elapsedTime = activity.getDuration().getValue();
-                    SpecUtils.assertNearEqualTime(movingTime, '01:19:37');
-                    SpecUtils.assertNearEqualTime(timerTime, '01:23:09');
-                    SpecUtils.assertNearEqualTime(elapsedTime, '01:23:09');
-                    SpecUtils.assertEqual(pauseTime, elapsedTime - movingTime, 1);
-                    done();
-                }).catch((e) => done(e));
-            });
-            it('should parse running FIT file (Suunto export) (3)', done => {
-                // Given FIT Source (Suunto export): https://connect.garmin.com/modern/activity/6909950168 OR https://www.strava.com/activities/5423646653
-                const path = __dirname + '/fixtures/runs/fit/6909950168.fit';
-                const buffer = fs.readFileSync(path);
-                // When
-                const eventInterfacePromise = SportsLib.importFromFit(buffer);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    const activity = event.getFirstActivity();
-                    expect(activity.type).toEqual(ActivityTypes.TrailRunning);
-                    expect(activity.creator.name).toEqual('Suunto 9');
-                    expect(activity.creator.productId).toEqual(34);
-                    expect(activity.getStat(DataDistance.type).getValue()).toEqual(6458);
-                    expect(activity.getStat(DataEnergy.type).getValue()).toEqual(487);
-                    expect(activity.getStat(DataCadenceAvg.type).getValue()).toEqual(90);
-                    expect(activity.getStat(DataCadenceMax.type).getValue()).toEqual(94);
-                    expect(activity.getStat(DataPowerAvg.type).getValue()).toEqual(227);
-                    expect(activity.getStat(DataPowerMax.type).getValue()).toEqual(294);
-                    expect(activity.getStat(DataHeartRateAvg.type).getValue()).toEqual(148);
-                    expect(activity.getStat(DataHeartRateMax.type).getValue()).toEqual(161);
-                    expect(activity.getStat(DataPaceAvg.type).getValue()).toBeGreaterThanOrEqual(activity.getStat(DataGradeAdjustedPaceAvg.type).getValue());
-                    SpecUtils.assertNearEqualTime(activity.getStat(DataPaceAvg.type).getValue(), '05:35', 1);
-                    SpecUtils.assertNearEqualTime(activity.getStat(DataGradeAdjustedPaceAvg.type).getValue(), '05:34', 1);
-                    const movingTime = activity.getStat(DataMovingTime.type).getValue();
-                    const timerTime = activity.getStat(DataTimerTime.type).getValue();
-                    const pauseTime = activity.getStat(DataPause.type).getValue();
-                    const elapsedTime = activity.getDuration().getValue();
-                    SpecUtils.assertNearEqualTime(movingTime, '35:42');
-                    SpecUtils.assertNearEqualTime(timerTime, '36:01');
-                    SpecUtils.assertNearEqualTime(elapsedTime, '36:36');
-                    SpecUtils.assertEqual(pauseTime, elapsedTime - movingTime, 1);
-                    done();
-                }).catch((e) => done(e));
-            });
-            it('should parse running FIT file (Suunto export) (4)', done => {
-                // Given FIT Source (Suunto export): https://connect.garmin.com/modern/activity/6910052863 OR https://www.strava.com/activities/5423660493
-                const path = __dirname + '/fixtures/runs/fit/6910052863.fit';
-                const buffer = fs.readFileSync(path);
-                // When
-                const eventInterfacePromise = SportsLib.importFromFit(buffer);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    const activity = event.getFirstActivity();
-                    expect(activity.type).toEqual(ActivityTypes.TrailRunning);
-                    expect(activity.creator.name).toEqual('Suunto 9');
-                    expect(activity.getStat(DataDistance.type).getValue()).toEqual(8225);
-                    expect(activity.getStat(DataAscent.type).getValue()).toEqual(1817);
-                    expect(activity.getStat(DataEnergy.type).getValue()).toEqual(2540);
-                    expect(activity.getStat(DataCadenceAvg.type).getValue()).toEqual(44);
-                    expect(activity.getStat(DataCadenceMax.type).getValue()).toEqual(96);
-                    expect(activity.getStat(DataHeartRateAvg.type).getValue()).toEqual(164);
-                    expect(activity.getStat(DataHeartRateMax.type).getValue()).toEqual(174);
-                    expect(activity.getStat(DataPaceAvg.type).getValue()).toBeGreaterThanOrEqual(activity.getStat(DataGradeAdjustedPaceAvg.type).getValue());
-                    SpecUtils.assertNearEqualTime(activity.getStat(DataPaceAvg.type).getValue(), '19:20', 1);
-                    SpecUtils.assertNearEqualTime(activity.getStat(DataGradeAdjustedPaceAvg.type).getValue(), '07:32', 1);
-                    const movingTime = activity.getStat(DataMovingTime.type).getValue();
-                    const timerTime = activity.getStat(DataTimerTime.type).getValue();
-                    const pauseTime = activity.getStat(DataPause.type).getValue();
-                    const elapsedTime = activity.getDuration().getValue();
-                    SpecUtils.assertNearEqualTime(movingTime, '02:35:40');
-                    SpecUtils.assertNearEqualTime(timerTime, '02:39:03');
-                    SpecUtils.assertNearEqualTime(elapsedTime, '02:40:02');
-                    SpecUtils.assertEqual(pauseTime, elapsedTime - movingTime, 1);
-                    done();
-                }).catch((e) => done(e));
-            });
-            it('should parse running FIT file (Suunto export) (5)', done => {
-                // Given FIT Source (Suunto export): https://connect.garmin.com/modern/activity/6914448270 OR https://www.strava.com/activities/5427988571
-                const path = __dirname + '/fixtures/runs/fit/6914448270.fit';
-                const buffer = fs.readFileSync(path);
-                // When
-                const eventInterfacePromise = SportsLib.importFromFit(buffer);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    const activity = event.getFirstActivity();
-                    expect(activity.type).toEqual(ActivityTypes.Running);
-                    expect(activity.creator.name).toEqual('Suunto 9 Baroless');
-                    expect(activity.getStat(DataDistance.type).getValue()).toEqual(49897);
-                    expect(activity.getStat(DataAscent.type).getValue()).toEqual(1063);
-                    expect(activity.getStat(DataEnergy.type).getValue()).toEqual(4445);
-                    expect(activity.getStat(DataCadenceAvg.type).getValue()).toEqual(74);
-                    expect(activity.getStat(DataCadenceMax.type).getValue()).toEqual(119);
-                    expect(activity.getStat(DataPaceAvg.type).getValue()).toBeGreaterThanOrEqual(activity.getStat(DataGradeAdjustedPaceAvg.type).getValue());
-                    SpecUtils.assertNearEqualTime(activity.getStat(DataPaceAvg.type).getValue(), '06:49', 1);
-                    SpecUtils.assertNearEqualTime(activity.getStat(DataGradeAdjustedPaceAvg.type).getValue(), '06:20', 1);
-                    const movingTime = activity.getStat(DataMovingTime.type).getValue(); // TODO If moving time unknown or INVALID loop on all records in activity utils
-                    const timerTime = activity.getStat(DataTimerTime.type).getValue();
-                    const pauseTime = activity.getStat(DataPause.type).getValue();
-                    const elapsedTime = activity.getDuration().getValue();
-                    SpecUtils.assertNearEqualTime(movingTime, '05:28:14');
-                    SpecUtils.assertNearEqualTime(timerTime, '05:40:19');
-                    SpecUtils.assertNearEqualTime(elapsedTime, '05:40:19');
-                    SpecUtils.assertEqual(pauseTime, elapsedTime - movingTime, 1);
-                    done();
-                }).catch((e) => done(e));
-            });
-            it('should parse running FIT file (Suunto export) (6)', done => {
-                // Given FIT Source (Suunto export): https://connect.garmin.com/modern/activity/6914538454 OR https://www.strava.com/activities/5428064152
-                const path = __dirname + '/fixtures/runs/fit/6914538454.fit';
-                const buffer = fs.readFileSync(path);
-                // When
-                const eventInterfacePromise = SportsLib.importFromFit(buffer);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    const activity = event.getFirstActivity();
-                    expect(activity.type).toEqual(ActivityTypes.Running);
-                    expect(activity.creator.name).toEqual('Suunto 9 Baroless');
-                    expect(activity.creator.manufacturer).toEqual('suunto');
-                    expect(activity.getStat(DataDistance.type).getValue()).toEqual(4330);
-                    expect(activity.getStat(DataAscent.type).getValue()).toEqual(0);
-                    expect(activity.getStat(DataEnergy.type).getValue()).toEqual(354);
-                    expect(activity.getStat(DataCadenceAvg.type).getValue()).toEqual(87);
-                    expect(activity.getStat(DataCadenceMax.type).getValue()).toEqual(109);
-                    expect(activity.getStat(DataPaceAvg.type).getValue()).toBeGreaterThanOrEqual(activity.getStat(DataGradeAdjustedPaceAvg.type).getValue());
-                    SpecUtils.assertNearEqualTime(activity.getStat(DataPaceAvg.type).getValue(), '04:52', 1);
-                    const movingTime = activity.getStat(DataMovingTime.type).getValue();
-                    const timerTime = activity.getStat(DataTimerTime.type).getValue();
-                    const pauseTime = activity.getStat(DataPause.type).getValue();
-                    const elapsedTime = activity.getDuration().getValue();
-                    SpecUtils.assertNearEqualTime(movingTime, '18:51');
-                    SpecUtils.assertNearEqualTime(timerTime, '21:04');
-                    SpecUtils.assertNearEqualTime(elapsedTime, '21:04');
-                    SpecUtils.assertEqual(pauseTime, elapsedTime - movingTime, 1);
-                    done();
-                }).catch((e) => done(e));
-            });
-            it('should parse running FIT file (Coros export) (7)', done => {
-                // Given FIT Source (Coros export): https://connect.garmin.com/modern/activity/6916663933 OR https://www.strava.com/activities/5429996380
-                const path = __dirname + '/fixtures/runs/fit/6916663933.fit';
-                const buffer = fs.readFileSync(path);
-                // When
-                const eventInterfacePromise = SportsLib.importFromFit(buffer);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    const activity = event.getFirstActivity();
-                    expect(activity.type).toEqual(ActivityTypes.Running);
-                    expect(activity.creator.name).toEqual('Coros APEX Pro');
-                    expect(activity.creator.productId).toEqual(841);
-                    expect(activity.getStat(DataDistance.type).getValue()).toEqual(10743.64);
-                    expect(activity.getStat(DataAscent.type).getValue()).toEqual(142);
-                    expect(activity.getStat(DataEnergy.type).getValue()).toEqual(685);
-                    expect(activity.getStat(DataCadenceAvg.type).getValue()).toEqual(92);
-                    expect(activity.getStat(DataCadenceMax.type).getValue()).toEqual(106);
-                    expect(activity.getStat(DataHeartRateAvg.type).getValue()).toEqual(160);
-                    expect(activity.getStat(DataHeartRateMax.type).getValue()).toEqual(173);
-                    expect(activity.getStat(DataPowerAvg.type).getValue()).toEqual(332);
-                    expect(activity.getStat(DataPowerMax.type).getValue()).toEqual(518);
-                    expect(activity.getStat(DataPaceAvg.type).getValue()).toBeGreaterThanOrEqual(activity.getStat(DataGradeAdjustedPaceAvg.type).getValue());
-                    SpecUtils.assertNearEqualTime(activity.getStat(DataPaceAvg.type).getValue(), '04:31', 1);
-                    SpecUtils.assertNearEqualTime(activity.getStat(DataGradeAdjustedPaceAvg.type).getValue(), '04:24', 1);
-                    expect(activity.getStat(DataStanceTimeBalanceLeft.type).getValue()).toEqual(49.14);
-                    expect(activity.getStat(DataStanceTimeBalanceRight.type).getValue()).toEqual(50.86);
-                    expect(activity.getStat(DataStanceTime.type).getValue()).toEqual(206);
-                    expect(activity.getStat(DataVerticalOscillation.type).getValue()).toEqual(94);
-                    expect(activity.getStat(DataVerticalRatio.type).getValue()).toEqual(7.9);
-                    expect(activity.getStat(DataAvgStrideLength.type).getValue()).toEqual(1.2);
-                    const movingTime = activity.getStat(DataMovingTime.type).getValue();
-                    const timerTime = activity.getStat(DataTimerTime.type).getValue();
-                    const pauseTime = activity.getStat(DataPause.type).getValue();
-                    const elapsedTime = activity.getDuration().getValue();
-                    SpecUtils.assertNearEqualTime(movingTime, '48:35');
-                    SpecUtils.assertNearEqualTime(timerTime, '48:42');
-                    SpecUtils.assertNearEqualTime(elapsedTime, '48:42');
-                    SpecUtils.assertEqual(pauseTime, elapsedTime - movingTime, 1);
-                    done();
-                }).catch((e) => done(e));
-            });
-            it('should parse running FIT file (Coros export) (8)', done => {
-                // Given FIT Source (Coros export): https://connect.garmin.com/modern/activity/6916728382 OR https://www.strava.com/activities/5430055225
-                const path = __dirname + '/fixtures/runs/fit/6916728382.fit';
-                const buffer = fs.readFileSync(path);
-                // When
-                const eventInterfacePromise = SportsLib.importFromFit(buffer);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    const activity = event.getFirstActivity();
-                    expect(activity.type).toEqual(ActivityTypes.Running);
-                    expect(activity.creator.name).toEqual('Coros APEX Pro');
-                    expect(activity.creator.manufacturer).toEqual('coros');
-                    expect(activity.getStat(DataDistance.type).getValue()).toEqual(21524.3);
-                    expect(activity.getStat(DataAscent.type).getValue()).toEqual(539);
-                    expect(activity.getStat(DataEnergy.type).getValue()).toEqual(1661);
-                    expect(activity.getStat(DataCadenceAvg.type).getValue()).toEqual(71);
-                    expect(activity.getStat(DataCadenceMax.type).getValue()).toEqual(88);
-                    expect(activity.getStat(DataHeartRateAvg.type).getValue()).toEqual(131);
-                    expect(activity.getStat(DataHeartRateMax.type).getValue()).toEqual(164);
-                    expect(activity.getStat(DataTemperatureAvg.type).getValue()).toEqual(22);
-                    expect(activity.getStat(DataPaceAvg.type).getValue()).toBeGreaterThanOrEqual(activity.getStat(DataGradeAdjustedPaceAvg.type).getValue());
-                    SpecUtils.assertNearEqualTime(activity.getStat(DataPaceAvg.type).getValue(), '07:31', 1);
-                    const movingTime = activity.getStat(DataMovingTime.type).getValue();
-                    const timerTime = activity.getStat(DataTimerTime.type).getValue();
-                    const pauseTime = activity.getStat(DataPause.type).getValue();
-                    const elapsedTime = activity.getDuration().getValue();
-                    SpecUtils.assertNearEqualTime(movingTime, '02:39:59');
-                    SpecUtils.assertNearEqualTime(timerTime, '02:41:39');
-                    SpecUtils.assertNearEqualTime(elapsedTime, '02:41:39');
-                    SpecUtils.assertEqual(pauseTime, elapsedTime - movingTime, 1);
-                    done();
-                }).catch((e) => done(e));
-            });
-            it('should parse running treadmill FIT file (1)', done => {
-                // Given FIT Source: https://connect.garmin.com/modern/activity/6860622783 or https://www.strava.com/activities/5375834427
-                const path = __dirname + '/fixtures/runs/fit/6860622783.fit';
-                const buffer = fs.readFileSync(path);
-                // When
-                const eventInterfacePromise = SportsLib.importFromFit(buffer);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    const activity = event.getFirstActivity();
-                    expect(activity.type).toEqual(ActivityTypes.Treadmill);
-                    expect(activity.hasPowerMeter()).toBeTruthy();
-                    expect(activity.isTrainer()).toBeTruthy();
-                    expect(activity.getStat(DataDistance.type).getValue()).toEqual(10630.37);
-                    expect(activity.getStat(DataCadenceAvg.type).getValue()).toEqual(82);
-                    expect(activity.getStat(DataCadenceMax.type).getValue()).toEqual(128);
-                    expect(activity.getStat(DataHeartRateAvg.type).getValue()).toEqual(145);
-                    expect(activity.getStat(DataHeartRateMax.type).getValue()).toEqual(177);
-                    expect(activity.getStat(DataStanceTimeBalanceLeft.type).getValue()).toEqual(49.91);
-                    expect(activity.getStat(DataStanceTimeBalanceRight.type).getValue()).toEqual(50.09);
-                    expect(activity.getStat(DataStanceTime.type).getValue()).toEqual(271.3);
-                    expect(activity.getStat(DataVerticalOscillation.type).getValue()).toEqual(97.2);
-                    expect(activity.getStat(DataVerticalRatio.type).getValue()).toEqual(9.57);
-                    expect(activity.getStat(DataAvgStrideLength.type).getValue()).toEqual(1.04);
-                    expect(activity.getStat(DataTotalCycles.type).getValue()).toEqual(4242);
-                    expect(activity.getStat(DataAerobicTrainingEffect.type).getValue()).toEqual(2.2);
-                    expect(activity.getStat(DataAnaerobicTrainingEffect.type).getValue()).toEqual(1.8);
-                    expect(activity.getStat(DataPowerWork.type).getValue()).toEqual(692);
-                    SpecUtils.assertNearEqualTime(activity.getStat(DataPaceAvg.type).getValue(), '04:51', 1);
-                    const movingTime = activity.getStat(DataMovingTime.type).getValue();
-                    const timerTime = activity.getStat(DataTimerTime.type).getValue();
-                    const pauseTime = activity.getStat(DataPause.type).getValue();
-                    const elapsedTime = activity.getDuration().getValue();
-                    SpecUtils.assertNearEqualTime(movingTime, '48:43');
-                    SpecUtils.assertNearEqualTime(timerTime, '51:38');
-                    SpecUtils.assertNearEqualTime(elapsedTime, '01:02:44');
-                    SpecUtils.assertEqual(pauseTime, elapsedTime - movingTime, 1);
-                    done();
-                }).catch((e) => done(e));
-            });
-        });
-        describe('TCX', () => {
-            it('should parse running TCX file (1)', done => {
-                // Given Recorded with "Strava Android App" => https://connect.garmin.com/modern/activity/1604524853 OR https://www.strava.com/activities/708752345
-                const path = __dirname + '/fixtures/runs/tcx/1604524853.tcx';
-                const doc = domParser.parseFromString(fs.readFileSync(path).toString(), 'application/xml');
-                // When
-                const eventInterfacePromise = SportsLib.importFromTCX(doc);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    const activity = event.getFirstActivity();
-                    expect(activity.type).toEqual(ActivityTypes.run);
-                    SpecUtils.assertNearEqualTime(activity.getStat(DataPaceAvg.type).getValue(), '09:15', 1);
-                    SpecUtils.assertNearEqualTime(activity.getStat(DataGradeAdjustedPaceAvg.type).getValue(), '07:07', 1);
-                    SpecUtils.assertEqual(event.getFirstActivity().getStat(DataAscent.type).getValue(), 432);
-                    SpecUtils.assertEqual(event.getFirstActivity().getStat(DataDescent.type).getValue(), 440);
-                    expect(activity.getStat(DataDistance.type).getValue()).toEqual(6106.6);
-                    expect(activity.getStat(DataCadenceAvg.type).getValue()).toEqual(69);
-                    expect(activity.getStat(DataCadenceMax.type).getValue()).toEqual(99);
-                    expect(activity.getStat(DataHeartRateAvg.type).getValue()).toEqual(158);
-                    expect(activity.getStat(DataHeartRateMax.type).getValue()).toEqual(191);
-                    expect(activity.getStat(DataPaceAvg.type).getValue()).toBeGreaterThanOrEqual(activity.getStat(DataGradeAdjustedPaceAvg.type).getValue());
-                    const movingTime = activity.getStat(DataMovingTime.type).getValue();
-                    const timerTime = activity.getStat(DataTimerTime.type).getValue();
-                    const pauseTime = activity.getStat(DataPause.type).getValue();
-                    const elapsedTime = activity.getDuration().getValue();
-                    SpecUtils.assertNearEqualTime(movingTime, '58:59', 3);
-                    SpecUtils.assertNearEqualTime(timerTime, '01:07:47');
-                    SpecUtils.assertNearEqualTime(elapsedTime, '01:07:47');
-                    SpecUtils.assertEqual(pauseTime, elapsedTime - movingTime, 1);
-                    done();
-                }).catch((e) => done(e));
-            });
-            it('should parse running TCX file (2)', done => {
-                // Given TCX Source: https://connect.garmin.com/modern/activity/6851149716 OR  https://www.strava.com/activities/5366592367
-                // Given FIT Source: https://connect.garmin.com/modern/activity/6782987395 OR https://www.strava.com/activities/2451375851
-                const path = __dirname + '/fixtures/runs/tcx/6782987395.tcx';
-                const doc = domParser.parseFromString(fs.readFileSync(path).toString(), 'application/xml');
-                // When
-                const eventInterfacePromise = SportsLib.importFromTCX(doc);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    const activity = event.getFirstActivity();
-                    expect(activity.type).toEqual(ActivityTypes.run);
-                    expect(activity.creator.name).toEqual('Forerunner 945');
-                    SpecUtils.assertNearEqualTime(activity.getStat(DataPaceAvg.type).getValue(), '05:41');
-                    SpecUtils.assertNearEqualTime(activity.getStat(DataGradeAdjustedPaceAvg.type).getValue(), '05:19', 1);
-                    SpecUtils.assertEqual(activity.getStat(DataAscent.type).getValue(), 363);
-                    SpecUtils.assertEqual(activity.getStat(DataDescent.type).getValue(), 386);
-                    expect(activity.getStat(DataDistance.type).getValue()).toBeCloseTo(14004.85);
-                    expect(activity.getStat(DataEnergy.type).getValue()).toEqual(982);
-                    expect(activity.getStat(DataCadenceAvg.type).getValue()).toEqual(80);
-                    expect(activity.getStat(DataCadenceMax.type).getValue()).toEqual(111);
-                    expect(activity.getStat(DataHeartRateAvg.type).getValue()).toEqual(137);
-                    expect(activity.getStat(DataHeartRateMax.type).getValue()).toEqual(167);
-                    expect(activity.getStat(DataPaceAvg.type).getValue()).toBeGreaterThanOrEqual(activity.getStat(DataGradeAdjustedPaceAvg.type).getValue());
-                    const movingTime = activity.getStat(DataMovingTime.type).getValue();
-                    const timerTime = activity.getStat(DataTimerTime.type).getValue();
-                    const pauseTime = activity.getStat(DataPause.type).getValue();
-                    const elapsedTime = activity.getDuration().getValue();
-                    SpecUtils.assertNearEqualTime(movingTime, '01:19:38');
-                    SpecUtils.assertNearEqualTime(timerTime, '01:23:09');
-                    SpecUtils.assertNearEqualTime(elapsedTime, '01:23:09');
-                    SpecUtils.assertEqual(pauseTime, elapsedTime - movingTime, 1);
-                    done();
-                }).catch((e) => done(e));
-            });
-            it('should parse running TCX file (3)', done => {
-                // Given TCX Source: https://connect.garmin.com/modern/activity/6860622916 or https://www.strava.com/activities/5375754773
-                const path = __dirname + '/fixtures/runs/tcx/6860622916.tcx';
-                const doc = domParser.parseFromString(fs.readFileSync(path).toString(), 'application/xml');
-                // When
-                const eventInterfacePromise = SportsLib.importFromTCX(doc);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    const activity = event.getFirstActivity();
-                    expect(activity.type).toEqual(ActivityTypes.run);
-                    SpecUtils.assertNearEqualTime(activity.getStat(DataPaceAvg.type).getValue(), '04:25');
-                    SpecUtils.assertNearEqualTime(activity.getStat(DataGradeAdjustedPaceAvg.type).getValue(), '04:24');
-                    SpecUtils.assertEqual(activity.getStat(DataAscent.type).getValue(), 85);
-                    SpecUtils.assertEqual(activity.getStat(DataDescent.type).getValue(), 74);
-                    expect(activity.getStat(DataDistance.type).getValue()).toBeCloseTo(13973.09);
-                    expect(activity.getStat(DataEnergy.type).getValue()).toEqual(739);
-                    expect(activity.getStat(DataCadenceAvg.type).getValue()).toEqual(89);
-                    expect(activity.getStat(DataCadenceMax.type).getValue()).toEqual(98);
-                    expect(activity.getStat(DataHeartRateAvg.type).getValue()).toEqual(143);
-                    expect(activity.getStat(DataHeartRateMax.type).getValue()).toEqual(168);
-                    expect(activity.getStat(DataPaceAvg.type).getValue()).toBeGreaterThanOrEqual(activity.getStat(DataGradeAdjustedPaceAvg.type).getValue());
-                    const movingTime = activity.getStat(DataMovingTime.type).getValue();
-                    const timerTime = activity.getStat(DataTimerTime.type).getValue();
-                    const pauseTime = activity.getStat(DataPause.type).getValue();
-                    const elapsedTime = activity.getDuration().getValue();
-                    SpecUtils.assertNearEqualTime(movingTime, '01:02:17');
-                    SpecUtils.assertNearEqualTime(timerTime, '01:02:17');
-                    SpecUtils.assertNearEqualTime(elapsedTime, '01:02:17');
-                    SpecUtils.assertEqual(pauseTime, elapsedTime - movingTime, 1);
-                    done();
-                }).catch((e) => done(e));
-            });
-            it('should parse running TCX file (4)', done => {
-                // Given TCX Source: (garmin connect upload impossible) or https://www.strava.com/activities/6281425038
-                const path = __dirname + '/fixtures/runs/tcx/6281425038.tcx';
-                const doc = domParser.parseFromString(fs.readFileSync(path).toString(), 'application/xml');
-                // When
-                const eventInterfacePromise = SportsLib.importFromTCX(doc);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    const activity = event.getFirstActivity();
-                    expect(activity.type).toEqual(ActivityTypes.run);
-                    SpecUtils.assertNearEqualTime(activity.getStat(DataPaceAvg.type).getValue(), '06:19');
-                    SpecUtils.assertNearEqualTime(activity.getStat(DataGradeAdjustedPaceAvg.type).getValue(), '05:58');
-                    const laps = activity.getLaps();
-                    expect(laps.length).toEqual(5);
-                    const movingTime = activity.getStat(DataMovingTime.type).getValue();
-                    const timerTime = activity.getStat(DataTimerTime.type).getValue();
-                    const pauseTime = activity.getStat(DataPause.type).getValue();
-                    const elapsedTime = activity.getDuration().getValue();
-                    SpecUtils.assertNearEqualTime(movingTime, '25:45');
-                    SpecUtils.assertNearEqualTime(timerTime, '25:45');
-                    SpecUtils.assertNearEqualTime(elapsedTime, '36:02');
-                    SpecUtils.assertEqual(pauseTime, elapsedTime - movingTime, 1);
-                    done();
-                }).catch((e) => done(e));
-            });
-            it('should parse running treadmill TCX file (3)', done => {
-                // Given FIT Source: https://connect.garmin.com/modern/activity/6860622783 or https://www.strava.com/activities/5375834427
-                const path = __dirname + '/fixtures/runs/tcx/6860622783.tcx';
-                const doc = domParser.parseFromString(fs.readFileSync(path).toString(), 'application/xml');
-                // When
-                const eventInterfacePromise = SportsLib.importFromTCX(doc);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    const activity = event.getFirstActivity();
-                    expect(activity.type).toEqual(ActivityTypes.IndoorRunning);
-                    expect(activity.isTrainer()).toBeTruthy();
-                    expect(activity.getStat(DataDistance.type).getValue()).toEqual(10630.37);
-                    expect(activity.getStat(DataCadenceAvg.type).getValue()).toEqual(82);
-                    expect(activity.getStat(DataCadenceMax.type).getValue()).toEqual(128);
-                    expect(activity.getStat(DataHeartRateAvg.type).getValue()).toEqual(145);
-                    expect(activity.getStat(DataHeartRateMax.type).getValue()).toEqual(177);
-                    SpecUtils.assertNearEqualTime(activity.getStat(DataPaceAvg.type).getValue(), '04:51', 1);
-                    const movingTime = activity.getStat(DataMovingTime.type).getValue();
-                    const timerTime = activity.getStat(DataTimerTime.type).getValue();
-                    const pauseTime = activity.getStat(DataPause.type).getValue();
-                    const elapsedTime = activity.getDuration().getValue();
-                    SpecUtils.assertNearEqualTime(movingTime, '48:43');
-                    SpecUtils.assertNearEqualTime(timerTime, '51:38');
-                    SpecUtils.assertNearEqualTime(elapsedTime, '01:02:44');
-                    SpecUtils.assertEqual(pauseTime, elapsedTime - movingTime, 1);
-                    done();
-                }).catch((e) => done(e));
-            });
-        });
-        describe('GPX', () => {
-            it('should parse running GPX file (1)', done => {
-                // Given GPX Source: https://connect.garmin.com/modern/activity/6870534840 OR https://www.strava.com/activities/5385528846
-                // Given FIT Source: https://connect.garmin.com/modern/activity/2067489619 OR https://www.strava.com/activities/1221143311
-                const path = __dirname + '/fixtures/runs/gpx/2067489619.gpx';
-                const gpxString = fs.readFileSync(path).toString();
-                // When
-                const eventInterfacePromise = SportsLib.importFromGPX(gpxString, xmldom.DOMParser);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    // Swim
-                    const activity = event.getFirstActivity();
-                    expect(activity.type).toEqual(ActivityTypes.Running);
-                    SpecUtils.assertNearEqualTime(activity.getStat(DataPaceAvg.type).getValue(), '09:18', 1);
-                    SpecUtils.assertNearEqualTime(activity.getStat(DataGradeAdjustedPaceAvg.type).getValue(), '09:18', 1);
-                    expect(activity.getStat(DataDistance.type).getValue()).toBeCloseTo(4400, 0);
-                    expect(activity.getStat(DataAscent.type).getValue()).toBeCloseTo(35, 0);
-                    expect(activity.getStat(DataCadenceAvg.type).getValue()).toEqual(67);
-                    expect(activity.getStat(DataCadenceMax.type).getValue()).toEqual(88);
-                    expect(activity.getStat(DataHeartRateAvg.type).getValue()).toEqual(134);
-                    expect(activity.getStat(DataHeartRateMax.type).getValue()).toEqual(178);
-                    expect(activity.getStat(DataPaceAvg.type).getValue()).toBeGreaterThanOrEqual(activity.getStat(DataGradeAdjustedPaceAvg.type).getValue());
-                    const movingTime = activity.getStat(DataMovingTime.type).getValue();
-                    const timerTime = activity.getStat(DataTimerTime.type).getValue();
-                    const pauseTime = activity.getStat(DataPause.type).getValue();
-                    const elapsedTime = activity.getDuration().getValue();
-                    SpecUtils.assertNearEqualTime(movingTime, '44:48');
-                    SpecUtils.assertNearEqualTime(timerTime, '47:00');
-                    SpecUtils.assertNearEqualTime(elapsedTime, '47:04');
-                    SpecUtils.assertEqual(pauseTime, elapsedTime - movingTime, 1);
-                    done();
-                }).catch((e) => done(e));
-            });
-            it('should parse running GPX file (2)', done => {
-                // Given GPX Source: https://connect.garmin.com/modern/activity/6870566668 OR https://www.strava.com/activities/5385561485
-                // Given FIT Source: https://connect.garmin.com/modern/activity/6782987395 OR https://www.strava.com/activities/2451375851
-                const path = __dirname + '/fixtures/runs/gpx/6782987395.gpx';
-                const gpxString = fs.readFileSync(path).toString();
-                // When
-                const eventInterfacePromise = SportsLib.importFromGPX(gpxString, xmldom.DOMParser);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    const activity = event.getFirstActivity();
-                    expect(activity.type).toEqual(ActivityTypes.Running);
-                    SpecUtils.assertNearEqualTime(activity.getStat(DataPaceAvg.type).getValue(), '05:53', 1);
-                    SpecUtils.assertNearEqualTime(activity.getStat(DataGradeAdjustedPaceAvg.type).getValue(), '05:18', 1);
-                    expect(activity.getStat(DataDistance.type).getValue()).toBeCloseTo(14170.5, 0);
-                    expect(activity.getStat(DataAscent.type).getValue()).toBeCloseTo(363, 0);
-                    expect(activity.getStat(DataCadenceAvg.type).getValue()).toEqual(82);
-                    expect(activity.getStat(DataCadenceMax.type).getValue()).toEqual(111);
-                    expect(activity.getStat(DataHeartRateAvg.type).getValue()).toEqual(137);
-                    expect(activity.getStat(DataHeartRateMax.type).getValue()).toEqual(167);
-                    expect(activity.getStat(DataPaceAvg.type).getValue()).toBeGreaterThanOrEqual(activity.getStat(DataGradeAdjustedPaceAvg.type).getValue());
-                    const movingTime = activity.getStat(DataMovingTime.type).getValue();
-                    const timerTime = activity.getStat(DataTimerTime.type).getValue();
-                    const pauseTime = activity.getStat(DataPause.type).getValue();
-                    const elapsedTime = activity.getDuration().getValue();
-                    SpecUtils.assertNearEqualTime(movingTime, '01:17:11');
-                    SpecUtils.assertNearEqualTime(timerTime, '01:23:09');
-                    SpecUtils.assertNearEqualTime(elapsedTime, '01:23:09');
-                    SpecUtils.assertEqual(pauseTime, elapsedTime - movingTime, 1);
-                    done();
-                }).catch((e) => done(e));
-            });
-            it('should parse running GPX file (3)', done => {
-                // Given Recorded with "Strava Android App" => https://connect.garmin.com/modern/activity/1681613317 OR https://www.strava.com/activities/906581465
-                const path = __dirname + '/fixtures/runs/gpx/1681613317.gpx';
-                const gpxString = fs.readFileSync(path).toString();
-                // When
-                const eventInterfacePromise = SportsLib.importFromGPX(gpxString, xmldom.DOMParser);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    const activity = event.getFirstActivity();
-                    expect(activity.type).toEqual(ActivityTypes.run);
-                    expect(activity.hasPowerMeter()).toBeFalsy();
-                    expect(activity.isTrainer()).toBeFalsy();
-                    SpecUtils.assertNearEqualTime(activity.getStat(DataPaceAvg.type).getValue(), '06:27', 1);
-                    SpecUtils.assertNearEqualTime(activity.getStat(DataGradeAdjustedPaceAvg.type).getValue(), '06:23', 1);
-                    expect(activity.getStat(DataDistance.type).getValue()).toBeCloseTo(4593, 0);
-                    expect(activity.getStat(DataAscent.type).getValue()).toBeCloseTo(39, 0);
-                    expect(activity.getStat(DataCadenceAvg.type).getValue()).toEqual(79);
-                    expect(activity.getStat(DataCadenceMax.type).getValue()).toEqual(96);
-                    expect(activity.getStat(DataHeartRateAvg.type).getValue()).toEqual(146);
-                    expect(activity.getStat(DataHeartRateMax.type).getValue()).toEqual(176);
-                    expect(activity.getStat(DataPaceAvg.type).getValue()).toBeGreaterThanOrEqual(activity.getStat(DataGradeAdjustedPaceAvg.type).getValue());
-                    const movingTime = activity.getStat(DataMovingTime.type).getValue();
-                    const timerTime = activity.getStat(DataTimerTime.type).getValue();
-                    const pauseTime = activity.getStat(DataPause.type).getValue();
-                    const elapsedTime = activity.getDuration().getValue();
-                    SpecUtils.assertNearEqualTime(movingTime, '32:09');
-                    SpecUtils.assertNearEqualTime(timerTime, '32:38');
-                    SpecUtils.assertNearEqualTime(elapsedTime, '32:38');
-                    SpecUtils.assertEqual(pauseTime, elapsedTime - movingTime, 1);
-                    done();
-                }).catch((e) => done(e));
-            });
-            it('should parse running GPX file (4)', done => {
-                // Given Recorded with "MyTracks" => https://connect.garmin.com/modern/activity/6909258631 OR https://www.strava.com/activities/5422847134
-                const path = __dirname + '/fixtures/runs/gpx/6909258631.gpx';
-                const gpxString = fs.readFileSync(path).toString();
-                // When
-                const eventInterfacePromise = SportsLib.importFromGPX(gpxString, xmldom.DOMParser);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    const activity = event.getFirstActivity();
-                    // expect(activity.type).toEqual(ActivityTypes.run); // TODO To be auto-detected by sports-data-science library (work in progress)
-                    expect(activity.getStat(DataDistance.type).getValue()).toBeCloseTo(40878.5, 1);
-                    expect(activity.getStat(DataAscent.type).getValue()).toBeCloseTo(2780, 0);
-                    expect(activity.getStat(DataAscent.type).getValue()).toBeCloseTo(2780, 0);
-                    SpecUtils.assertNearEqualTime(activity.getStat(DataPaceAvg.type).getValue(), '07:22', 1);
-                    const movingTime = activity.getStat(DataMovingTime.type).getValue();
-                    const timerTime = activity.getStat(DataTimerTime.type).getValue();
-                    const pauseTime = activity.getStat(DataPause.type).getValue();
-                    const elapsedTime = activity.getDuration().getValue();
-                    SpecUtils.assertNearEqualTime(movingTime, '04:51:49');
-                    SpecUtils.assertNearEqualTime(timerTime, '06:30:22');
-                    SpecUtils.assertNearEqualTime(elapsedTime, '06:30:22');
-                    SpecUtils.assertEqual(pauseTime, elapsedTime - movingTime, 1);
-                    done();
-                }).catch((e) => done(e));
-            });
-            it('should parse running GPX file (5)', done => {
-                // Given https://connect.garmin.com/modern/activity/6048438275 OR https://www.strava.com/activities/3497177564
-                const path = __dirname + '/fixtures/runs/gpx/6048438275.gpx';
-                const gpxString = fs.readFileSync(path).toString();
-                // When
-                const eventInterfacePromise = SportsLib.importFromGPX(gpxString, xmldom.DOMParser);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    const activity = event.getFirstActivity();
-                    expect(activity.type).toEqual(ActivityTypes.run);
-                    expect(activity.hasPowerMeter()).toBeFalsy();
-                    expect(activity.isTrainer()).toBeFalsy();
-                    SpecUtils.assertNearEqual(activity.getStat(DataDistance.type).getValue(), 16771.3, 1, 1);
-                    expect(activity.getStat(DataAscent.type).getValue()).toBeCloseTo(579, 0);
-                    expect(activity.getStat(DataCadenceAvg.type).getValue()).toEqual(86);
-                    expect(activity.getStat(DataCadenceMax.type).getValue()).toEqual(123);
-                    SpecUtils.assertNearEqualTime(activity.getStat(DataPaceAvg.type).getValue(), '04:48', 1);
-                    SpecUtils.assertNearEqualTime(activity.getStat(DataGradeAdjustedPaceAvg.type).getValue(), '04:17', 1);
-                    expect(activity.getStat(DataPaceAvg.type).getValue()).toBeGreaterThanOrEqual(activity.getStat(DataGradeAdjustedPaceAvg.type).getValue());
-                    expect(activity.getSquashedStreamData('Distance').length).toEqual(activity.getSquashedStreamData('Speed').length);
-                    const movingTime = activity.getStat(DataMovingTime.type).getValue();
-                    const timerTime = activity.getStat(DataTimerTime.type).getValue();
-                    const pauseTime = activity.getStat(DataPause.type).getValue();
-                    const elapsedTime = activity.getDuration().getValue();
-                    SpecUtils.assertNearEqualTime(movingTime, '01:04:19');
-                    SpecUtils.assertNearEqualTime(timerTime, '01:22:50');
-                    SpecUtils.assertNearEqualTime(elapsedTime, '01:22:50');
-                    SpecUtils.assertEqual(pauseTime, elapsedTime - movingTime, 1);
-                    done();
-                }).catch((e) => done(e));
-            });
-            it('should parse running GPX file (6)', done => {
-                // Given https://www.strava.com/activities/3632493456 or https://connect.garmin.com/modern/activity/6037744996
-                const path = __dirname + '/fixtures/runs/gpx/6037744996.gpx';
-                const gpxString = fs.readFileSync(path).toString();
-                // When
-                const eventInterfacePromise = SportsLib.importFromGPX(gpxString, xmldom.DOMParser);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    const activity = event.getFirstActivity();
-                    expect(activity.type).toEqual(ActivityTypes.run);
-                    expect(activity.hasPowerMeter()).toBeFalsy();
-                    expect(activity.isTrainer()).toBeFalsy();
-                    SpecUtils.assertNearEqual(activity.getStat(DataDistance.type).getValue(), 5115.1, 1, 1);
-                    expect(activity.getStat(DataAscent.type).getValue()).toBeCloseTo(516, 0);
-                    expect(activity.getStat(DataCadenceAvg.type).getValue()).toEqual(68);
-                    expect(activity.getStat(DataCadenceMax.type).getValue()).toEqual(124);
-                    expect(activity.getStat(DataPaceAvg.type).getValue()).toBeGreaterThanOrEqual(activity.getStat(DataGradeAdjustedPaceAvg.type).getValue());
-                    SpecUtils.assertNearEqualTime(activity.getStat(DataPaceAvg.type).getValue(), '13:10', 1);
-                    SpecUtils.assertNearEqualTime(activity.getStat(DataGradeAdjustedPaceAvg.type).getValue(), '09:07', 1);
-                    const movingTime = activity.getStat(DataMovingTime.type).getValue();
-                    const timerTime = activity.getStat(DataTimerTime.type).getValue();
-                    const pauseTime = activity.getStat(DataPause.type).getValue();
-                    const elapsedTime = activity.getDuration().getValue();
-                    SpecUtils.assertNearEqualTime(movingTime, '28:35');
-                    SpecUtils.assertNearEqualTime(timerTime, '01:07:19');
-                    SpecUtils.assertNearEqualTime(elapsedTime, '01:07:19');
-                    SpecUtils.assertEqual(pauseTime, elapsedTime - movingTime, 1);
-                    done();
-                }).catch((e) => done(e));
-            });
-        });
-    });
-    describe('Cycling', () => {
-        describe('FIT', () => {
-            it('should parse cycling FIT file (1)', done => {
-                // Given FIT Source: https://connect.garmin.com/modern/activity/3939576645 OR https://www.strava.com/activities/2610176355
-                const path = __dirname + '/fixtures/rides/fit/3939576645.fit';
-                const buffer = fs.readFileSync(path);
-                const expectedSamplesLength = 2547;
-                // When
-                const eventInterfacePromise = SportsLib.importFromFit(buffer);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    // Verify streams consistency
-                    const activity = event.getFirstActivity();
-                    expect(activity.creator.name).toEqual('Garmin Edge 1000');
-                    expect(activity.generateTimeStream([DataDistance.type]).getData(true).length).toEqual(expectedSamplesLength);
-                    expect(activity.hasPowerMeter()).toBeFalsy();
-                    expect(activity.isTrainer()).toBeFalsy();
-                    expect(activity.getSquashedStreamData(DataLongitudeDegrees.type).length).toEqual(expectedSamplesLength);
-                    expect(activity.getSquashedStreamData(DataLatitudeDegrees.type).length).toEqual(expectedSamplesLength);
-                    expect(activity.getSquashedStreamData(DataDistance.type).length).toEqual(expectedSamplesLength);
-                    expect(activity.getSquashedStreamData(DataAltitude.type).length).toEqual(expectedSamplesLength);
-                    expect(activity.getSquashedStreamData(DataAltitudeSmooth.type).length).toEqual(expectedSamplesLength);
-                    expect(activity.getSquashedStreamData(DataSpeed.type).length).toEqual(expectedSamplesLength);
-                    expect(activity.getSquashedStreamData(DataCadence.type).length).toEqual(expectedSamplesLength);
-                    expect(activity.getSquashedStreamData(DataHeartRate.type).length).toEqual(expectedSamplesLength);
-                    expect(activity.getSquashedStreamData(DataGrade.type).length).toEqual(expectedSamplesLength);
-                    const missingStreamCall = () => {
-                        activity.getSquashedStreamData(DataPower.type);
-                    };
-                    expect(missingStreamCall).toThrow();
-                    // Verify global activity stats
-                    expect(activity.type).toEqual(ActivityTypes.Cycling);
-                    expect(activity.getStat(DataDistance.type).getValue()).toEqual(42220.87);
-                    expect(activity.getStat(DataAscent.type).getValue()).toEqual(668);
-                    expect(activity.getStat(DataDescent.type).getValue()).toEqual(664);
-                    expect(activity.getStat(DataEnergy.type).getValue()).toEqual(1497);
-                    expect(activity.getStat(DataCadenceAvg.type).getValue()).toEqual(68);
-                    expect(activity.getStat(DataCadenceMax.type).getValue()).toEqual(109);
-                    expect(activity.getStat(DataHeartRateAvg.type).getValue()).toEqual(155);
-                    expect(activity.getStat(DataHeartRateMax.type).getValue()).toEqual(186);
-                    expect(activity.getStat(DataSpeedAvg.type).getValue()).toEqual(5.812); // Or 20.9 kph
-                    expect(activity.getStat(DataTotalCycles.type).getValue()).toEqual(6550);
-                    // Verifying time data
-                    const movingTime = activity.getStat(DataMovingTime.type).getValue();
-                    const timerTime = activity.getStat(DataTimerTime.type).getValue();
-                    const pauseTime = activity.getStat(DataPause.type).getValue();
-                    const elapsedTime = activity.getDuration().getValue();
-                    SpecUtils.assertNearEqualTime(movingTime, '02:00:42', 1);
-                    SpecUtils.assertNearEqualTime(timerTime, '02:01:04');
-                    SpecUtils.assertNearEqualTime(elapsedTime, '02:04:36');
-                    SpecUtils.assertEqual(pauseTime, elapsedTime - movingTime, 1);
-                    done();
-                }).catch((e) => done(e));
-            });
-            it('should parse cycling FIT file (2)', done => {
-                // Given FIT Source: https://connect.garmin.com/modern/activity/828989227 OR https://www.strava.com/activities/343080886
-                const path = __dirname + '/fixtures/rides/fit/828989227.fit';
-                const buffer = fs.readFileSync(path);
-                // When
-                const eventInterfacePromise = SportsLib.importFromFit(buffer);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    const activity = event.getFirstActivity();
-                    expect(activity.type).toEqual(ActivityTypes.Cycling);
-                    expect(activity.creator.name).toEqual('Garmin Edge 810');
-                    expect(activity.hasPowerMeter()).toBeFalsy();
-                    expect(activity.getStat(DataDistance.type).getValue()).toEqual(141944.2);
-                    expect(activity.getStat(DataAscent.type).getValue()).toEqual(2052);
-                    expect(activity.getStat(DataDescent.type).getValue()).toEqual(2028);
-                    expect(activity.getStat(DataEnergy.type).getValue()).toEqual(2629);
-                    expect(activity.getStat(DataCadenceAvg.type).getValue()).toEqual(79);
-                    expect(activity.getStat(DataCadenceMax.type).getValue()).toEqual(118);
-                    expect(activity.getStat(DataHeartRateAvg.type).getValue()).toEqual(148);
-                    expect(activity.getStat(DataHeartRateMax.type).getValue()).toEqual(174);
-                    expect(activity.getStat(DataSpeedAvg.type).getValue()).toEqual(7.219); // Or 26 kph
-                    const movingTime = activity.getStat(DataMovingTime.type).getValue();
-                    const timerTime = activity.getStat(DataTimerTime.type).getValue();
-                    const pauseTime = activity.getStat(DataPause.type).getValue();
-                    const elapsedTime = activity.getDuration().getValue();
-                    SpecUtils.assertNearEqualTime(movingTime, '05:26:49');
-                    SpecUtils.assertNearEqualTime(timerTime, '05:27:44');
-                    SpecUtils.assertNearEqualTime(elapsedTime, '06:07:08');
-                    SpecUtils.assertEqual(pauseTime, elapsedTime - movingTime, 1);
-                    done();
-                }).catch((e) => done(e));
-            });
-            it('should parse cycling FIT file (3)', done => {
-                // Given FIT Source: https://connect.garmin.com/modern/activity/614953343 OR https://www.strava.com/activities/208748758
-                const path = __dirname + '/fixtures/rides/fit/614953343.fit';
-                const buffer = fs.readFileSync(path);
-                // When
-                const eventInterfacePromise = SportsLib.importFromFit(buffer);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    const activity = event.getFirstActivity();
-                    expect(activity.creator.name).toEqual('Garmin Edge 800');
-                    expect(activity.hasPowerMeter()).toBeFalsy();
-                    const movingTime = activity.getStat(DataMovingTime.type).getValue();
-                    const timerTime = activity.getStat(DataTimerTime.type).getValue();
-                    const pauseTime = activity.getStat(DataPause.type).getValue();
-                    const elapsedTime = activity.getDuration().getValue();
-                    SpecUtils.assertNearEqualTime(movingTime, '05:52:28', 1);
-                    SpecUtils.assertNearEqualTime(timerTime, '05:54:34');
-                    SpecUtils.assertNearEqualTime(elapsedTime, '07:04:31');
-                    SpecUtils.assertEqual(pauseTime, elapsedTime - movingTime, 1);
-                    done();
-                }).catch((e) => done(e));
-            });
-            it('should parse cycling FIT file (4)', done => {
-                // Given FIT Source: https://connect.garmin.com/modern/activity/6783622686 OR https://www.strava.com/activities/5300988022
-                const path = __dirname + '/fixtures/rides/fit/6783622686.fit';
-                const buffer = fs.readFileSync(path);
-                // When
-                const eventInterfacePromise = SportsLib.importFromFit(buffer);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    const activity = event.getFirstActivity();
-                    expect(activity.creator.name).toEqual('Garmin Edge 1030');
-                    const movingTime = activity.getStat(DataMovingTime.type).getValue();
-                    const timerTime = activity.getStat(DataTimerTime.type).getValue();
-                    const pauseTime = activity.getStat(DataPause.type).getValue();
-                    const elapsedTime = activity.getDuration().getValue();
-                    SpecUtils.assertNearEqualTime(movingTime, '05:07:53');
-                    SpecUtils.assertNearEqualTime(timerTime, '05:08:22');
-                    SpecUtils.assertNearEqualTime(elapsedTime, '07:26:55');
-                    SpecUtils.assertEqual(pauseTime, elapsedTime - movingTime, 1);
-                    done();
-                }).catch((e) => done(e));
-            });
-            it('should parse cycling FIT file (5)', done => {
-                // Given FIT Source: https://connect.garmin.com/modern/activity/7386755164 OR https://www.strava.com/activities/5952147686
-                const path = __dirname + '/fixtures/rides/fit/7386755164.fit';
-                const buffer = fs.readFileSync(path);
-                // When
-                const eventInterfacePromise = SportsLib.importFromFit(buffer);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    const activity = event.getFirstActivity();
-                    expect(activity.creator.name).toEqual('Garmin Edge 1030');
-                    // Power extended stats
-                    expect(activity.getStat(DataLeftBalance.type).getValue()).toEqual(51.45);
-                    expect(activity.getStat(DataRightBalance.type).getValue()).toEqual(48.55);
-                    expect(activity.getStat(DataPowerTorqueEffectivenessLeft.type).getValue()).toEqual(80);
-                    expect(activity.getStat(DataPowerTorqueEffectivenessRight.type).getValue()).toEqual(76.5);
-                    expect(activity.getStat(DataPowerPedalSmoothnessLeft.type).getValue()).toEqual(22);
-                    expect(activity.getStat(DataPowerPedalSmoothnessRight.type).getValue()).toEqual(20.5);
-                    expect(activity.getStat(DataPowerNormalized.type).getValue()).toEqual(179);
-                    expect(activity.getStat(DataPowerIntensityFactor.type).getValue()).toEqual(0.786);
-                    expect(activity.getStat(DataPowerTrainingStressScore.type).getValue()).toEqual(105.4);
-                    expect(activity.getStat(DataPowerWork.type).getValue()).toEqual(832);
-                    // Cycling dynamics: Power "position" stats
-                    SpecUtils.assertNearEqualTime(activity.getStat(DataCyclingStandingTime.type).getValue(), '17:53', 0);
-                    SpecUtils.assertNearEqualTime(activity.getStat(DataCyclingSeatedTime.type).getValue(), '01:25:02', 0);
-                    done();
-                }).catch((e) => done(e));
-            });
-            it('should parse cycling FIT file (6)', done => {
-                // Given FIT Source: https://connect.garmin.com/modern/activity/7445393868 OR https://www.strava.com/activities/5921768617
-                const path = __dirname + '/fixtures/rides/fit/7445393868.fit';
-                const buffer = fs.readFileSync(path);
-                // When
-                const eventInterfacePromise = SportsLib.importFromFit(buffer);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    const activity = event.getFirstActivity();
-                    expect(activity.creator.name).toEqual('Garmin Edge 1000');
-                    expect(activity.hasPowerMeter()).toBeTruthy();
-                    expect(activity.getStat(DataLeftBalance.type).getValue()).toEqual(45.91);
-                    expect(activity.getStat(DataRightBalance.type).getValue()).toEqual(54.09);
-                    expect(activity.getStat(DataPowerTorqueEffectivenessLeft.type).getValue()).toEqual(71);
-                    expect(activity.getStat(DataPowerTorqueEffectivenessRight.type).getValue()).toEqual(73);
-                    expect(activity.getStat(DataPowerPedalSmoothnessLeft.type).getValue()).toEqual(20);
-                    expect(activity.getStat(DataPowerPedalSmoothnessRight.type).getValue()).toEqual(21.5);
-                    expect(activity.getStat(DataPowerNormalized.type).getValue()).toEqual(147);
-                    expect(activity.getStat(DataPowerIntensityFactor.type).getValue()).toEqual(0.733);
-                    expect(activity.getStat(DataPowerTrainingStressScore.type).getValue()).toEqual(48.3);
-                    expect(activity.getStat(DataPowerWork.type).getValue()).toEqual(417);
-                    done();
-                }).catch((e) => done(e));
-            });
-            it('should parse cycling FIT file (7)', done => {
-                // Given FIT Source: https://connect.garmin.com/modern/activity/7432332116 OR https://www.strava.com/activities/5910143591
-                const path = __dirname + '/fixtures/rides/fit/7432332116.fit';
-                const buffer = fs.readFileSync(path);
-                const expectedSamplesLength = 10063;
-                // When
-                const eventInterfacePromise = SportsLib.importFromFit(buffer);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    const activity = event.getFirstActivity();
-                    expect(activity.creator.name).toEqual('Garmin Edge 1000');
-                    expect(activity.hasPowerMeter()).toBeTruthy();
-                    expect(activity.getStat(DataPowerAvg.type).getValue()).toEqual(152);
-                    expect(activity.getStat(DataPowerNormalized.type).getValue()).toEqual(172);
-                    expect(activity.getStat(DataPowerMax.type).getValue()).toEqual(564);
-                    expect(activity.getSquashedStreamData(DataLongitudeDegrees.type).length).toEqual(expectedSamplesLength);
-                    expect(activity.getSquashedStreamData(DataLatitudeDegrees.type).length).toEqual(expectedSamplesLength);
-                    expect(activity.getSquashedStreamData(DataDistance.type).length).toEqual(expectedSamplesLength);
-                    expect(activity.getSquashedStreamData(DataAltitude.type).length).toEqual(expectedSamplesLength);
-                    expect(activity.getSquashedStreamData(DataSpeed.type).length).toEqual(expectedSamplesLength);
-                    expect(activity.getSquashedStreamData(DataCadence.type).length).toEqual(expectedSamplesLength);
-                    expect(activity.getSquashedStreamData(DataHeartRate.type).length).toEqual(expectedSamplesLength);
-                    expect(activity.getSquashedStreamData(DataPower.type).length).toEqual(expectedSamplesLength);
-                    done();
-                }).catch((e) => done(e));
-            });
-            it('should parse cycling FIT file (8)', done => {
-                // Given FIT Source: https://connect.garmin.com/modern/activity/7739869618 OR https://www.strava.com/activities/2380240532
-                const path = __dirname + '/fixtures/rides/fit/7739869618.fit';
-                const buffer = fs.readFileSync(path);
-                // When
-                const eventInterfacePromise = SportsLib.importFromFit(buffer);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    const activity = event.getFirstActivity();
-                    expect(activity.creator.name).toEqual('Wahoo ELEMNT BOLT');
-                    expect(activity.creator.manufacturer).toEqual('wahoo_fitness');
-                    expect(activity.creator.isRecognized).toBeTruthy();
-                    done();
-                }).catch((e) => done(e));
-            });
-            it('should parse cycling FIT file (9)', done => {
-                // Given FIT Source: https://connect.garmin.com/modern/activity/5319808632 OR https://www.strava.com/activities/3849490840
-                const path = __dirname + '/fixtures/rides/fit/5319808632.fit';
-                const buffer = fs.readFileSync(path);
-                // When
-                const eventInterfacePromise = SportsLib.importFromFit(buffer);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    const activity = event.getFirstActivity();
-                    expect(activity.startDate.toISOString()).toEqual('2020-07-26T15:28:41.000Z');
-                    expect(activity.endDate.toISOString()).toEqual('2020-07-26T16:31:26.063Z');
-                    done();
-                }).catch((e) => done(e));
-            });
-            it('should parse virtual cycling FIT file (1)', done => {
-                // Given FIT Source: https://connect.garmin.com/modern/activity/971150603 OR https://www.strava.com/activities/442080924
-                const path = __dirname + '/fixtures/rides/fit/971150603.fit';
-                const buffer = fs.readFileSync(path);
-                const expectedSamplesLength = 3806;
-                // When
-                const eventInterfacePromise = SportsLib.importFromFit(buffer);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    // Verify streams consistency
-                    const activity = event.getFirstActivity();
-                    expect(activity.creator.name).toEqual('Zwift');
-                    expect(activity.creator.productId).toEqual(15706);
-                    expect(activity.creator.isRecognized).toBeTruthy();
-                    expect(activity.generateTimeStream([DataDistance.type]).getData(true).length).toEqual(expectedSamplesLength);
-                    expect(activity.hasPowerMeter()).toBeTruthy();
-                    expect(activity.isTrainer()).toBeFalsy();
-                    expect(activity.getSquashedStreamData(DataLongitudeDegrees.type).length).toEqual(expectedSamplesLength);
-                    expect(activity.getSquashedStreamData(DataLatitudeDegrees.type).length).toEqual(expectedSamplesLength);
-                    expect(activity.getSquashedStreamData(DataDistance.type).length).toEqual(expectedSamplesLength);
-                    expect(activity.getSquashedStreamData(DataAltitude.type).length).toEqual(expectedSamplesLength);
-                    expect(activity.getSquashedStreamData(DataSpeed.type).length).toEqual(expectedSamplesLength);
-                    expect(activity.getSquashedStreamData(DataCadence.type).length).toEqual(expectedSamplesLength);
-                    expect(activity.getSquashedStreamData(DataHeartRate.type).length).toEqual(expectedSamplesLength);
-                    expect(activity.getSquashedStreamData(DataPower.type).length).toEqual(expectedSamplesLength);
-                    // Verify global activity stats
-                    expect(activity.type).toEqual(ActivityTypes.Cycling);
-                    expect(activity.getStat(DataDistance.type).getValue()).toEqual(32227.5);
-                    SpecUtils.assertEqual(activity.getStat(DataAscent.type).getValue(), 242, 0);
-                    expect(activity.getStat(DataEnergy.type)).toBeUndefined(); // Zwift didn't give the calories
-                    expect(activity.getStat(DataCadenceAvg.type).getValue()).toEqual(76);
-                    expect(activity.getStat(DataCadenceMax.type).getValue()).toEqual(114);
-                    expect(activity.getStat(DataHeartRateAvg.type).getValue()).toEqual(148);
-                    expect(activity.getStat(DataHeartRateMax.type).getValue()).toEqual(180);
-                    expect(activity.getStat(DataSpeedAvg.type).getValue()).toEqual(8.476); // Or 30.5 kph
-                    expect(activity.getStat(DataPowerAvg.type).getValue()).toEqual(143);
-                    expect(activity.getStat(DataPowerMax.type).getValue()).toEqual(381);
-                    // Verifying time data
-                    const movingTime = activity.getStat(DataMovingTime.type).getValue();
-                    const timerTime = activity.getStat(DataTimerTime.type).getValue();
-                    const pauseTime = activity.getStat(DataPause.type).getValue();
-                    const elapsedTime = activity.getDuration().getValue();
-                    SpecUtils.assertNearEqualTime(movingTime, '01:02:53', 1);
-                    SpecUtils.assertNearEqualTime(timerTime, '01:03:35');
-                    SpecUtils.assertNearEqualTime(elapsedTime, '01:03:42');
-                    SpecUtils.assertEqual(pauseTime, elapsedTime - movingTime, 1);
-                    done();
-                }).catch((e) => done(e));
-            });
-        });
-        describe('TCX', () => {
-            it('should parse cycling TCX file (1)', done => {
-                // Given TCX Source: https://connect.garmin.com/modern/activity/6791039036 OR https://www.strava.com/activities/5308417342
-                // Given FIT Source: https://connect.garmin.com/modern/activity/3939576645 OR https://www.strava.com/activities/2610176355
-                const path = __dirname + '/fixtures/rides/tcx/6791039036.tcx';
-                const doc = domParser.parseFromString(fs.readFileSync(path).toString(), 'application/xml');
-                // When
-                const eventInterfacePromise = SportsLib.importFromTCX(doc);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    // Verify global activity stats
-                    const activity = event.getFirstActivity();
-                    expect(activity.type).toEqual(ActivityTypes.Cycling);
-                    expect(activity.creator.name).toEqual('Garmin Edge 1000');
-                    SpecUtils.assertEqual(activity.getStat(DataAscent.type).getValue(), 672, 0);
-                    SpecUtils.assertEqual(activity.getStat(DataDescent.type).getValue(), 664);
-                    expect(activity.getStat(DataDistance.type).getValue()).toEqual(42220.87);
-                    expect(activity.getStat(DataEnergy.type).getValue()).toEqual(1497);
-                    expect(activity.getStat(DataCadenceAvg.type).getValue()).toEqual(69);
-                    expect(activity.getStat(DataCadenceMax.type).getValue()).toEqual(108);
-                    expect(activity.getStat(DataHeartRateAvg.type).getValue()).toEqual(153);
-                    expect(activity.getStat(DataHeartRateMax.type).getValue()).toEqual(186);
-                    expect(activity.getStat(DataSpeedAvg.type).getValue()).toBeCloseTo(6.536); // Or 23.5 kph
-                    // Verifying time data
-                    const movingTime = activity.getStat(DataMovingTime.type).getValue();
-                    const timerTime = activity.getStat(DataTimerTime.type).getValue();
-                    const pauseTime = activity.getStat(DataPause.type).getValue();
-                    const elapsedTime = activity.getDuration().getValue();
-                    SpecUtils.assertNearEqualTime(movingTime, '02:01:59', 1);
-                    SpecUtils.assertNearEqualTime(timerTime, '02:01:04');
-                    SpecUtils.assertNearEqualTime(elapsedTime, '02:04:36');
-                    SpecUtils.assertEqual(pauseTime, elapsedTime - movingTime, 1);
-                    done();
-                }).catch((e) => done(e));
-            });
-            it('should parse cycling TCX file (2)', done => {
-                // Given TCX Source: https://connect.garmin.com/modern/activity/6838497277 or https://www.strava.com/activities/5354278524
-                // Given FIT Source: https://connect.garmin.com/modern/activity/3953195468 or https://www.strava.com/activities/2621275265
-                const path = __dirname + '/fixtures/rides/tcx/6838497277.tcx';
-                const doc = domParser.parseFromString(fs.readFileSync(path).toString(), 'application/xml');
-                // When
-                const eventInterfacePromise = SportsLib.importFromTCX(doc);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    const activity = event.getFirstActivity();
-                    expect(activity.type).toEqual(ActivityTypes.Cycling);
-                    expect(activity.hasPowerMeter()).toBeFalsy();
-                    expect(activity.isTrainer()).toBeFalsy();
-                    SpecUtils.assertEqual(activity.getStat(DataAscent.type).getValue(), 685, 0);
-                    SpecUtils.assertEqual(activity.getStat(DataDescent.type).getValue(), 670);
-                    expect(activity.getStat(DataDistance.type).getValue()).toEqual(59853.31);
-                    expect(activity.getStat(DataEnergy.type).getValue()).toEqual(2206);
-                    expect(activity.getStat(DataCadenceAvg.type).getValue()).toEqual(68);
-                    expect(activity.getStat(DataCadenceMax.type).getValue()).toEqual(109);
-                    expect(activity.getStat(DataHeartRateAvg.type).getValue()).toEqual(160);
-                    expect(activity.getStat(DataHeartRateMax.type).getValue()).toEqual(192);
-                    expect(activity.getStat(DataSpeedAvg.type).getValue()).toBeCloseTo(6.278); // 22.6 kph
-                    // Verifying time data
-                    const movingTime = activity.getStat(DataMovingTime.type).getValue();
-                    const timerTime = activity.getStat(DataTimerTime.type).getValue();
-                    const pauseTime = activity.getStat(DataPause.type).getValue();
-                    const elapsedTime = activity.getDuration().getValue();
-                    SpecUtils.assertNearEqualTime(movingTime, '02:52:10', 1.5);
-                    SpecUtils.assertNearEqualTime(timerTime, '02:55:15');
-                    SpecUtils.assertNearEqualTime(elapsedTime, '02:55:15');
-                    SpecUtils.assertEqual(pauseTime, elapsedTime - movingTime, 1);
-                    done();
-                }).catch((e) => done(e));
-            });
-            it('should parse cycling TCX file (3)', done => {
-                // Given TCX Source: https://connect.garmin.com/modern/activity/7555170032 or https://www.strava.com/activities/6020442882
-                // Given FIT Source: https://connect.garmin.com/modern/activity/7432332116 OR https://www.strava.com/activities/5910143591
-                const path = __dirname + '/fixtures/rides/tcx/7555170032.tcx';
-                const doc = domParser.parseFromString(fs.readFileSync(path).toString(), 'application/xml');
-                const expectedSamplesLength = 10063;
-                // When
-                const eventInterfacePromise = SportsLib.importFromTCX(doc);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    const activity = event.getFirstActivity();
-                    expect(activity.creator.name).toEqual('Garmin Edge 1000');
-                    expect(activity.hasPowerMeter()).toBeTruthy();
-                    expect(activity.getStat(DataPowerAvg.type).getValue()).toBeCloseTo(152, 0);
-                    expect(activity.getStat(DataPowerNormalized.type).getValue()).toBeCloseTo(171, 0);
-                    expect(activity.getStat(DataPowerMax.type).getValue()).toEqual(564);
-                    expect(activity.getSquashedStreamData(DataLongitudeDegrees.type).length).toEqual(expectedSamplesLength);
-                    expect(activity.getSquashedStreamData(DataLatitudeDegrees.type).length).toEqual(expectedSamplesLength);
-                    expect(activity.getSquashedStreamData(DataDistance.type).length).toEqual(expectedSamplesLength);
-                    expect(activity.getSquashedStreamData(DataAltitude.type).length).toEqual(expectedSamplesLength);
-                    expect(activity.getSquashedStreamData(DataSpeed.type).length).toEqual(expectedSamplesLength);
-                    expect(activity.getSquashedStreamData(DataCadence.type).length).toEqual(expectedSamplesLength);
-                    expect(activity.getSquashedStreamData(DataHeartRate.type).length).toEqual(expectedSamplesLength);
-                    expect(activity.getSquashedStreamData(DataPower.type).length).toEqual(expectedSamplesLength);
-                    done();
-                }).catch((e) => done(e));
-            });
-            it('should parse virtual cycling TCX file (1)', done => {
-                // Given https://connect.garmin.com/modern/activity/6823905801 OR https://www.strava.com/activities/5340305665
-                const path = __dirname + '/fixtures/rides/tcx/6823905801.tcx';
-                const doc = domParser.parseFromString(fs.readFileSync(path).toString(), 'application/xml');
-                // When
-                const eventInterfacePromise = SportsLib.importFromTCX(doc);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    const activity = event.getFirstActivity();
-                    expect(activity.hasPowerMeter()).toBeTruthy();
-                    expect(activity.isTrainer()).toBeFalsy();
-                    // Verify global activity stats
-                    expect(activity.type).toEqual(ActivityTypes.Cycling);
-                    expect(activity.getStat(DataDistance.type).getValue()).toEqual(32227.5);
-                    SpecUtils.assertEqual(activity.getStat(DataAscent.type).getValue(), 242);
-                    expect(activity.getStat(DataEnergy.type)).toBeUndefined(); // Zwift didn't give the calories
-                    expect(activity.getStat(DataCadenceAvg.type).getValue()).toEqual(76);
-                    expect(activity.getStat(DataCadenceMax.type).getValue()).toEqual(114);
-                    expect(activity.getStat(DataHeartRateAvg.type).getValue()).toEqual(148);
-                    expect(activity.getStat(DataHeartRateMax.type).getValue()).toEqual(180);
-                    expect(activity.getStat(DataSpeedAvg.type).getValue()).toBeCloseTo(8.47, 3); // Or 30.5 kph
-                    SpecUtils.assertEqual(activity.getStat(DataPowerAvg.type).getValue(), 143);
-                    expect(activity.getStat(DataPowerMax.type).getValue()).toEqual(381);
-                    // Verifying time data
-                    const movingTime = activity.getStat(DataMovingTime.type).getValue();
-                    const timerTime = activity.getStat(DataTimerTime.type).getValue();
-                    const pauseTime = activity.getStat(DataPause.type).getValue();
-                    const elapsedTime = activity.getDuration().getValue();
-                    SpecUtils.assertNearEqualTime(movingTime, '01:03:10', 1);
-                    SpecUtils.assertNearEqualTime(timerTime, '01:03:35');
-                    SpecUtils.assertNearEqualTime(elapsedTime, '01:03:42');
-                    SpecUtils.assertEqual(pauseTime, elapsedTime - movingTime, 1);
-                    done();
-                }).catch((e) => done(e));
-            });
-        });
-        describe('GPX', () => {
-            it('should parse cycling GPX file (1)', done => {
-                // Given GPX Source: https://connect.garmin.com/modern/activity/6870609105 OR https://www.strava.com/activities/5385601807
-                // Given FIT Source: https://connect.garmin.com/modern/activity/3939576645 OR https://www.strava.com/activities/2610176355
-                const path = __dirname + '/fixtures/rides/gpx/3939576645.gpx';
-                const gpxString = fs.readFileSync(path).toString();
-                // When
-                const eventInterfacePromise = SportsLib.importFromGPX(gpxString, xmldom.DOMParser);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    const activity = event.getFirstActivity();
-                    expect(activity.type).toEqual(ActivityTypes.Cycling);
-                    expect(activity.hasPowerMeter()).toBeFalsy();
-                    expect(activity.getStat(DataDistance.type).getValue()).toBeCloseTo(41829, 0);
-                    expect(activity.getStat(DataAscent.type).getValue()).toBeCloseTo(672, 0);
-                    expect(activity.getStat(DataDescent.type).getValue()).toBeCloseTo(664, 0);
-                    expect(activity.getStat(DataCadenceAvg.type).getValue()).toEqual(69);
-                    expect(activity.getStat(DataCadenceMax.type).getValue()).toEqual(108);
-                    expect(activity.getStat(DataHeartRateAvg.type).getValue()).toEqual(153);
-                    expect(activity.getStat(DataHeartRateMax.type).getValue()).toEqual(186);
-                    expect(activity.getStat(DataSpeedAvg.type).getValue()).toBeCloseTo(6.479); // Or 23.32 kph
-                    // Verifying time data
-                    const movingTime = activity.getStat(DataMovingTime.type).getValue();
-                    const timerTime = activity.getStat(DataTimerTime.type).getValue();
-                    const pauseTime = activity.getStat(DataPause.type).getValue();
-                    const elapsedTime = activity.getDuration().getValue();
-                    SpecUtils.assertNearEqualTime(movingTime, '02:00:42', 1.5);
-                    SpecUtils.assertNearEqualTime(timerTime, '02:04:35');
-                    SpecUtils.assertNearEqualTime(elapsedTime, '02:04:36');
-                    SpecUtils.assertEqual(pauseTime, elapsedTime - movingTime, 1);
-                    done();
-                }).catch((e) => done(e));
-            });
-            it('should parse cycling GPX file (2)', done => {
-                // Given GPX Source: https://connect.garmin.com/modern/activity/6870692308 OR https://www.strava.com/activities/5385683390
-                // Given FIT Source: https://connect.garmin.com/modern/activity/828989227 OR https://www.strava.com/activities/343080886
-                const path = __dirname + '/fixtures/rides/gpx/828989227.gpx';
-                const gpxString = fs.readFileSync(path).toString();
-                // When
-                const eventInterfacePromise = SportsLib.importFromGPX(gpxString, xmldom.DOMParser);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    const activity = event.getFirstActivity();
-                    expect(activity.type).toEqual(ActivityTypes.Cycling);
-                    expect(activity.hasPowerMeter()).toBeFalsy();
-                    expect(activity.getStat(DataDistance.type).getValue()).toBeCloseTo(141975, 0);
-                    expect(activity.getStat(DataAscent.type).getValue()).toBeCloseTo(2052, 0);
-                    expect(activity.getStat(DataDescent.type).getValue()).toBeCloseTo(2034, 0);
-                    expect(activity.getStat(DataCadenceAvg.type).getValue()).toEqual(79);
-                    expect(activity.getStat(DataCadenceMax.type).getValue()).toEqual(118);
-                    expect(activity.getStat(DataHeartRateAvg.type).getValue()).toEqual(148);
-                    expect(activity.getStat(DataHeartRateMax.type).getValue()).toEqual(174);
-                    expect(activity.getStat(DataSpeedAvg.type).getValue()).toBeCloseTo(7.329); // Or 26.3 kph
-                    const movingTime = activity.getStat(DataMovingTime.type).getValue();
-                    const timerTime = activity.getStat(DataTimerTime.type).getValue();
-                    const pauseTime = activity.getStat(DataPause.type).getValue();
-                    const elapsedTime = activity.getDuration().getValue();
-                    SpecUtils.assertNearEqualTime(movingTime, '05:26:49', 2);
-                    SpecUtils.assertNearEqualTime(timerTime, '06:07:13');
-                    SpecUtils.assertNearEqualTime(elapsedTime, '06:07:13');
-                    SpecUtils.assertEqual(pauseTime, elapsedTime - movingTime, 1);
-                    done();
-                }).catch((e) => done(e));
-            });
-            it('should parse cycling GPX file (3)', done => {
-                // Given GPX Source: https://connect.garmin.com/modern/activity/6905455978 OR https://www.strava.com/activities/5419099678
-                // Given FIT Source: https://connect.garmin.com/modern/activity/4108490848 OR https://www.strava.com/activities/2749884297
-                const path = __dirname + '/fixtures/rides/gpx/4108490848.gpx';
-                const gpxString = fs.readFileSync(path).toString();
-                // When
-                const eventInterfacePromise = SportsLib.importFromGPX(gpxString, xmldom.DOMParser);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    const activity = event.getFirstActivity();
-                    expect(activity.name).toEqual('Meylan Road Cycling');
-                    expect(activity.type).toEqual(ActivityTypes.Cycling);
-                    expect(activity.getStat(DataDistance.type).getValue()).toBeCloseTo(49909, 0);
-                    expect(activity.getStat(DataAscent.type).getValue()).toBeCloseTo(292, 0);
-                    expect(activity.getStat(DataDescent.type).getValue()).toBeCloseTo(283, 0);
-                    expect(activity.getStat(DataCadenceAvg.type).getValue()).toEqual(76);
-                    expect(activity.getStat(DataCadenceMax.type).getValue()).toEqual(117);
-                    expect(activity.getStat(DataHeartRateAvg.type).getValue()).toEqual(165);
-                    expect(activity.getStat(DataHeartRateMax.type).getValue()).toEqual(186);
-                    expect(activity.getStat(DataSpeedAvg.type).getValue()).toBeCloseTo(7.903); // Or 28.4 kph
-                    const movingTime = activity.getStat(DataMovingTime.type).getValue();
-                    const timerTime = activity.getStat(DataTimerTime.type).getValue();
-                    const pauseTime = activity.getStat(DataPause.type).getValue();
-                    const elapsedTime = activity.getDuration().getValue();
-                    SpecUtils.assertNearEqualTime(movingTime, '01:47:13', 1);
-                    SpecUtils.assertNearEqualTime(timerTime, '01:49:20');
-                    SpecUtils.assertNearEqualTime(elapsedTime, '01:49:20');
-                    SpecUtils.assertEqual(pauseTime, elapsedTime - movingTime, 1);
-                    done();
-                }).catch((e) => done(e));
-            });
-            it('should parse cycling GPX file (4)', done => {
-                // Given GPX Source: https://connect.garmin.com/modern/activity/7555261629 or https://www.strava.com/activities/6020530554
-                // Given FIT Source: https://connect.garmin.com/modern/activity/7432332116 OR https://www.strava.com/activities/5910143591
-                const path = __dirname + '/fixtures/rides/gpx/7555261629.gpx';
-                const gpxString = fs.readFileSync(path).toString();
-                const expectedSamplesLength = 10063;
-                // When
-                const eventInterfacePromise = SportsLib.importFromGPX(gpxString, xmldom.DOMParser);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    const activity = event.getFirstActivity();
-                    expect(activity.hasPowerMeter()).toBeTruthy();
-                    expect(activity.getStat(DataPowerAvg.type).getValue()).toBeCloseTo(152, 0);
-                    expect(activity.getStat(DataPowerNormalized.type).getValue()).toBeCloseTo(171, 0);
-                    expect(activity.getStat(DataPowerMax.type).getValue()).toEqual(564);
-                    expect(activity.getSquashedStreamData(DataLongitudeDegrees.type).length).toEqual(expectedSamplesLength);
-                    expect(activity.getSquashedStreamData(DataLatitudeDegrees.type).length).toEqual(expectedSamplesLength);
-                    expect(activity.getSquashedStreamData(DataDistance.type).length).toEqual(expectedSamplesLength);
-                    expect(activity.getSquashedStreamData(DataAltitude.type).length).toEqual(expectedSamplesLength);
-                    expect(activity.getSquashedStreamData(DataSpeed.type).length).toEqual(expectedSamplesLength);
-                    expect(activity.getSquashedStreamData(DataCadence.type).length).toEqual(expectedSamplesLength);
-                    expect(activity.getSquashedStreamData(DataHeartRate.type).length).toEqual(expectedSamplesLength);
-                    expect(activity.getSquashedStreamData(DataPower.type).length).toEqual(expectedSamplesLength);
-                    done();
-                }).catch((e) => done(e));
-            });
-            it('should parse virtual cycling GPX file (1)', done => {
-                // Given GPX Source: https://connect.garmin.com/modern/activity/6909869014 OR https://www.strava.com/activities/5423473093
-                // Given FIT Source: https://connect.garmin.com/modern/activity/1137672073 OR https://www.strava.com/activities/553573871
-                const path = __dirname + '/fixtures/rides/gpx/6909869014.gpx';
-                const gpxString = fs.readFileSync(path).toString();
-                // When
-                const eventInterfacePromise = SportsLib.importFromGPX(gpxString, xmldom.DOMParser);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    const activity = event.getFirstActivity();
-                    expect(activity.type).toEqual(ActivityTypes.VirtualCycling);
-                    expect(activity.hasPowerMeter()).toBeTruthy();
-                    expect(activity.isTrainer()).toBeTruthy();
-                    expect(activity.getStat(DataDistance.type).getValue()).toBeCloseTo(28620, 0);
-                    expect(activity.getStat(DataAscent.type).getValue()).toBeCloseTo(271, 0);
-                    expect(activity.getStat(DataDescent.type).getValue()).toBeCloseTo(257, 0);
-                    expect(activity.getStat(DataCadenceAvg.type).getValue()).toEqual(75);
-                    expect(activity.getStat(DataCadenceMax.type).getValue()).toEqual(120);
-                    expect(activity.getStat(DataHeartRateAvg.type).getValue()).toEqual(161);
-                    expect(activity.getStat(DataHeartRateMax.type).getValue()).toEqual(184);
-                    expect(activity.getStat(DataPowerAvg.type).getValue()).toBeCloseTo(142, 0);
-                    expect(activity.getStat(DataPowerMax.type).getValue()).toBeCloseTo(330);
-                    expect(activity.getStat(DataSpeedAvg.type).getValue()).toBeCloseTo(7.55); // Or 27.2 kph
-                    const movingTime = activity.getStat(DataMovingTime.type).getValue();
-                    const timerTime = activity.getStat(DataTimerTime.type).getValue();
-                    const pauseTime = activity.getStat(DataPause.type).getValue();
-                    const elapsedTime = activity.getDuration().getValue();
-                    SpecUtils.assertNearEqualTime(movingTime, '01:02:58', 1);
-                    SpecUtils.assertNearEqualTime(timerTime, '01:03:09');
-                    SpecUtils.assertNearEqualTime(elapsedTime, '01:03:09');
-                    SpecUtils.assertEqual(pauseTime, elapsedTime - movingTime, 1);
-                    done();
-                }).catch((e) => done(e));
-            });
-        });
-    });
-    describe('Triathlon', () => {
-        describe('FIT', () => {
-            it('should parse a .FIT Triathlon IronMan w/ 3 activities (swim + ride + run) ', done => {
-                // Given https://connect.garmin.com/modern/activity/4623204522 ; https://www.strava.com/activities/5352030147 + https://www.strava.com/activities/5352030778 + https://www.strava.com/activities/5352030764
-                const path = __dirname + '/fixtures/triathlons/fit/4623204522.fit';
-                const buffer = fs.readFileSync(path);
-                const activitiesCount = 5;
-                // When
-                const eventInterfacePromise = SportsLib.importFromFit(buffer);
-                // Then
-                eventInterfacePromise.then((event) => {
-                    expect(event.getActivities().length).toEqual(activitiesCount);
-                    // Swim
-                    const swimActivity = event.getFirstActivity();
-                    expect(swimActivity.type).toEqual(ActivityTypes.OpenWaterSwimming);
-                    expect(swimActivity.getStreamData(DataSpeed.type).length).toEqual(3689);
-                    expect(swimActivity.startDate.toISOString()).toEqual('2018-10-13T17:05:01.000Z');
-                    expect(swimActivity.endDate.toISOString()).toEqual('2018-10-13T18:06:29.000Z');
-                    expect(swimActivity.getStat(DataDistance.type).getValue()).toEqual(3933.3);
-                    expect(swimActivity.getStat(DataEnergy.type).getValue()).toEqual(869);
-                    expect(swimActivity.getStat(DataCadenceAvg.type).getValue()).toEqual(37);
-                    expect(swimActivity.getStat(DataCadenceMax.type).getValue()).toEqual(48);
-                    expect(swimActivity.getStat(DataHeartRateAvg.type).getValue()).toEqual(93);
-                    expect(swimActivity.getStat(DataHeartRateMax.type).getValue()).toEqual(112);
-                    expect(swimActivity.getStat(DataTotalCycles.type).getValue()).toEqual(2294);
-                    SpecUtils.assertNearEqualTime(SpecUtils.speedToSwimPace(swimActivity.getStat(DataSpeedAvg.type).getValue()), '01:34');
-                    // Verifying time data
-                    let movingTime = swimActivity.getStat(DataMovingTime.type).getValue();
-                    let timerTime = swimActivity.getStat(DataTimerTime.type).getValue();
-                    let pauseTime = swimActivity.getStat(DataPause.type).getValue();
-                    let elapsedTime = swimActivity.getDuration().getValue();
-                    SpecUtils.assertNearEqualTime(movingTime, '01:01:16', 1);
-                    SpecUtils.assertNearEqualTime(timerTime, '01:01:29');
-                    SpecUtils.assertNearEqualTime(elapsedTime, '01:01:29');
-                    SpecUtils.assertEqual(pauseTime, elapsedTime - movingTime, 1);
-                    // Transition
-                    let transition = event.getActivities()[1];
-                    expect(transition.type).toEqual(ActivityTypes.Transition);
-                    // Cycling
-                    const cyclingActivity = event.getActivities()[2];
-                    expect(cyclingActivity.type).toEqual(ActivityTypes.Cycling);
-                    expect(cyclingActivity.getStreamData(DataSpeed.type).length).toEqual(17250);
-                    expect(cyclingActivity.startDate.toISOString()).toEqual('2018-10-13T18:10:15.000Z');
-                    expect(cyclingActivity.endDate.toISOString()).toEqual('2018-10-13T22:57:44.000Z');
-                    expect(cyclingActivity.getStat(DataDistance.type).getValue()).toEqual(180301.58);
-                    expect(cyclingActivity.getStat(DataEnergy.type).getValue()).toEqual(3804);
-                    expect(cyclingActivity.getStat(DataCadenceAvg.type).getValue()).toEqual(89);
-                    expect(cyclingActivity.getStat(DataCadenceMax.type).getValue()).toEqual(117);
-                    expect(cyclingActivity.getStat(DataHeartRateAvg.type).getValue()).toEqual(140);
-                    expect(cyclingActivity.getStat(DataHeartRateMax.type).getValue()).toEqual(153);
-                    expect(cyclingActivity.getStat(DataTotalCycles.type).getValue()).toEqual(24373);
-                    expect(cyclingActivity.getStat(DataSpeedAvg.type).getValue()).toBeCloseTo(10.453, 2); // Or 37.6 kph
-                    // Verifying time data
-                    movingTime = cyclingActivity.getStat(DataMovingTime.type).getValue();
-                    timerTime = cyclingActivity.getStat(DataTimerTime.type).getValue();
-                    pauseTime = cyclingActivity.getStat(DataPause.type).getValue();
-                    elapsedTime = cyclingActivity.getDuration().getValue();
-                    SpecUtils.assertNearEqualTime(movingTime, '04:42:28', 1);
-                    SpecUtils.assertNearEqualTime(timerTime, '04:47:29');
-                    SpecUtils.assertNearEqualTime(elapsedTime, '04:47:29');
-                    SpecUtils.assertEqual(pauseTime, elapsedTime - movingTime);
-                    transition = event.getActivities()[3];
-                    expect(transition.type).toEqual(ActivityTypes.Transition);
-                    const runningActivity = event.getActivities()[4];
-                    expect(runningActivity.type).toEqual(ActivityTypes.Running);
-                    expect(runningActivity.startDate.toISOString()).toEqual('2018-10-13T22:57:45.000Z');
-                    expect(runningActivity.endDate.toISOString()).toEqual('2018-10-14T02:42:23.000Z');
-                    expect(runningActivity.getStat(DataDistance.type).getValue()).toEqual(42563.91);
-                    expect(runningActivity.getStat(DataEnergy.type).getValue()).toEqual(2056);
-                    expect(runningActivity.getStat(DataCadenceAvg.type).getValue()).toEqual(84);
-                    expect(runningActivity.getStat(DataCadenceMax.type).getValue()).toEqual(116);
-                    expect(runningActivity.getStat(DataHeartRateAvg.type).getValue()).toEqual(142);
-                    expect(runningActivity.getStat(DataHeartRateMax.type).getValue()).toEqual(151);
-                    SpecUtils.assertNearEqualTime(runningActivity.getStat(DataPaceAvg.type).getValue(), '05:08', 1);
-                    // Verifying time data
-                    movingTime = runningActivity.getStat(DataMovingTime.type).getValue();
-                    timerTime = runningActivity.getStat(DataTimerTime.type).getValue();
-                    pauseTime = runningActivity.getStat(DataPause.type).getValue();
-                    elapsedTime = runningActivity.getDuration().getValue();
-                    SpecUtils.assertNearEqualTime(movingTime, '03:36:57', 1);
-                    SpecUtils.assertNearEqualTime(timerTime, '03:38:13');
-                    SpecUtils.assertNearEqualTime(elapsedTime, '03:39:01');
-                    SpecUtils.assertEqual(pauseTime, elapsedTime - movingTime, 1);
-                    done();
-                }).catch((e) => done(e));
-            });
-        });
-    });
-    describe('Others', () => {
-        it('should reject parsing of broken fit file (empty activities)', done => {
-            // Given
-            const path = __dirname + '/fixtures/others/empty-activities.fit';
-            const buffer = fs.readFileSync(path);
-            const expectedErrorMessage = 'No activities found';
-            const expectedErrorClassName = 'EmptyEventLibError';
-            const expectedCode = 'EVENT_EMPTY_ERROR';
-            // When
-            const eventInterfacePromise = SportsLib.importFromFit(buffer);
-            // Then
-            eventInterfacePromise.then(() => {
-                throw new Error('Should not be resolved...');
-            }, (err) => {
-                expect(err.constructor.name).toEqual(expectedErrorClassName);
-                expect(err.message).toEqual(expectedErrorMessage);
-                expect(err.code).toEqual(expectedCode);
-                expect(err.event).toBeNull();
-                done();
-            });
-        });
-        it('should reject parsing of broken fit file (empty sessions)', done => {
-            // Given
-            const path = __dirname + '/fixtures/others/empty-sessions.fit';
-            const buffer = fs.readFileSync(path);
-            const expectedErrorMessage = 'No activities found';
-            const expectedErrorClassName = 'EmptyEventLibError';
-            const expectedCode = 'EVENT_EMPTY_ERROR';
-            // When
-            const eventInterfacePromise = SportsLib.importFromFit(buffer);
-            // Then
-            eventInterfacePromise.then(() => {
-                throw new Error('Should not be resolved...');
-            }, (err) => {
-                expect(err.constructor.name).toEqual(expectedErrorClassName);
-                expect(err.message).toEqual(expectedErrorMessage);
-                expect(err.code).toEqual(expectedCode);
-                expect(err.event).toBeNull();
-                done();
-            });
-        });
-        it('should parse fit file with broken sessionObject.start_time date', done => {
-            // Given
-            const path = __dirname + '/fixtures/others/broken-dates.fit';
-            const buffer = fs.readFileSync(path);
-            // When
-            const eventInterfacePromise = SportsLib.importFromFit(buffer);
-            // Then
-            eventInterfacePromise.then(event => {
-                expect(event.startDate.toISOString()).toEqual('2017-03-20T19:09:28.000Z');
-                expect(event.endDate.toISOString()).toEqual('2017-03-20T19:20:26.083Z');
-                done();
-            });
-        });
-        it('should handle activity with broken start lat/lng', done => {
-            // Given FIT Source: https://connect.garmin.com/modern/activity/7606651718 OR https://www.strava.com/activities/6066984530
-            const path = __dirname + '/fixtures/others/broken-start-latlng.fit';
-            const buffer = fs.readFileSync(path);
-            // When
-            const eventInterfacePromise = SportsLib.importFromFit(buffer);
-            // Then
-            eventInterfacePromise.then((event) => {
-                const activity = event.getFirstActivity();
-                const longStream = activity.getSquashedStreamData(DataLongitudeDegrees.type);
-                const latStream = activity.getSquashedStreamData(DataLatitudeDegrees.type);
-                expect(longStream[0]).not.toEqual(0);
-                expect(latStream[0]).not.toEqual(0);
-                done();
-            });
-        });
-        it('should reject parsing of a too long activity (31 days)', done => {
-            // Given
-            const path = __dirname + '/fixtures/others/31-days-activity.fit';
-            const buffer = fs.readFileSync(path);
-            const expectedErrorMessage = 'Activity duration exceeds 14 days. That is not supported';
-            const expectedErrorClassName = 'DurationExceededEventLibError';
-            const expectedCode = 'DURATION_EXCEEDED_EVENT_ERROR';
-            // When
-            const eventInterfacePromise = SportsLib.importFromFit(buffer);
-            // Then
-            eventInterfacePromise.then(() => {
-                throw new Error('Should not be resolved...');
-            }, (err) => {
-                expect(err.constructor.name).toEqual(expectedErrorClassName);
-                expect(err.message).toEqual(expectedErrorMessage);
-                expect(err.code).toEqual(expectedCode);
-                expect(err.event).toBeNull();
-                done();
-            });
-        });
-        it('should handle inverted elapsed and timer time', done => {
-            // Given FIT Source: https://connect.garmin.com/modern/activity/7852903753 OR https://www.strava.com/activities/6288405028
-            const path = __dirname + '/fixtures/others/inverted-times.fit';
-            const buffer = fs.readFileSync(path);
-            // When
-            const eventInterfacePromise = SportsLib.importFromFit(buffer);
-            // Then
-            eventInterfacePromise.then((event) => {
-                const activity = event.getFirstActivity();
-                // Verifying time data
-                const movingTime = activity.getStat(DataMovingTime.type).getValue();
-                const timerTime = activity.getStat(DataTimerTime.type).getValue();
-                const elapsedTime = activity.getDuration().getValue();
-                SpecUtils.assertNearEqualTime(movingTime, '47:20', 1);
-                SpecUtils.assertNearEqualTime(timerTime, '47:20');
-                SpecUtils.assertNearEqualTime(elapsedTime, '06:01:20');
-                done();
-            });
-        });
-        it('should handle calculation on a ultra long activity (27 days) with acceptable human time', done => {
-            // Given FIT Source: https://connect.garmin.com/modern/activity/7769719668 OR https://www.strava.com/activities/6197356353
-            const path = __dirname + '/fixtures/others/27-days-activity.fit';
-            const buffer = fs.readFileSync(path);
-            const options = ActivityParsingOptions.DEFAULT;
-            options.maxActivityDurationDays = 30;
-            const expectedSamplesLength = 3699;
-            // When
-            const eventInterfacePromise = SportsLib.importFromFit(buffer, options);
-            // Then
-            eventInterfacePromise.then((event) => {
-                const activity = event.getFirstActivity();
-                expect(activity.getSquashedStreamData(DataDistance.type).length).toEqual(expectedSamplesLength);
-                expect(activity.getSquashedStreamData(DataSpeed.type).length).toEqual(expectedSamplesLength);
-                expect(activity.getSquashedStreamData(DataCadence.type).length).toEqual(expectedSamplesLength);
-                expect(activity.getSquashedStreamData(DataHeartRate.type).length).toEqual(expectedSamplesLength);
-                expect(activity.getSquashedStreamData(DataGrade.type).length).toEqual(expectedSamplesLength);
-                done();
-            });
-        });
-        it('should handle and detect an activity with broken speed data', done => {
-            // Given TCX Source: (unable to upload on garmin connect) OR https://www.strava.com/activities/3197023890
-            const path = __dirname + '/fixtures/others/broken-speed-activity.tcx';
-            const doc = domParser.parseFromString(fs.readFileSync(path).toString(), 'application/xml');
-            const options = ActivityParsingOptions.DEFAULT;
-            options.streams.fixAbnormal.speed = true;
-            // When
-            const eventInterfacePromise = SportsLib.importFromTCX(doc);
-            // Then
-            eventInterfacePromise.then((event) => {
-                const activity = event.getFirstActivity();
-                const speedStdDev = standardDeviation(activity.getSquashedStreamData(DataSpeed.type));
-                expect(speedStdDev).toBeCloseTo(0.55, 2);
-                // Verifying time data
-                const movingTime = activity.getStat(DataMovingTime.type).getValue();
-                const timerTime = activity.getStat(DataTimerTime.type).getValue();
-                const elapsedTime = activity.getDuration().getValue();
-                SpecUtils.assertNearEqualTime(movingTime, '05:04:20');
-                SpecUtils.assertNearEqualTime(timerTime, '5:07:54');
-                SpecUtils.assertNearEqualTime(elapsedTime, '5:07:54');
-                done();
-            });
-        });
-    });
-});