update translated strings

2012-09-07 11:11:47 -07:00
commit 9eba8e4b64
702 changed files with 65694 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,105 @@
+/*
+ * 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);
+
+    // 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(60.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());
+  }
+
+  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());
+  }
+}
@@ -0,0 +1,221 @@
+// Copyright 2009 Google Inc. All Rights Reserved.
+
+package com.google.android.apps.mytracks.stats;
+
+import com.google.android.apps.mytracks.Constants;
+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 TripStatisticsUpdater tripStatisticsUpdater = null;
+
+  @Override
+  protected void setUp() throws Exception {
+    tripStatisticsUpdater = new TripStatisticsUpdater(System.currentTimeMillis());
+  }
+
+  public void testAddLocationSimple() throws Exception {
+    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());
+    
+    float speed = 11.1f;
+    for (int i = 0; i < 100; i++) {
+      Location location = new Location("test");
+      location.setAccuracy(1.0f);
+      location.setLongitude(45.0);
+
+      // Going up by 1 meter each time.
+      location.setAltitude(i);
+
+      // Moving by .001 degree latitude (111 meters)
+      location.setLatitude(i * .001);
+
+      location.setSpeed(speed);
+
+      // Each time slice is 10 seconds.
+      location.setTime(startTime + i * TEN_SECONDS);
+      tripStatisticsUpdater.addLocation(location, PreferencesUtils.MIN_RECORDING_DISTANCE_DEFAULT);
+
+      tripStatistics = tripStatisticsUpdater.getTripStatistics();
+      assertEquals(i * TEN_SECONDS, tripStatistics.getTotalTime());
+      assertEquals(i * TEN_SECONDS, tripStatistics.getMovingTime());
+      assertEquals(i, tripStatisticsUpdater.getSmoothedElevation(),
+          Constants.ELEVATION_SMOOTHING_FACTOR / 2);
+      assertEquals(0.0, tripStatistics.getMinElevation());
+      assertEquals(i, tripStatistics.getMaxElevation(), Constants.ELEVATION_SMOOTHING_FACTOR / 2);
+      assertEquals(i, tripStatistics.getTotalElevationGain(), Constants.ELEVATION_SMOOTHING_FACTOR);
+
+      if (i >= Constants.SPEED_SMOOTHING_FACTOR) {
+        assertEquals(speed, tripStatistics.getMaxSpeed(), 0.1);
+      }
+      if (i >= Constants.DISTANCE_SMOOTHING_FACTOR && i >= Constants.ELEVATION_SMOOTHING_FACTOR) {
+        // 1 m / 111 m = .009
+        assertEquals(0.009, tripStatistics.getMinGrade(), 0.0001);
+        assertEquals(0.009, tripStatistics.getMaxGrade(), 0.0001);
+      }
+      assertEquals(i * 111.0, tripStatistics.getTotalDistance(), 100);
+    }
+  }
+
+  /**
+   * 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++) {
+        assertEquals(0.0, tripStatisticsUpdater.updateElevation(elevation));
+        assertEquals(elevation, tripStatisticsUpdater.getSmoothedElevation());
+
+        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++) {
+      double expectedGain;
+      if (i < Constants.ELEVATION_SMOOTHING_FACTOR - 1) {
+        expectedGain = 0;
+      } else if (i < Constants.ELEVATION_SMOOTHING_FACTOR) {
+        expectedGain = 0.5;
+      } else {
+        expectedGain = 1.0;
+      }
+      assertEquals(expectedGain, tripStatisticsUpdater.updateElevation(i));
+      assertEquals(i, tripStatisticsUpdater.getSmoothedElevation(),
+          Constants.ELEVATION_SMOOTHING_FACTOR / 2);
+
+      TripStatistics data = tripStatisticsUpdater.getTripStatistics();
+      assertEquals(0.0, data.getMinElevation());
+      assertEquals(i, data.getMaxElevation(), Constants.ELEVATION_SMOOTHING_FACTOR / 2);
+      assertEquals(i, data.getTotalElevationGain(), Constants.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++) {
+      /*
+       * The value of the elevation does not matter. This is just to fill the
+       * elevation buffer.
+       */
+      tripStatisticsUpdater.updateElevation(i);
+      tripStatisticsUpdater.updateGrade(100, 100);
+      if (i >= Constants.GRADE_SMOOTHING_FACTOR && i >= Constants.ELEVATION_SMOOTHING_FACTOR) {
+        assertEquals(1.0, tripStatisticsUpdater.getTripStatistics().getMaxGrade());
+        assertEquals(1.0, tripStatisticsUpdater.getTripStatistics().getMinGrade());
+      }
+    }
+    for (double i = 0; i < 1000; i++) {
+      /*
+       * The value of the elevation does not matter. This is just to fill the
+       * elevation buffer.
+       */
+      tripStatisticsUpdater.updateElevation(i);
+      tripStatisticsUpdater.updateGrade(100, -100);
+      if (i >= Constants.GRADE_SMOOTHING_FACTOR && i >= Constants.ELEVATION_SMOOTHING_FACTOR) {
+        assertEquals(1.0, tripStatisticsUpdater.getTripStatistics().getMaxGrade());
+        assertEquals(-1.0, tripStatisticsUpdater.getTripStatistics().getMinGrade());
+      }
+    }
+  }
+
+  /**
+   * 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, 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 >= Constants.SPEED_SMOOTHING_FACTOR) {
+        assertEquals(speed, tripStatisticsUpdater.getTripStatistics().getMaxSpeed());
+      }
+    }
+  }
+}