diff -r f5050f1da672 -r 04becd199f91 javaextensions/location/tsrc/vipertest/src/PeriodicUpdateTest.java --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/javaextensions/location/tsrc/vipertest/src/PeriodicUpdateTest.java Tue Apr 27 16:30:29 2010 +0300 @@ -0,0 +1,391 @@ +/* +* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: +* +*/ +import javax.microedition.location.*; + +class PeriodicUpdateTest extends ViperUnitTest implements LocationListener +{ + final static int ONLY_STATUS_INTERVAL = 0; + + final static int DEFAULT_INTERVAL = -1; + + final static int INTERVAL = 10; + + final static int TIMEOUT = 3; + + final static int MAXAGE = 2; + + final static int LARGE_TIMEOUT = 12; + + final static int LARGE_MAXAGE = 11; + + final static int[] badInterval = new int[] { -2, -12345, Integer.MIN_VALUE }; + + final static int[] badTimeout = new int[] { 0, -2, -12345, + Integer.MIN_VALUE + }; + + final static int[] badMaxAge = badTimeout; + + private Coordinates currentCoords; + + private Location[] iLocations; + + private int iNumUpdates; + + private long[] iLocUpdateCallbackTime; + + PeriodicUpdateTest() + { + super("PeriodicUpdateTest"); + } + + protected void runTest() throws Throwable + { + testBadArguments(); + testGoodArguments(); + testLocationListenerDefault(); + testLocationListenerInterval_1s(); + testLocationListenerInterval_3s(); + testLocationListenerInterval_7s(); + testLocationListenerTimeout(); + testLocationListenerMaxAge(); + testChangeListener(); + } + + private void testBadArguments() + { + setCurrentTest("testBadArguments()"); + providerSetUp(null); + assertTrue(iLP != null, "LocationProvider is null"); + + assertBad(INTERVAL, TIMEOUT, LARGE_MAXAGE); // MaxAge > Interval + assertBad(INTERVAL, LARGE_TIMEOUT, MAXAGE); // Timeout > Interval + assertBad(INTERVAL, LARGE_TIMEOUT, LARGE_MAXAGE); + + for (int i = 0; i < badInterval.length; ++i) + { + assertBad(badInterval[i], TIMEOUT, MAXAGE); + } + + for (int i = 0; i < badTimeout.length; ++i) + { + assertBad(INTERVAL, badTimeout[i], MAXAGE); + assertBad(INTERVAL, badTimeout[i], LARGE_MAXAGE); + } + + for (int i = 0; i < badMaxAge.length; ++i) + { + assertBad(INTERVAL, TIMEOUT, badMaxAge[i]); + assertBad(INTERVAL, LARGE_TIMEOUT, badMaxAge[i]); + } + + for (int i = 0; i < badInterval.length; ++i) + { + for (int j = 0; j < badTimeout.length; ++j) + { + for (int k = 0; k < badMaxAge.length; ++k) + { + assertBad(badInterval[i], badTimeout[j], badMaxAge[k]); + } + } + } + + } + + private void testGoodArguments() + { + setCurrentTest("testGoodArguments()"); + providerSetUp(null); + assertTrue(iLP != null, "LocationProvider is null"); + + // These arguments should not throw exceptions + testGoodWithBad(this, DEFAULT_INTERVAL); + testGoodWithBad(this, ONLY_STATUS_INTERVAL); + + testGoodWithBad(null, INTERVAL); + testGoodWithBad(null, DEFAULT_INTERVAL); + testGoodWithBad(null, ONLY_STATUS_INTERVAL); + + for (int i = 0; i < badInterval.length; ++i) + { + testGoodWithBad(null, badInterval[i]); + } + + int bigValue = Integer.MAX_VALUE / 1000000; + assertGood(this, bigValue, bigValue, bigValue); + + assertGood(this, Integer.MAX_VALUE, Integer.MAX_VALUE, + Integer.MAX_VALUE); + } + + private void testLocationListenerDefault() + { + setCurrentTest("testLocationListenerDefault()"); + final int MAXTIME = 1000 * (TIMETOFIX + 13 + 1); // Interval ~ 6.25 + + providerSetUp(null); // Simulation PSY should be default + assertTrue(iLP != null, "LocationProvider is null"); + + // Start listening for location changes + iLP.setLocationListener(this, -1, -1, -1); + + getUpdates(2, MAXTIME); + + checkLocationData(iLocations[0]); + checkLocationData(iLocations[1]); + + iLocations = null; + } + + private void testLocationListenerInterval_1s() + { + setCurrentTest("testLocationListenerInterval_1s()"); + + testInterval(1, 4); + } + + private void testLocationListenerInterval_3s() + { + setCurrentTest("testLocationListenerInterval_3s()"); + + testInterval(3, 5); + } + + private void testLocationListenerInterval_7s() + { + setCurrentTest("testLocationListenerInterval_7s()"); + + testInterval(7, 3); + } + + private void testLocationListenerTimeout() + { + } + + private void testLocationListenerMaxAge() + { + } + + private void testChangeListener() + { + setCurrentTest("testChangeListener()"); + providerSetUp(null); + assertTrue(iLP != null, "LocationProvider is null"); + + final int PERIOD1 = 10; // seconds + final int PERIOD2 = 7; // seconds + + LocationListener listener = new LocationListener() + { + public void providerStateChanged(LocationProvider lp, int s) + { + } + + public void locationUpdated(LocationProvider lp, Location l) + { + } + }; + + // Change interval + iLP.setLocationListener(this, PERIOD1, -1, -1); + int maxtime = 1000 * (2 * PERIOD1 + TIMETOFIX); + getUpdates(2, maxtime); + + iLP.setLocationListener(this, PERIOD2, -1, -1); + maxtime = 1000 * (2 * PERIOD2 + TIMETOFIX); + getUpdates(2, maxtime); + + // Change listener + iLP.setLocationListener(listener, -1, -1, -1); + + tearDown(); + } + + private void tearDown() + { + // Remove this class as listener + try + { + if (iLP != null) + { + iLP.setLocationListener(null, -1, -1, -1); + } + } + catch (Exception e) + { + echo("PeriodicUpdateTest: Could not remove listener!"); + echo("PeriodicUpdateTest: Exception thrown: " + e); + } + } + + public void providerStateChanged(LocationProvider l, int event) + { + } + + public void locationUpdated(LocationProvider l, Location fix) + { + iLocUpdateCallbackTime[iNumUpdates] = System.currentTimeMillis(); + + echo("PeriodicUpdateTest.locationUpdated() called"); + iLocations[iNumUpdates] = fix; + ++iNumUpdates; + assertTrue(l != null, "LocationProvider is null"); + } + + // ------------------------ Helper methods ----------------------- + + private void assertBad(int aInterval, int aTimeout, int aMaxAge) + { + try + { + iLP.setLocationListener(this, aInterval, aTimeout, aMaxAge); + // Oops, no exception thrown, remove listener + iLP.setLocationListener(null, -1, -1, -1); + assertTrue(false, "Bad arguments should throw exception: " + + aInterval + "," + aTimeout + "," + aMaxAge); + } + catch (IllegalArgumentException iae) + { + // OK + assertNoMessage(iae); + } + catch (Exception e) + { + assertTrue(false, "Unknown error: " + e); + } + } + + private void testGoodWithBad(LocationListener aListener, int aInterval) + { + assertGood(aListener, aInterval, LARGE_TIMEOUT, LARGE_MAXAGE); + + for (int i = 0; i < badTimeout.length; ++i) + { + assertGood(aListener, aInterval, badTimeout[i], LARGE_MAXAGE); + } + + for (int i = 0; i < badMaxAge.length; ++i) + { + assertGood(aListener, aInterval, LARGE_TIMEOUT, badMaxAge[i]); + } + + for (int j = 0; j < badTimeout.length; ++j) + { + for (int k = 0; k < badMaxAge.length; ++k) + { + assertGood(aListener, aInterval, badTimeout[j], badMaxAge[k]); + } + } + } + + private void assertGood(LocationListener aListener, int aInterval, + int aTimeout, int aMaxAge) + { + try + { + iLP.setLocationListener(aListener, aInterval, aTimeout, aMaxAge); + } + catch (IllegalArgumentException iae) + { + assertTrue(false, "setLocationListener(" + aListener + "," + + aInterval + "," + aTimeout + "," + aMaxAge + + ") threw exception:\n" + iae); + } + + // remove listener + tearDown(); + } + + private void testInterval(int aInterval, int aNumberOfFixes) + { + assertTrue(aNumberOfFixes > 0, "Must test with at least one fix!"); + + final int TIMETOFIX = 100; // 100 ms + final int TIMEOUT = 1000 + 2 * TIMETOFIX; + final int MAXTIME = 1000 * (aNumberOfFixes * aInterval) + TIMEOUT; + + Criteria criteria = new Criteria(); + criteria.setPreferredResponseTime(TIMETOFIX); + + providerSetUp(criteria); + assertTrue(iLP != null, "LocationProvider is null"); + + // Start listening for location changes + iLP.setLocationListener(this, aInterval, -1, -1); + + getUpdates(aNumberOfFixes, MAXTIME); + + checkLocationData(iLocations[0]); + // Fixes at interval starts after first fix + long startTime = iLocUpdateCallbackTime[0]; + long lastTimeOfFix = startTime; + + for (int i = 1; i < aNumberOfFixes; ++i) + { + checkLocationData(iLocations[i]); + long timeOfFix = iLocUpdateCallbackTime[i]; + long timeDiff = timeOfFix - lastTimeOfFix; + assertTrue(timeDiff > (aInterval - TIMEOUT) * 1000, + "Period difference is less than allowed for fix" + i + ": " + + timeDiff); + assertTrue(timeDiff < (aInterval + TIMEOUT) * 1000, + "Period difference is more than allowed for fix" + i + ": " + + timeDiff); + assertTrue((timeOfFix - startTime) < ((i + 1) * aInterval * 1000), + "Timestamp too late for fix" + i); + lastTimeOfFix = timeOfFix; + } + + iLocations = null; + } + + private void getUpdates(int aNumUpdates, int aTimeout) + { + iLocations = new Location[aNumUpdates]; + iLocUpdateCallbackTime = new long[aNumUpdates]; + iNumUpdates = 0; + + // Wait for the first result or timeout + boolean timeout = false; + long startTime = System.currentTimeMillis(); + while (iNumUpdates < aNumUpdates) + { + // Wait a moment before checking things + try + { + Thread.sleep(250); + } + catch (InterruptedException ie) + { + } + + // Use a safeguard timeout in case the updating thread hangs + // or takes too long + if (System.currentTimeMillis() - startTime > aTimeout) + { + echo("Timeout (updates = " + iNumUpdates + ")"); + timeout = true; + break; + } + } + + tearDown(); + + assertTrue(!timeout, "Got a timeout"); + } + +}