Releasing mytracks 1.0.15

2010-05-23 00:00:00 -03:00
commit 500dfa3107
191 changed files with 29191 additions and 0 deletions
@@ -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,180 @@
+// Copyright 2009 Google Inc. All Rights Reserved.
+
+package com.google.android.apps.mytracks.stats;
+
+import com.google.android.apps.mytracks.MyTracksConstants;
+
+import android.location.Location;
+
+import junit.framework.TestCase;
+
+/**
+ * Test the the function of the TripStatistics class.
+ *
+ * @author Sandor Dornbush
+ */
+public class TripStatisticsTest extends TestCase {
+
+  private TripStatistics stats = null;
+
+  @Override
+  protected void setUp() throws Exception {
+    super.setUp();
+    stats = new TripStatistics();
+  }
+
+  public void testAddLocationSimple() throws Exception {
+    stats = new TripStatistics(1000);
+
+    assertEquals(0.0, stats.getSmoothedElevation());
+    assertEquals(Double.POSITIVE_INFINITY, stats.getMinElevation());
+    assertEquals(Double.NEGATIVE_INFINITY, stats.getMaxElevation());
+    assertEquals(0.0, stats.getMaxSpeed());
+    assertEquals(Double.POSITIVE_INFINITY, stats.getMinGrade());
+    assertEquals(Double.NEGATIVE_INFINITY, stats.getMaxGrade());
+    assertEquals(0.0, stats.getTotalElevationGain());
+    assertEquals(0, stats.getMovingTime());
+    assertEquals(0.0, stats.getTotalDistance());
+    for (int i = 0; i < 100; i++) {
+      Location l = new Location("test");
+      l.setAccuracy(1.0f);
+      l.setLongitude(45.0);
+
+      // Going up by 5 meters each time.
+      l.setAltitude(i);
+      // Moving by .1% of a degree latitude.
+      l.setLatitude(i * .001);
+      l.setSpeed(11.1f);
+      // Each time slice is 10 seconds.
+      long time = 1000 + 10000 * i;
+      l.setTime(time);
+      boolean moving = stats.addLocation(l, time);
+      assertEquals((i != 0), moving);
+
+      assertEquals(10000 * i, stats.getTotalTime());
+      System.out.println("i: " + i + "\nLocation: " + l + "\nStats: " + stats);
+      assertEquals(10000 * i, stats.getMovingTime());
+      assertEquals(i, stats.getSmoothedElevation(),
+                   MyTracksConstants.ELEVATION_SMOOTHING_FACTOR / 2);
+      assertEquals(0.0, stats.getMinElevation());
+      assertEquals(i , stats.getMaxElevation(),
+                   MyTracksConstants.ELEVATION_SMOOTHING_FACTOR / 2);
+      assertEquals(i, stats.getTotalElevationGain(),
+                   MyTracksConstants.ELEVATION_SMOOTHING_FACTOR);
+      if (i > MyTracksConstants.SPEED_SMOOTHING_FACTOR) {
+        assertEquals(11.1f, stats.getMaxSpeed(), 0.1);
+      }
+      if ((i > MyTracksConstants.GRADE_SMOOTHING_FACTOR)
+          && (i > MyTracksConstants.ELEVATION_SMOOTHING_FACTOR)) {
+        assertEquals(0.009, stats.getMinGrade(), 0.0001);
+        assertEquals(0.009, stats.getMaxGrade(), 0.0001);
+      }
+      // 1 degree = 111 km
+      // 1 timeslice = 0.001 degree = 111 m
+      assertEquals(111.0 * i, stats.getTotalDistance(), 100);
+    }
+  }
+
+  /**
+   * Test that elevation works if the user is stable.
+   */
+  public void testElevationSimple() throws Exception {
+    for (double elevation = 0; elevation < 1000; elevation += 10) {
+      stats = new TripStatistics();
+      for (int j = 0; j < 100; j++) {
+        assertEquals(0.0, stats.updateElevation(elevation));
+        assertEquals(elevation, stats.getSmoothedElevation());
+        assertEquals(elevation, stats.getMinElevation());
+        assertEquals(elevation, stats.getMaxElevation());
+        assertEquals(0.0, stats.getTotalElevationGain());
+      }
+    }
+  }
+
+  public void testElevationGain() throws Exception {
+    for (double i = 0; i < 1000; i++) {
+      double expectedGain;
+      if (i < (MyTracksConstants.ELEVATION_SMOOTHING_FACTOR - 1)) {
+        expectedGain = 0;
+      } else if (i < MyTracksConstants.ELEVATION_SMOOTHING_FACTOR) {
+        expectedGain = 0.5;
+      } else {
+        expectedGain = 1.0;
+      }
+      assertEquals(expectedGain,
+                   stats.updateElevation(i));
+      assertEquals(i, stats.getSmoothedElevation(), 20);
+      assertEquals(0.0, stats.getMinElevation(), 0.0);
+      assertEquals(i, stats.getMaxElevation(),
+                   MyTracksConstants.ELEVATION_SMOOTHING_FACTOR);
+      assertEquals(i, stats.getTotalElevationGain(),
+                   MyTracksConstants.ELEVATION_SMOOTHING_FACTOR);
+    }
+  }
+
+  public void testGradeSimple() throws Exception {
+    for (double i = 0; i < 1000; i++) {
+      // The value of the elevation does not matter.  This is just to fill the
+      // buffer.
+      stats.updateElevation(i);
+      stats.updateGrade(100, 100);
+      if ((i > MyTracksConstants.GRADE_SMOOTHING_FACTOR)
+          && (i > MyTracksConstants.ELEVATION_SMOOTHING_FACTOR)) {
+        assertEquals(1.0, stats.getMaxGrade());
+        assertEquals(1.0, stats.getMinGrade());
+      }
+    }
+    for (double i = 0; i < 1000; i++) {
+      // The value of the elevation does not matter.  This is just to fill the
+      // buffer.
+      stats.updateElevation(i);
+      stats.updateGrade(100, -100);
+      if ((i > MyTracksConstants.GRADE_SMOOTHING_FACTOR)
+          && (i > MyTracksConstants.ELEVATION_SMOOTHING_FACTOR)) {
+        assertEquals(1.0, stats.getMaxGrade());
+        assertEquals(-1.0, stats.getMinGrade());
+      }
+    }
+  }
+
+  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
+      // buffer.
+      stats.updateElevation(i);
+      stats.updateGrade(1, 100);
+      assertEquals(Double.NEGATIVE_INFINITY, stats.getMaxGrade());
+      assertEquals(Double.POSITIVE_INFINITY, stats.getMinGrade());
+    }
+  }
+
+  public void testUpdateSpeedIncludeZero() {
+    for (int i = 0; i < 1000; i++) {
+      stats.updateSpeed(i + 1000, 0.0, i, 4.0);
+      assertEquals(0.0, stats.getMaxSpeed());
+      assertEquals((i + 1) * 1000, stats.getMovingTime());
+    }
+  }
+
+  public void testUpdateSpeedIngoreErrorCode() {
+    stats.updateSpeed(12345000, 128.0, 12344000, 0.0);
+    assertEquals(0.0, stats.getMaxSpeed());
+    assertEquals(1000, stats.getMovingTime());
+  }
+
+  public void testUpdateSpeedIngoreLargeAcceleration() {
+    stats.updateSpeed(12345000, 100.0, 12344000, 1.0);
+    assertEquals(0.0, stats.getMaxSpeed());
+    assertEquals(1000, stats.getMovingTime());
+  }
+
+  public void testUpdateSpeed() {
+    for (int i = 0; i < 1000; i++) {
+      stats.updateSpeed(i + 1000, 4.0, i, 4.0);
+      assertEquals((i + 1) * 1000, stats.getMovingTime());
+      if (i > MyTracksConstants.SPEED_SMOOTHING_FACTOR) {
+        assertEquals(4.0, stats.getMaxSpeed());
+      }
+    }
+  }
+}