forked from upstream-mirrors/OpenTracks
Handles interrupt and error cleanup during import
This commit is contained in:
Jimmy Shih
@@ -0,0 +1,117 @@
|
||||
/*
|
||||
* Copyright 2009 Google Inc. All Rights Reserved.
|
||||
*/
|
||||
|
||||
package com.google.android.apps.mytracks.stats;
|
||||
|
||||
import junit.framework.TestCase;
|
||||
|
||||
/**
|
||||
* Test for the DoubleBuffer class.
|
||||
*
|
||||
* @author Sandor Dornbush
|
||||
*/
|
||||
public class DoubleBufferTest extends TestCase {
|
||||
|
||||
/**
|
||||
* Tests that the constructor leaves the buffer in a valid state.
|
||||
*/
|
||||
public void testConstructor() {
|
||||
DoubleBuffer buffer = new DoubleBuffer(10);
|
||||
assertFalse(buffer.isFull());
|
||||
assertEquals(0.0, buffer.getAverage());
|
||||
double[] averageAndVariance = buffer.getAverageAndVariance();
|
||||
assertEquals(0.0, averageAndVariance[0]);
|
||||
assertEquals(0.0, averageAndVariance[1]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Simple test with 10 of the same values.
|
||||
*/
|
||||
public void testBasic() {
|
||||
DoubleBuffer buffer = new DoubleBuffer(10);
|
||||
|
||||
for (int i = 0; i < 9; i++) {
|
||||
buffer.setNext(1.0);
|
||||
assertFalse(buffer.isFull());
|
||||
assertEquals(1.0, buffer.getAverage());
|
||||
double[] averageAndVariance = buffer.getAverageAndVariance();
|
||||
assertEquals(1.0, averageAndVariance[0]);
|
||||
assertEquals(0.0, averageAndVariance[1]);
|
||||
}
|
||||
buffer.setNext(1);
|
||||
assertTrue(buffer.isFull());
|
||||
assertEquals(1.0, buffer.getAverage());
|
||||
double[] averageAndVariance = buffer.getAverageAndVariance();
|
||||
assertEquals(1.0, averageAndVariance[0]);
|
||||
assertEquals(0.0, averageAndVariance[1]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests with 5 entries of -10 and 5 entries of 10.
|
||||
*/
|
||||
public void testSplit() {
|
||||
DoubleBuffer buffer = new DoubleBuffer(10);
|
||||
|
||||
for (int i = 0; i < 5; i++) {
|
||||
buffer.setNext(-10);
|
||||
assertFalse(buffer.isFull());
|
||||
assertEquals(-10.0, buffer.getAverage());
|
||||
double[] averageAndVariance = buffer.getAverageAndVariance();
|
||||
assertEquals(-10.0, averageAndVariance[0]);
|
||||
assertEquals(0.0, averageAndVariance[1]);
|
||||
}
|
||||
|
||||
for (int i = 1; i < 5; i++) {
|
||||
buffer.setNext(10);
|
||||
assertFalse(buffer.isFull());
|
||||
double expectedAverage = ((i * 10.0) - 50.0) / (i + 5);
|
||||
assertEquals(buffer.toString(),
|
||||
expectedAverage, buffer.getAverage(), 0.01);
|
||||
double[] averageAndVariance = buffer.getAverageAndVariance();
|
||||
assertEquals(expectedAverage, averageAndVariance[0]);
|
||||
}
|
||||
buffer.setNext(10);
|
||||
assertTrue(buffer.isFull());
|
||||
assertEquals(0.0, buffer.getAverage());
|
||||
double[] averageAndVariance = buffer.getAverageAndVariance();
|
||||
assertEquals(0.0, averageAndVariance[0]);
|
||||
assertEquals(100.0, averageAndVariance[1]);
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests that reset leaves the buffer in a valid state.
|
||||
*/
|
||||
public void testReset() {
|
||||
DoubleBuffer buffer = new DoubleBuffer(10);
|
||||
|
||||
for (int i = 0; i < 100; i++) {
|
||||
buffer.setNext(i);
|
||||
}
|
||||
assertTrue(buffer.isFull());
|
||||
|
||||
buffer.reset();
|
||||
assertFalse(buffer.isFull());
|
||||
assertEquals(0.0, buffer.getAverage());
|
||||
double[] averageAndVariance = buffer.getAverageAndVariance();
|
||||
assertEquals(0.0, averageAndVariance[0]);
|
||||
assertEquals(0.0, averageAndVariance[1]);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Tests that if a lot of items are inserted the smoothing and looping works.
|
||||
*/
|
||||
public void testLoop() {
|
||||
DoubleBuffer buffer = new DoubleBuffer(10);
|
||||
|
||||
for (int i = 0; i < 1000; i++) {
|
||||
buffer.setNext(i);
|
||||
assertEquals(i >= 9, buffer.isFull());
|
||||
if (i > 10) {
|
||||
assertEquals(i - 4.5, buffer.getAverage());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,63 @@
|
||||
/**
|
||||
* Copyright 2009 Google Inc. All Rights Reserved.
|
||||
*/
|
||||
package com.google.android.apps.mytracks.stats;
|
||||
|
||||
import junit.framework.TestCase;
|
||||
import java.util.Random;
|
||||
|
||||
/**
|
||||
* This class test the ExtremityMonitor class.
|
||||
*
|
||||
* @author Sandor Dornbush
|
||||
*/
|
||||
public class ExtremityMonitorTest extends TestCase {
|
||||
|
||||
public ExtremityMonitorTest(String name) {
|
||||
super(name);
|
||||
}
|
||||
|
||||
public void testInitialize() {
|
||||
ExtremityMonitor monitor = new ExtremityMonitor();
|
||||
assertEquals(Double.POSITIVE_INFINITY, monitor.getMin());
|
||||
assertEquals(Double.NEGATIVE_INFINITY, monitor.getMax());
|
||||
}
|
||||
|
||||
public void testSimple() {
|
||||
ExtremityMonitor monitor = new ExtremityMonitor();
|
||||
assertTrue(monitor.update(0));
|
||||
assertTrue(monitor.update(1));
|
||||
assertEquals(0.0, monitor.getMin());
|
||||
assertEquals(1.0, monitor.getMax());
|
||||
assertFalse(monitor.update(1));
|
||||
assertFalse(monitor.update(0.5));
|
||||
}
|
||||
|
||||
/**
|
||||
* Throws a bunch of random numbers between [0,1] at the monitor.
|
||||
*/
|
||||
public void testRandom() {
|
||||
ExtremityMonitor monitor = new ExtremityMonitor();
|
||||
Random random = new Random(42);
|
||||
for (int i = 0; i < 1000; i++) {
|
||||
monitor.update(random.nextDouble());
|
||||
}
|
||||
assertTrue(monitor.getMin() < 0.1);
|
||||
assertTrue(monitor.getMax() < 1.0);
|
||||
assertTrue(monitor.getMin() >= 0.0);
|
||||
assertTrue(monitor.getMax() > 0.9);
|
||||
}
|
||||
|
||||
public void testReset() {
|
||||
ExtremityMonitor monitor = new ExtremityMonitor();
|
||||
assertTrue(monitor.update(0));
|
||||
assertTrue(monitor.update(1));
|
||||
monitor.reset();
|
||||
assertEquals(Double.POSITIVE_INFINITY, monitor.getMin());
|
||||
assertEquals(Double.NEGATIVE_INFINITY, monitor.getMax());
|
||||
assertTrue(monitor.update(0));
|
||||
assertTrue(monitor.update(1));
|
||||
assertEquals(0.0, monitor.getMin());
|
||||
assertEquals(1.0, monitor.getMax());
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,107 @@
|
||||
/*
|
||||
* Copyright 2010 Google Inc.
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
|
||||
* use this file except in compliance with the License. You may obtain a copy of
|
||||
* the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
||||
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
||||
* License for the specific language governing permissions and limitations under
|
||||
* the License.
|
||||
*/
|
||||
package com.google.android.apps.mytracks.stats;
|
||||
|
||||
import junit.framework.TestCase;
|
||||
|
||||
/**
|
||||
* Tests for {@link TripStatistics}.
|
||||
* This only tests non-trivial pieces of that class.
|
||||
*
|
||||
* @author Rodrigo Damazio
|
||||
*/
|
||||
public class TripStatisticsTest extends TestCase {
|
||||
|
||||
private TripStatistics statistics;
|
||||
|
||||
@Override
|
||||
protected void setUp() throws Exception {
|
||||
super.setUp();
|
||||
|
||||
statistics = new TripStatistics();
|
||||
}
|
||||
|
||||
public void testSetBounds() {
|
||||
// This is not a trivial setter, conversion happens in it
|
||||
statistics.setBounds(12345, -34567, 56789, -98765);
|
||||
assertEquals(12345, statistics.getLeft());
|
||||
assertEquals(-34567, statistics.getTop());
|
||||
assertEquals(56789, statistics.getRight());
|
||||
assertEquals(-98765, statistics.getBottom());
|
||||
}
|
||||
|
||||
public void testMerge() {
|
||||
TripStatistics statistics2 = new TripStatistics();
|
||||
statistics.setStartTime(1000L); // Resulting start time
|
||||
statistics.setStopTime(2500L);
|
||||
statistics2.setStartTime(3000L);
|
||||
statistics2.setStopTime(4000L); // Resulting stop time
|
||||
statistics.setTotalTime(1500L);
|
||||
statistics2.setTotalTime(1000L); // Result: 1500+1000
|
||||
statistics.setMovingTime(700L);
|
||||
statistics2.setMovingTime(600L); // Result: 700+600
|
||||
statistics.setTotalDistance(750.0);
|
||||
statistics2.setTotalDistance(350.0); // Result: 750+350
|
||||
statistics.setTotalElevationGain(50.0);
|
||||
statistics2.setTotalElevationGain(850.0); // Result: 850+50
|
||||
statistics.setMaxSpeed(60.0); // Resulting max speed
|
||||
statistics2.setMaxSpeed(30.0);
|
||||
statistics.setMaxElevation(1250.0);
|
||||
statistics.setMinElevation(1200.0); // Resulting min elevation
|
||||
statistics2.setMaxElevation(3575.0); // Resulting max elevation
|
||||
statistics2.setMinElevation(2800.0);
|
||||
statistics.setMaxGrade(15.0);
|
||||
statistics.setMinGrade(-25.0); // Resulting min grade
|
||||
statistics2.setMaxGrade(35.0); // Resulting max grade
|
||||
statistics2.setMinGrade(0.0);
|
||||
statistics2.setCalorie(50.0);
|
||||
|
||||
// Resulting bounds: -10000, 35000, 30000, -40000
|
||||
statistics.setBounds(-10000, 20000, 30000, -40000);
|
||||
statistics2.setBounds(-5000, 35000, 0, 20000);
|
||||
|
||||
statistics.merge(statistics2);
|
||||
|
||||
assertEquals(1000L, statistics.getStartTime());
|
||||
assertEquals(4000L, statistics.getStopTime());
|
||||
assertEquals(2500L, statistics.getTotalTime());
|
||||
assertEquals(1300L, statistics.getMovingTime());
|
||||
assertEquals(1100.0, statistics.getTotalDistance());
|
||||
assertEquals(900.0, statistics.getTotalElevationGain());
|
||||
assertEquals(statistics.getTotalDistance()/ (statistics.getMovingTime() / 1000.0), statistics.getMaxSpeed());
|
||||
assertEquals(-10000, statistics.getLeft());
|
||||
assertEquals(30000, statistics.getRight());
|
||||
assertEquals(35000, statistics.getTop());
|
||||
assertEquals(-40000, statistics.getBottom());
|
||||
assertEquals(1200.0, statistics.getMinElevation());
|
||||
assertEquals(3575.0, statistics.getMaxElevation());
|
||||
assertEquals(-25.0, statistics.getMinGrade());
|
||||
assertEquals(35.0, statistics.getMaxGrade());
|
||||
assertEquals(50.0, statistics.getCalorie());
|
||||
}
|
||||
|
||||
public void testGetAverageSpeed() {
|
||||
statistics.setTotalDistance(1000.0);
|
||||
statistics.setTotalTime(50000); // in milliseconds
|
||||
assertEquals(20.0, statistics.getAverageSpeed());
|
||||
}
|
||||
|
||||
public void testGetAverageMovingSpeed() {
|
||||
statistics.setTotalDistance(1000.0);
|
||||
statistics.setMovingTime(20000); // in milliseconds
|
||||
assertEquals(50.0, statistics.getAverageMovingSpeed());
|
||||
}
|
||||
}
|
||||
+341
@@ -0,0 +1,341 @@
|
||||
// Copyright 2009 Google Inc. All Rights Reserved.
|
||||
|
||||
package com.google.android.apps.mytracks.stats;
|
||||
|
||||
import com.google.android.apps.mytracks.util.PreferencesUtils;
|
||||
|
||||
import android.location.Location;
|
||||
|
||||
import junit.framework.TestCase;
|
||||
|
||||
/**
|
||||
* Tests {@link TripStatisticsUpdater}.
|
||||
*
|
||||
* @author Sandor Dornbush
|
||||
*/
|
||||
public class TripStatisticsUpdaterTest extends TestCase {
|
||||
|
||||
private static final long ONE_SECOND = 1000;
|
||||
private static final long TEN_SECONDS = 10 * ONE_SECOND;
|
||||
private static final float MOVING_SPEED = 11.1f;
|
||||
|
||||
private TripStatisticsUpdater tripStatisticsUpdater = null;
|
||||
|
||||
@Override
|
||||
protected void setUp() throws Exception {
|
||||
tripStatisticsUpdater = new TripStatisticsUpdater(System.currentTimeMillis());
|
||||
}
|
||||
|
||||
/**
|
||||
* Sends some moving and waiting locations and then checks the statistics.
|
||||
*/
|
||||
public void testAddLocationSimple() {
|
||||
long startTime = 1000;
|
||||
tripStatisticsUpdater = new TripStatisticsUpdater(startTime);
|
||||
TripStatistics tripStatistics = tripStatisticsUpdater.getTripStatistics();
|
||||
|
||||
assertEquals(0.0, tripStatisticsUpdater.getSmoothedElevation());
|
||||
assertEquals(Double.POSITIVE_INFINITY, tripStatistics.getMinElevation());
|
||||
assertEquals(Double.NEGATIVE_INFINITY, tripStatistics.getMaxElevation());
|
||||
assertEquals(0.0, tripStatistics.getMaxSpeed());
|
||||
assertEquals(Double.POSITIVE_INFINITY, tripStatistics.getMinGrade());
|
||||
assertEquals(Double.NEGATIVE_INFINITY, tripStatistics.getMaxGrade());
|
||||
assertEquals(0.0, tripStatistics.getTotalElevationGain());
|
||||
assertEquals(0, tripStatistics.getMovingTime());
|
||||
assertEquals(0.0, tripStatistics.getTotalDistance());
|
||||
|
||||
// Time:0 ~ 99; Location:0 ~ 99
|
||||
addMoveLocations(100, startTime, tripStatistics, 0, 0);
|
||||
// Time:100 ~ 199; Location:99
|
||||
addWaitLocations(100, startTime, tripStatistics, 100, 99);
|
||||
// Time:200 ~ 299; Location:100 ~ 199
|
||||
addMoveLocations(100, startTime, tripStatistics, 200, 100);
|
||||
// Time:300 ~ 399; Location:199
|
||||
addWaitLocations(100, startTime, tripStatistics, 300, 199);
|
||||
// Time:400 ~ 499; Location:200 ~ 299
|
||||
addMoveLocations(100, startTime, tripStatistics, 400, 200);
|
||||
// Time:500 ~ 599; Location:299
|
||||
addWaitLocations(100, startTime, tripStatistics, 500, 299);
|
||||
// Time:600 ~ 699; Location:300 ~ 399
|
||||
addMoveLocations(100, startTime, tripStatistics, 600, 300);
|
||||
}
|
||||
|
||||
/**
|
||||
* Sends some disordered locations and checks the statistics. In some
|
||||
* situation, especially when signal is not good, MyTracks may receive such
|
||||
* data.
|
||||
*/
|
||||
public void testAddLocation_disorderedLocatiions() {
|
||||
long startTime = 1000;
|
||||
tripStatisticsUpdater = new TripStatisticsUpdater(startTime);
|
||||
TripStatistics tripStatistics = tripStatisticsUpdater.getTripStatistics();
|
||||
|
||||
addLocations(5, startTime, tripStatistics, 0, 0);
|
||||
addLocations(5, startTime, tripStatistics, 5, 0);
|
||||
addLocations(5, startTime, tripStatistics, 10, -5);
|
||||
addLocations(5, startTime, tripStatistics, 15, 5);
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests {@link TripStatisticsUpdater#updateElevation(double)} with constant
|
||||
* elevations.
|
||||
*/
|
||||
public void testElevationSimple() throws Exception {
|
||||
for (double elevation = 0; elevation < 1000; elevation += 10) {
|
||||
tripStatisticsUpdater = new TripStatisticsUpdater(System.currentTimeMillis());
|
||||
for (int i = 0; i < 100; i++) {
|
||||
tripStatisticsUpdater.updateElevation(elevation);
|
||||
assertEquals(elevation, tripStatisticsUpdater.getSmoothedElevation());
|
||||
|
||||
if (i >= TripStatisticsUpdater.ELEVATION_SMOOTHING_FACTOR) {
|
||||
TripStatistics tripStatistics = tripStatisticsUpdater.getTripStatistics();
|
||||
assertEquals(elevation, tripStatistics.getMinElevation());
|
||||
assertEquals(elevation, tripStatistics.getMaxElevation());
|
||||
assertEquals(0.0, tripStatistics.getTotalElevationGain());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests {@link TripStatisticsUpdater#updateGrade(double, Double)} with
|
||||
* elevation gain.
|
||||
*/
|
||||
public void testElevationGain() throws Exception {
|
||||
for (double i = 0; i < 1000; i++) {
|
||||
tripStatisticsUpdater.updateElevation(i);
|
||||
assertEquals(i, tripStatisticsUpdater.getSmoothedElevation(),
|
||||
TripStatisticsUpdater.ELEVATION_SMOOTHING_FACTOR / 2);
|
||||
|
||||
if (i >= TripStatisticsUpdater.ELEVATION_SMOOTHING_FACTOR) {
|
||||
TripStatistics data = tripStatisticsUpdater.getTripStatistics();
|
||||
assertEquals(12.0, data.getMinElevation());
|
||||
assertEquals(
|
||||
i, data.getMaxElevation(), TripStatisticsUpdater.ELEVATION_SMOOTHING_FACTOR / 2);
|
||||
assertEquals(
|
||||
i, data.getTotalElevationGain(), TripStatisticsUpdater.ELEVATION_SMOOTHING_FACTOR);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests {@link TripStatisticsUpdater#updateGrade(double, Double)} with grade
|
||||
* of 1 and -1.
|
||||
*/
|
||||
public void testGradeSimple() throws Exception {
|
||||
for (double i = 0; i < 1000; i++) {
|
||||
tripStatisticsUpdater.updateGrade(100, Double.valueOf(100));
|
||||
if (i >= TripStatisticsUpdater.RUN_SMOOTHING_FACTOR
|
||||
+ TripStatisticsUpdater.GRADE_SMOOTHING_FACTOR) {
|
||||
assertEquals(1.0, tripStatisticsUpdater.getTripStatistics().getMaxGrade());
|
||||
assertEquals(1.0, tripStatisticsUpdater.getTripStatistics().getMinGrade());
|
||||
}
|
||||
}
|
||||
for (double i = 0; i < 1000; i++) {
|
||||
tripStatisticsUpdater.updateGrade(100, Double.valueOf(-100));
|
||||
if (i >= TripStatisticsUpdater.GRADE_SMOOTHING_FACTOR
|
||||
&& i >= TripStatisticsUpdater.RUN_SMOOTHING_FACTOR) {
|
||||
assertEquals(1.0, tripStatisticsUpdater.getTripStatistics().getMaxGrade());
|
||||
// add 0.1 delta since changing min grade from 1 to -1
|
||||
assertEquals(-1.0, tripStatisticsUpdater.getTripStatistics().getMinGrade(), 0.1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests {@link TripStatisticsUpdater#updateGrade(double, Double)} with
|
||||
* distance of 1. The grade should get ignored.
|
||||
*/
|
||||
public void testGradeIgnoreShort() throws Exception {
|
||||
for (double i = 0; i < 100; i++) {
|
||||
/*
|
||||
* The value of the elevation does not matter. This is just to fill the
|
||||
* elevation buffer.
|
||||
*/
|
||||
tripStatisticsUpdater.updateElevation(i);
|
||||
tripStatisticsUpdater.updateGrade(1, Double.valueOf(100));
|
||||
assertEquals(
|
||||
Double.NEGATIVE_INFINITY, tripStatisticsUpdater.getTripStatistics().getMaxGrade());
|
||||
assertEquals(
|
||||
Double.POSITIVE_INFINITY, tripStatisticsUpdater.getTripStatistics().getMinGrade());
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests {@link TripStatisticsUpdater#updateSpeed(long, double, long, double)}
|
||||
* with speed of zero.
|
||||
*/
|
||||
public void testUpdateSpeedIncludeZero() {
|
||||
for (int i = 0; i < 1000; i++) {
|
||||
tripStatisticsUpdater.updateSpeed(i + ONE_SECOND, 0.0, i, 4.0);
|
||||
assertEquals(0.0, tripStatisticsUpdater.getTripStatistics().getMaxSpeed());
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests {@link TripStatisticsUpdater#updateSpeed(long, double, long, double)}
|
||||
* with the error code 128. The speed should get ignored.
|
||||
*/
|
||||
public void testUpdateSpeedIngoreErrorCode() {
|
||||
long time = 12344000;
|
||||
tripStatisticsUpdater.updateSpeed(time + ONE_SECOND, 128.0, time, 0.0);
|
||||
assertEquals(0.0, tripStatisticsUpdater.getTripStatistics().getMaxSpeed());
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests {@link TripStatisticsUpdater#updateSpeed(long, double, long, double)}
|
||||
* with a large speed change. The speed should get ignored.
|
||||
*/
|
||||
public void testUpdateSpeedIngoreLargeAcceleration() {
|
||||
long time = 12344000;
|
||||
tripStatisticsUpdater.updateSpeed(time + ONE_SECOND, 100.0, time, 1.0);
|
||||
assertEquals(0.0, tripStatisticsUpdater.getTripStatistics().getMaxSpeed());
|
||||
}
|
||||
|
||||
/**
|
||||
* Tests {@link TripStatisticsUpdater#updateSpeed(long, double, long, double)}
|
||||
* with constant speed.
|
||||
*/
|
||||
public void testUpdateSpeed() {
|
||||
double speed = 4.0;
|
||||
for (int i = 0; i < 1000; i++) {
|
||||
tripStatisticsUpdater.updateSpeed(i + ONE_SECOND, speed, i, speed);
|
||||
if (i >= TripStatisticsUpdater.SPEED_SMOOTHING_FACTOR) {
|
||||
assertEquals(speed, tripStatisticsUpdater.getTripStatistics().getMaxSpeed());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Sends some locations which keeping moving and checks the statistics.
|
||||
*
|
||||
* @param points number of locations
|
||||
* @param startTime start time of this track
|
||||
* @param tripStatistics the TripStatistics object
|
||||
* @param timeOffset offset to start time
|
||||
* @param locationOffset location offset to start
|
||||
*/
|
||||
private void addMoveLocations(int points, long startTime, TripStatistics tripStatistics,
|
||||
int timeOffset, int locationOffset) {
|
||||
for (int i = 0; i < points; i++) {
|
||||
// Going up by 1 meter each time.
|
||||
// Moving by .001 degree latitude (111 meters).
|
||||
// Each time slice is 10 seconds.
|
||||
Location location = getLocation(i + locationOffset, (i + locationOffset) * .001, MOVING_SPEED,
|
||||
startTime + (timeOffset + i) * TEN_SECONDS);
|
||||
tripStatisticsUpdater.addLocation(location,
|
||||
PreferencesUtils.RECORDING_DISTANCE_INTERVAL_DEFAULT,
|
||||
PreferencesUtils.STATS_WEIGHT_DEFAULT);
|
||||
tripStatistics = tripStatisticsUpdater.getTripStatistics();
|
||||
|
||||
assertEquals((timeOffset + i) * TEN_SECONDS, tripStatistics.getTotalTime());
|
||||
assertEquals((locationOffset + i) * TEN_SECONDS, tripStatistics.getMovingTime());
|
||||
assertEquals(i + locationOffset, tripStatisticsUpdater.getSmoothedElevation(),
|
||||
TripStatisticsUpdater.ELEVATION_SMOOTHING_FACTOR / 2);
|
||||
if (i + locationOffset >= TripStatisticsUpdater.ELEVATION_SMOOTHING_FACTOR) {
|
||||
assertEquals(12.0, tripStatistics.getMinElevation());
|
||||
assertEquals(i + locationOffset, tripStatistics.getMaxElevation(),
|
||||
TripStatisticsUpdater.ELEVATION_SMOOTHING_FACTOR / 2);
|
||||
assertEquals(i + locationOffset, tripStatistics.getTotalElevationGain(),
|
||||
TripStatisticsUpdater.ELEVATION_SMOOTHING_FACTOR);
|
||||
}
|
||||
|
||||
if (i + locationOffset >= TripStatisticsUpdater.SPEED_SMOOTHING_FACTOR) {
|
||||
assertEquals(MOVING_SPEED, tripStatistics.getMaxSpeed(), 0.1);
|
||||
}
|
||||
|
||||
// If there are only moving locations in the track.
|
||||
if (locationOffset == 0 && (i + locationOffset) >= TripStatisticsUpdater.RUN_SMOOTHING_FACTOR
|
||||
+ TripStatisticsUpdater.GRADE_SMOOTHING_FACTOR) {
|
||||
// 1 m / 111 m = .009
|
||||
assertEquals(0.009, tripStatistics.getMinGrade(), 0.0001);
|
||||
assertEquals(0.009, tripStatistics.getMaxGrade(), 0.0001);
|
||||
}
|
||||
assertEquals((i + locationOffset) * 111.0, tripStatistics.getTotalDistance(),
|
||||
(i + locationOffset) * 111.0 * 0.01);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Sends some locations which are not moving and checks the statistics.
|
||||
*
|
||||
* @param points number of locations
|
||||
* @param startTime start time of this track
|
||||
* @param tripStatistics the TripStatistics object
|
||||
* @param timeOffset offset to start time
|
||||
* @param locationOffset location offset to start
|
||||
*/
|
||||
private void addWaitLocations(int points, long startTime, TripStatistics tripStatistics,
|
||||
int timeOffset, int locationOffset) {
|
||||
for (int i = 0; i < points; i++) {
|
||||
Location location = getLocation(
|
||||
locationOffset, locationOffset * .001, 0, startTime + (i + timeOffset) * TEN_SECONDS);
|
||||
tripStatisticsUpdater.addLocation(location,
|
||||
PreferencesUtils.RECORDING_DISTANCE_INTERVAL_DEFAULT,
|
||||
PreferencesUtils.STATS_WEIGHT_DEFAULT);
|
||||
|
||||
tripStatistics = tripStatisticsUpdater.getTripStatistics();
|
||||
assertEquals((i + timeOffset) * TEN_SECONDS, tripStatistics.getTotalTime());
|
||||
assertEquals((locationOffset) * TEN_SECONDS, tripStatistics.getMovingTime());
|
||||
assertEquals(locationOffset, tripStatisticsUpdater.getSmoothedElevation(),
|
||||
TripStatisticsUpdater.ELEVATION_SMOOTHING_FACTOR / 2);
|
||||
assertEquals(12.0, tripStatistics.getMinElevation());
|
||||
assertEquals(locationOffset, tripStatistics.getMaxElevation(),
|
||||
TripStatisticsUpdater.ELEVATION_SMOOTHING_FACTOR / 2);
|
||||
assertEquals(locationOffset, tripStatistics.getTotalElevationGain(),
|
||||
TripStatisticsUpdater.ELEVATION_SMOOTHING_FACTOR);
|
||||
if (locationOffset >= TripStatisticsUpdater.SPEED_SMOOTHING_FACTOR) {
|
||||
assertEquals(MOVING_SPEED, tripStatistics.getMaxSpeed(), 0.1);
|
||||
}
|
||||
assertEquals(MOVING_SPEED, tripStatistics.getMaxSpeed(), 0.1);
|
||||
assertEquals(
|
||||
locationOffset * 111.0, tripStatistics.getTotalDistance(), locationOffset * 111.0 * 0.01);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Sends some locations which are moving and checks some simple policy.
|
||||
*
|
||||
* @param points number of locations
|
||||
* @param startTime start time of this track
|
||||
* @param tripStatistics the TripStatistics object
|
||||
* @param timeOffset offset to start time
|
||||
* @param locationOffset location offset to start
|
||||
*/
|
||||
private void addLocations(int points, long startTime, TripStatistics tripStatistics,
|
||||
int timeOffset, int locationOffset) {
|
||||
for (int i = 0; i < points; i++) {
|
||||
// 99999 means a speed should bigger than given speed.
|
||||
Location location = getLocation(i + locationOffset, (i + locationOffset) * .001, 99999,
|
||||
startTime + (timeOffset + i) * TEN_SECONDS);
|
||||
tripStatisticsUpdater.addLocation(location,
|
||||
PreferencesUtils.RECORDING_DISTANCE_INTERVAL_DEFAULT,
|
||||
PreferencesUtils.STATS_WEIGHT_DEFAULT);
|
||||
tripStatistics = tripStatisticsUpdater.getTripStatistics();
|
||||
|
||||
assertTrue(tripStatistics.getMovingTime() <= tripStatistics.getTotalTime());
|
||||
assertTrue(tripStatistics.getAverageSpeed() <= tripStatistics.getAverageMovingSpeed());
|
||||
assertTrue(tripStatistics.getAverageMovingSpeed() <= tripStatistics.getMaxSpeed());
|
||||
assertTrue(tripStatistics.getStopTime() >= tripStatistics.getStartTime());
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a location and returns it.
|
||||
*
|
||||
* @param altitude altitude of location
|
||||
* @param latitude latitude of location
|
||||
* @param speed speed of location
|
||||
* @param time time of location
|
||||
*/
|
||||
private Location getLocation(double altitude, double latitude, float speed, long time) {
|
||||
Location location = new Location("test");
|
||||
location.setAccuracy(1.0f);
|
||||
location.setLongitude(45.0);
|
||||
location.setAltitude(altitude);
|
||||
location.setLatitude(latitude);
|
||||
location.setSpeed(speed);
|
||||
location.setTime(time);
|
||||
return location;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user