@sports-alliance/sports-lib 6.0.4 → 6.1.0

package/lib/esm/activities/activity.js

@@ -0,0 +1,273 @@
+import { ActivityTypes } from './activity.types';
+import { DurationClassAbstract } from '../duration/duration.class.abstract';
+import { DataLatitudeDegrees } from '../data/data.latitude-degrees';
+import { DataLongitudeDegrees } from '../data/data.longitude-degrees';
+import { Stream } from '../streams/stream';
+import { isNumber } from '../events/utilities/helpers';
+import { DataPower } from '../data/data.power';
+import { DataStartEvent } from '../data/data.start-event';
+import { DataStopEvent } from '../data/data.stop-event';
+import { DataStopAllEvent } from '../data/data.stop-all-event';
+import { DataTime } from '../data/data.time';
+import { ActivityUtilities } from '../events/utilities/activity.utilities';
+import { DataDistance } from '../data/data.distance';
+import { DataRiderPositionChangeEvent } from '../data/data.rider-position-change-event';
+import { ActivityParsingOptions } from './activity-parsing-options';
+import { ParsingEventLibError } from '../errors/parsing-event-lib.error';
+import { DurationExceededEventLibError } from '../errors/duration-exceeded-event-lib.error';
+export class Activity extends DurationClassAbstract {
+    constructor(startDate, endDate, type, creator, options = ActivityParsingOptions.DEFAULT, name = '') {
+        super(startDate, endDate);
+        this.intensityZones = []; // maybe rename
+        this.laps = [];
+        this.streams = [];
+        this.events = [];
+        if (!startDate || !endDate) {
+            throw new ParsingEventLibError('Start and end dates are required');
+        }
+        if (endDate < startDate) {
+            throw new ParsingEventLibError('Activity end date is before the start date and that is not acceptable');
+        }
+        if (+endDate - +startDate > options.maxActivityDurationDays * 24 * 60 * 60 * 1000) {
+            throw new DurationExceededEventLibError(`Activity duration exceeds ${options.maxActivityDurationDays} days. That is not supported`);
+        }
+        this.type = type;
+        this.creator = creator;
+        this.parseOptions = options;
+        this.name = name;
+    }
+    createStream(type) {
+        return new Stream(type, Array(ActivityUtilities.getDataLength(this.startDate, this.endDate)).fill(null));
+    }
+    addDataToStream(type, date, value) {
+        this.getStreamData(type)[this.getDateIndex(date)] = value;
+        return this;
+    }
+    addStream(stream) {
+        if (this.streams.find(activityStream => activityStream.type === stream.type)) {
+            throw new Error(`Duplicate type of stream when adding ${stream.type} to activity ${this.getID()}`);
+        }
+        this.streams.push(stream);
+        return this;
+    }
+    clearStreams() {
+        this.streams = [];
+        return this;
+    }
+    removeStream(streamType) {
+        const stream = streamType instanceof Stream ? streamType : this.getStream(streamType);
+        this.streams = this.streams.filter(activityStream => stream !== activityStream);
+        return this;
+    }
+    replaceStreamData(streamType, data) {
+        this.removeStream(streamType);
+        this.addStream(this.createStream(streamType).setData(data));
+        return this;
+    }
+    addStreams(streams) {
+        this.streams.push(...streams);
+        return this;
+    }
+    getAllStreams() {
+        return this.streams;
+    }
+    // @todo needs more logic improvement and transparency
+    getAllExportableStreams() {
+        return this.getAllStreams().filter(stream => stream.isExportable());
+    }
+    hasStreamData(streamType, startDate, endDate) {
+        try {
+            this.getStreamData(streamType, startDate, endDate);
+        }
+        catch (e) {
+            return false;
+        }
+        return true;
+    }
+    hasPositionData(startDate, endDate) {
+        return (this.hasStreamData(DataLatitudeDegrees.type, startDate, endDate) &&
+            this.hasStreamData(DataLongitudeDegrees.type, startDate, endDate));
+    }
+    isTrainer() {
+        return Activity.TRAINER_TYPES.indexOf(this.type) !== -1;
+    }
+    hasPowerMeter() {
+        return this.hasStreamData(DataPower.type);
+    }
+    getStream(streamType) {
+        const find = this.streams.find(stream => stream.type === streamType);
+        if (!find) {
+            throw Error(`No stream found with type ${streamType}`);
+        }
+        return find;
+    }
+    getStreamData(streamType, startDate, endDate) {
+        const stream = streamType instanceof Stream ? streamType : this.getStream(streamType);
+        if (!startDate && !endDate) {
+            return stream.getData();
+        }
+        if (startDate && endDate) {
+            return stream
+                .getData()
+                .filter((value, index) => new Date(this.startDate.getTime() + index * 1000) <= endDate)
+                .filter((value, index) => new Date(this.startDate.getTime() + index * 1000) >= startDate);
+        }
+        if (startDate) {
+            return stream.getData().filter((value, index) => new Date(this.startDate.getTime() + index * 1000) > startDate);
+        }
+        if (endDate) {
+            return stream.getData().filter((value, index) => new Date(this.startDate.getTime() + index * 1000) < endDate);
+        }
+        return [];
+    }
+    // @todo see how this fits with the filtering on the stream class
+    /**
+     * Gets the data array of an activity stream excluding the non numeric ones
+     * @todo include strings and all data abstract types
+     * @param streamType
+     * @param startDate
+     * @param endDate
+     */
+    getSquashedStreamData(streamType, startDate, endDate) {
+        return this.getStreamData(streamType, startDate, endDate).filter(data => isNumber(data));
+    }
+    getPositionData(startDate, endDate) {
+        const latitudeStreamData = this.getStreamData(DataLatitudeDegrees.type, startDate, endDate);
+        const longitudeStreamData = this.getStreamData(DataLongitudeDegrees.type, startDate, endDate);
+        return latitudeStreamData.reduce((positionArray, value, index, array) => {
+            const currentLatitude = latitudeStreamData[index];
+            const currentLongitude = longitudeStreamData[index];
+            if (!isNumber(currentLatitude) || !isNumber(currentLongitude)) {
+                positionArray.push(null);
+                return positionArray;
+            }
+            positionArray.push({
+                latitudeDegrees: currentLatitude,
+                longitudeDegrees: currentLongitude
+            });
+            return positionArray;
+        }, []);
+    }
+    getSquashedPositionData(startDate, endDate) {
+        return this.getPositionData(startDate, endDate).filter(data => data !== null);
+    }
+    getStreamDataTypesBasedOnDataType(streamTypeToBaseOn, streamTypes) {
+        return ActivityUtilities.getStreamDataTypesBasedOnDataType(this.getStream(streamTypeToBaseOn), this.getAllStreams()
+            .filter(stream => stream.type !== streamTypeToBaseOn)
+            .filter(stream => streamTypes.indexOf(stream.type) !== -1));
+    }
+    getStreamDataTypesBasedOnTime(streamTypes) {
+        return ActivityUtilities.getStreamDataTypesBasedOnTime(this.startDate, this.endDate, !streamTypes
+            ? this.getAllStreams()
+            : this.getAllStreams().filter(stream => streamTypes.indexOf(stream.type) !== -1));
+    }
+    getStreamDataByTime(streamType, filterNull = false, filterInfinity = false) {
+        return this.getStream(streamType).getStreamDataByTime(this.startDate, filterNull, filterInfinity);
+    }
+    getStreamDataByDuration(streamType, filterNull = false, filterInfinity = false) {
+        return this.getStream(streamType).getStreamDataByDuration(0, filterNull, filterInfinity);
+    }
+    addLap(lap) {
+        this.laps.push(lap);
+        return this;
+    }
+    getLaps(activity) {
+        return this.laps;
+    }
+    hasLaps() {
+        return this.laps.length > 0;
+    }
+    getAllEvents() {
+        return this.events;
+    }
+    getStartEvents() {
+        return this.events.filter(event => event instanceof DataStartEvent);
+    }
+    getStopEvents() {
+        return this.events.filter(event => event instanceof DataStopEvent);
+    }
+    getStopAllEvents() {
+        return this.events.filter(event => event instanceof DataStopAllEvent);
+    }
+    getAllRiderPositionChangeEvents() {
+        return this.events.filter(event => event instanceof DataRiderPositionChangeEvent);
+    }
+    addEvent(event) {
+        this.events.push(event);
+        return this;
+    }
+    setAllEvents(events) {
+        this.events = events;
+        return this;
+    }
+    generateTimeStream(streamTypes = []) {
+        const timeStream = this.createStream(DataTime.type);
+        let streams = this.getAllStreams();
+        if (streamTypes.length) {
+            streams = streams.filter(stream => streamTypes.indexOf(stream.type) !== -1);
+        }
+        streams.forEach(stream => {
+            this.getStreamDataByDuration(stream.type, true, false).forEach((data) => {
+                timeStream.getData()[data.time / 1000] = data.time / 1000;
+            });
+        });
+        return timeStream;
+    }
+    getDateIndex(date) {
+        // @todo ceil vs floor (still debatable)
+        return Math.round((+date - +this.startDate) / 1000);
+    }
+    toJSON() {
+        const intensityZones = [];
+        this.intensityZones.forEach((value) => {
+            intensityZones.push(value.toJSON());
+        });
+        const stats = {};
+        this.stats.forEach((value, key) => {
+            Object.assign(stats, value.toJSON());
+        });
+        // Fetch streams from activity
+        const streams = this.getAllStreams().reduce((streams, stream) => {
+            streams.push(stream.toJSON());
+            return streams;
+        }, []);
+        // Now append missing time stream to JSON export
+        if (streams === null || streams === void 0 ? void 0 : streams.length) {
+            const stream = streams.find(s => s.type === DataDistance.type) || streams[0];
+            const timeStream = this.generateTimeStream([stream.type]).toJSON();
+            streams.push(timeStream);
+        }
+        return {
+            name: this.name || null,
+            startDate: this.startDate.getTime(),
+            endDate: this.endDate.getTime(),
+            type: this.type,
+            creator: this.creator.toJSON(),
+            intensityZones: intensityZones,
+            powerMeter: this.hasPowerMeter(),
+            trainer: this.isTrainer(),
+            stats: stats,
+            streams: streams,
+            events: this.getAllEvents().reduce((eventsArray, event) => {
+                eventsArray.push(event.toJSON());
+                return eventsArray;
+            }, []),
+            laps: this.getLaps().reduce((jsonLapsArray, lap) => {
+                jsonLapsArray.push(lap.toJSON(this));
+                return jsonLapsArray;
+            }, [])
+        };
+    }
+}
+Activity.TRAINER_TYPES = [
+    ActivityTypes.VirtualRun,
+    ActivityTypes.VirtualCycling,
+    ActivityTypes.Treadmill,
+    ActivityTypes.IndoorCycling,
+    ActivityTypes.IndoorRunning,
+    ActivityTypes.IndoorRowing,
+    ActivityTypes.Crosstrainer,
+    ActivityTypes.EllipticalTrainer,
+    ActivityTypes.FitnessEquipment,
+    ActivityTypes.StairStepper
+];

package/lib/esm/activities/activity.json.interface.d.ts

@@ -0,0 +1,23 @@
+import { CreatorJSONInterface } from '../creators/creator.json.interface';
+import { IntensityZonesJSONInterface } from '../intensity-zones/intensity-zones.json.interface';
+import { LapJSONInterface } from '../laps/lap.json.interface';
+import { DataJSONInterface } from '../data/data.json.interface';
+import { StreamJSONInterface } from '../streams/stream';
+import { ActivityTypes } from './activity.types';
+export interface ActivityJSONInterface {
+    id?: string;
+    name: string | null;
+    startDate: number;
+    endDate: number;
+    type: ActivityTypes;
+    powerMeter: boolean;
+    trainer: boolean;
+    stats: DataJSONInterface;
+    streams: StreamJSONInterface[] | {
+        [key: string]: (number | null)[];
+    };
+    laps: LapJSONInterface[];
+    creator: CreatorJSONInterface;
+    intensityZones: IntensityZonesJSONInterface[];
+    events: DataJSONInterface[];
+}

package/lib/esm/activities/activity.json.interface.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/activities/activity.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/esm/activities/activity.spec.js

@@ -0,0 +1,348 @@
+import { Activity } from './activity';
+import { DataHeartRate } from '../data/data.heart-rate';
+import { DataAltitude } from '../data/data.altitude';
+import { ActivityTypes } from './activity.types';
+import { Creator } from '../creators/creator';
+import { Stream } from '../streams/stream';
+import { DataDistance } from '../data/data.distance';
+import { DataStopEvent } from '../data/data.stop-event';
+import { DataStartEvent } from '../data/data.start-event';
+import { DataStopAllEvent } from '../data/data.stop-all-event';
+describe('Activity', () => {
+    let activity;
+    beforeEach(() => {
+        // New activity that ends +6m and is 10s duration from new Date(0)
+        activity = new Activity(new Date(0), new Date(new Date(0).getTime() + 10000), ActivityTypes.Running, new Creator('Test'));
+        activity.setID('123');
+    });
+    it('should get streams based on time', () => {
+        activity.addStream(new Stream(DataAltitude.type, [200, 500, null, 502, null, 600, 700]));
+        activity.addStream(new Stream(DataDistance.type, [0, 10, 20, 30, 40, 50, 60]));
+        expect(activity.getStreamDataTypesBasedOnTime([DataAltitude.type])).toEqual({
+            0: {
+                Altitude: 200
+            },
+            1000: {
+                Altitude: 500
+            },
+            3000: {
+                Altitude: 502
+            },
+            5000: {
+                Altitude: 600
+            },
+            6000: {
+                Altitude: 700
+            }
+        });
+        expect(activity.getStreamDataTypesBasedOnTime([DataDistance.type])).toEqual({
+            0: { Distance: 0 },
+            1000: { Distance: 10 },
+            2000: { Distance: 20 },
+            3000: { Distance: 30 },
+            4000: { Distance: 40 },
+            5000: { Distance: 50 },
+            6000: { Distance: 60 }
+        });
+        expect(activity.getStreamDataTypesBasedOnTime([DataAltitude.type, DataDistance.type])).toEqual({
+            0: {
+                Altitude: 200,
+                Distance: 0
+            },
+            1000: { Altitude: 500, Distance: 10 },
+            2000: { Distance: 20 },
+            3000: { Altitude: 502, Distance: 30 },
+            4000: { Distance: 40 },
+            5000: { Altitude: 600, Distance: 50 },
+            6000: { Altitude: 700, Distance: 60 }
+        });
+    });
+    it('should get streams based on another stream', () => {
+        activity.addStream(new Stream(DataAltitude.type, [200, 500, null, 502, null, 500, 700]));
+        activity.addStream(new Stream(DataHeartRate.type, [60, 70, 80, null, null, null, 120]));
+        activity.addStream(new Stream(DataDistance.type, [0, 10, 20, 30, 40, 50, 60]));
+        expect(activity.getStreamDataTypesBasedOnDataType(DataDistance.type, [DataAltitude.type])).toEqual([
+            {
+                Altitude: 200,
+                Distance: 0
+            },
+            {
+                Altitude: 500,
+                Distance: 10
+            },
+            {
+                Altitude: null,
+                Distance: 20
+            },
+            {
+                Altitude: 502,
+                Distance: 30
+            },
+            {
+                Altitude: null,
+                Distance: 40
+            },
+            {
+                Altitude: 500,
+                Distance: 50
+            },
+            {
+                Altitude: 700,
+                Distance: 60
+            }
+        ]);
+        expect(activity.getStreamDataTypesBasedOnDataType(DataDistance.type, [DataHeartRate.type, DataAltitude.type])).toEqual([
+            {
+                Altitude: 200,
+                Distance: 0,
+                'Heart Rate': 60
+            },
+            {
+                Altitude: 500,
+                Distance: 10,
+                'Heart Rate': 70
+            },
+            {
+                Altitude: null,
+                Distance: 20,
+                'Heart Rate': 80
+            },
+            {
+                Altitude: 502,
+                Distance: 30,
+                'Heart Rate': null
+            },
+            {
+                Altitude: null,
+                Distance: 40,
+                'Heart Rate': null
+            },
+            {
+                Altitude: 500,
+                Distance: 50,
+                'Heart Rate': null
+            },
+            {
+                Altitude: 700,
+                Distance: 60,
+                'Heart Rate': 120
+            }
+        ]);
+        expect(activity.getStreamDataTypesBasedOnDataType(DataAltitude.type, [DataDistance.type, DataHeartRate.type])).toEqual([
+            {
+                Altitude: 200,
+                Distance: 0,
+                'Heart Rate': 60
+            },
+            {
+                Altitude: 500,
+                Distance: 10,
+                'Heart Rate': 70
+            },
+            {
+                Altitude: 502,
+                Distance: 30,
+                'Heart Rate': null
+            },
+            {
+                Altitude: 500,
+                Distance: 50,
+                'Heart Rate': null
+            },
+            {
+                Altitude: 700,
+                Distance: 60,
+                'Heart Rate': 120
+            }
+        ]);
+    });
+    describe('Trainer flagging', () => {
+        it('should flag activities to be performed on a trainer', () => {
+            // Given
+            const types = [
+                ActivityTypes.VirtualRun,
+                ActivityTypes.VirtualCycling,
+                ActivityTypes.Treadmill,
+                ActivityTypes.IndoorCycling,
+                ActivityTypes.IndoorRunning,
+                ActivityTypes.IndoorRowing,
+                ActivityTypes.Crosstrainer,
+                ActivityTypes.EllipticalTrainer,
+                ActivityTypes.FitnessEquipment,
+                ActivityTypes.StairStepper
+            ];
+            // When, Then
+            types.forEach(type => {
+                const fakeActivity = new Activity(new Date(), new Date(), type, new Creator('John doo'));
+                expect(fakeActivity.isTrainer()).toBeTruthy();
+            });
+        });
+        it('should NOT flag activities to be performed on a trainer', () => {
+            // Given
+            const types = [
+                ActivityTypes.Aerobics,
+                ActivityTypes.AlpineSkiing,
+                ActivityTypes.AmericanFootball,
+                ActivityTypes.Aquathlon,
+                ActivityTypes.BackcountrySkiing,
+                ActivityTypes.Badminton,
+                ActivityTypes.Baseball,
+                ActivityTypes.Basketball,
+                ActivityTypes.Boxing,
+                ActivityTypes.Canoeing,
+                ActivityTypes.CardioTraining,
+                ActivityTypes.Climbing,
+                ActivityTypes.Combat,
+                ActivityTypes.Cricket,
+                ActivityTypes.Crossfit,
+                ActivityTypes.CrosscountrySkiing,
+                ActivityTypes.Cycling,
+                ActivityTypes.Dancing,
+                ActivityTypes.Diving,
+                ActivityTypes.DownhillSkiing,
+                ActivityTypes.Driving,
+                ActivityTypes.Duathlon,
+                ActivityTypes.EBikeRide,
+                ActivityTypes.Fishing,
+                ActivityTypes.FlexibilityTraining,
+                ActivityTypes.FloorClimbing,
+                ActivityTypes.Floorball,
+                ActivityTypes.Flying,
+                ActivityTypes.Football,
+                ActivityTypes.FreeDiving,
+                ActivityTypes.Frisbee,
+                ActivityTypes.Generic,
+                ActivityTypes.Golf,
+                ActivityTypes.Gymnastics,
+                ActivityTypes.Handcycle,
+                ActivityTypes.Handball,
+                ActivityTypes.HangGliding,
+                ActivityTypes.Hiking,
+                ActivityTypes.HorsebackRiding,
+                ActivityTypes.IceHockey,
+                ActivityTypes.IceSkating,
+                ActivityTypes.IndoorTraining,
+                ActivityTypes.InlineSkating,
+                ActivityTypes.Kayaking,
+                ActivityTypes.Kettlebell,
+                ActivityTypes.Kitesurfing,
+                ActivityTypes.Motorcycling,
+                ActivityTypes.Motorsports,
+                ActivityTypes.MountainBiking,
+                ActivityTypes.Mountaineering,
+                ActivityTypes.NordicWalking,
+                ActivityTypes.OpenWaterSwimming,
+                ActivityTypes.Orienteering,
+                ActivityTypes.Paddling,
+                ActivityTypes.Paragliding,
+                ActivityTypes.Rafting,
+                ActivityTypes.RockClimbing,
+                ActivityTypes.RollerSki,
+                ActivityTypes.Rowing,
+                ActivityTypes.Rugby,
+                ActivityTypes.Running,
+                ActivityTypes.Sailing,
+                ActivityTypes.ScubaDiving,
+                ActivityTypes.Skating,
+                ActivityTypes.SkiTouring,
+                ActivityTypes.SkyDiving,
+                ActivityTypes.Snorkeling,
+                ActivityTypes.Snowboarding,
+                ActivityTypes.Snowmobiling,
+                ActivityTypes.Snowshoeing,
+                ActivityTypes.Soccer,
+                ActivityTypes.Softball,
+                ActivityTypes.Squash,
+                ActivityTypes.StandUpPaddling,
+                ActivityTypes.StrengthTraining,
+                ActivityTypes.Stretching,
+                ActivityTypes.Surfing,
+                ActivityTypes.Swimming,
+                ActivityTypes.Swimrun,
+                ActivityTypes.TableTennis,
+                ActivityTypes.Tactical,
+                ActivityTypes.TelemarkSkiing,
+                ActivityTypes.Tennis,
+                ActivityTypes.TrackAndField,
+                ActivityTypes.TrailRunning,
+                ActivityTypes.Training,
+                ActivityTypes.Trekking,
+                ActivityTypes.Triathlon,
+                ActivityTypes.UnknownSport,
+                ActivityTypes.Velomobile,
+                ActivityTypes.Volleyball,
+                ActivityTypes.Wakeboarding,
+                ActivityTypes.Walking,
+                ActivityTypes.WaterSkiing,
+                ActivityTypes.WeightTraining,
+                ActivityTypes.Wheelchair,
+                ActivityTypes.Windsurfing,
+                ActivityTypes.Workout,
+                ActivityTypes.Yoga,
+                ActivityTypes.YogaPilates
+            ];
+            // When, Then
+            types.forEach(type => {
+                const fakeActivity = new Activity(new Date(), new Date(), type, new Creator('John doo'));
+                expect(fakeActivity.isTrainer()).toBeFalsy();
+            });
+        });
+    });
+    it('should get the time stream', () => {
+        activity.addStreams([
+            //                                   0     1    2       3       4         5    6     7    8 9 and 10 are not set
+            new Stream(DataAltitude.type, [200, null, 502, Infinity, -Infinity, NaN, 0]),
+            new Stream(DataDistance.type, [0, null, 600, 700, 800, null, NaN, 900, Infinity])
+        ]);
+        expect(activity.generateTimeStream().getData()).toEqual([0, null, 2, 3, 4, null, 6, 7, 8, null, null]);
+        expect(activity.generateTimeStream().getData(true)).toEqual([0, 2, 3, 4, 6, 7, 8]);
+        expect(activity.generateTimeStream().getData(false)).toEqual([0, null, 2, 3, 4, null, 6, 7, 8, null, null]);
+    });
+    it('should set the correct sample sizes', () => {
+        const stream = activity.createStream(DataAltitude.type);
+        expect(stream.getData().length).toBe(11);
+    });
+    it('should get and set the correct sample keys and ', () => {
+        const stream = activity.createStream(DataAltitude.type);
+        activity.addStream(stream);
+        activity.addDataToStream(DataAltitude.type, new Date(0), 0);
+        activity.addDataToStream(DataAltitude.type, new Date(500), 5);
+        activity.addDataToStream(DataAltitude.type, new Date(1040), 10);
+        activity.addDataToStream(DataAltitude.type, new Date(2010), 20);
+        activity.addDataToStream(DataAltitude.type, new Date(2060), 30);
+        activity.addDataToStream(DataAltitude.type, new Date(2080), 35);
+        activity.addDataToStream(DataAltitude.type, new Date(3000), 40);
+        activity.addDataToStream(DataAltitude.type, new Date(4000), 50);
+        activity.addDataToStream(DataAltitude.type, new Date(5000), 60);
+        activity.addDataToStream(DataAltitude.type, new Date(6300), 70);
+        activity.addDataToStream(DataAltitude.type, new Date(7000), 80);
+        activity.addDataToStream(DataAltitude.type, new Date(8000), 90);
+        activity.addDataToStream(DataAltitude.type, new Date(9000), 100);
+        activity.addDataToStream(DataAltitude.type, new Date(10000), 110);
+        expect(stream.getData()).toEqual([0, 10, 35, 40, 50, 60, 70, 80, 90, 100, 110]);
+    });
+    it('should get events correctly', () => {
+        activity.addEvent(new DataStopEvent(1));
+        activity.addEvent(new DataStopEvent(1));
+        activity.addEvent(new DataStartEvent(1));
+        activity.addEvent(new DataStartEvent(1));
+        activity.addEvent(new DataStopAllEvent(1));
+        expect(activity.getAllEvents().length).toBe(5);
+        expect(activity.getStartEvents().length).toBe(2);
+        expect(activity.getStopEvents().length).toBe(2);
+        expect(activity.getStopAllEvents().length).toBe(1);
+    });
+    it('should set all events', () => {
+        activity.setAllEvents([
+            new DataStopEvent(1),
+            new DataStopEvent(1),
+            new DataStartEvent(1),
+            new DataStartEvent(1),
+            new DataStopAllEvent(1)
+        ]);
+        expect(activity.getAllEvents().length).toBe(5);
+        expect(activity.getStartEvents().length).toBe(2);
+        expect(activity.getStopEvents().length).toBe(2);
+        expect(activity.getStopAllEvents().length).toBe(1);
+    });
+});