diff -r f5050f1da672 -r 04becd199f91 javaextensions/location/tsrc/junit/src/automatic/PeriodicUpdateTest.java
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/javaextensions/location/tsrc/junit/src/automatic/PeriodicUpdateTest.java	Tue Apr 27 16:30:29 2010 +0300
@@ -0,0 +1,525 @@
+/*
+* 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:
+*
+*/
+package com.nokia.mj.test.lapi;
+
+import j2meunit.framework.*;
+import javax.microedition.location.*;
+
+public class PeriodicUpdateTest extends TestCase 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;
+
+    final static int TIMETOFIX = 5;
+
+    protected LocationProvider iLP = null;
+
+    long[] iTimeArray;
+
+    public PeriodicUpdateTest()
+    {
+    }
+
+    public PeriodicUpdateTest(String sTestName, TestMethod rTestMethod)
+    {
+        super(sTestName, rTestMethod);
+    }
+
+    /***************************************************************************
+     * Creates the test suite. You need to add a new aSuite.addTest antry for
+     * any new test methods, otherwise they won't be run.
+     */
+    public Test suite()
+    {
+        TestSuite aSuite = new TestSuite();
+
+        aSuite.addTest(new PeriodicUpdateTest("testBadArguments",
+                                              new TestMethod()
+        {
+            public void run(TestCase tc)
+            {
+                ((PeriodicUpdateTest) tc).testBadArguments();
+            }
+        }));
+
+        aSuite.addTest(new PeriodicUpdateTest("testGoodArguments",
+                                              new TestMethod()
+        {
+            public void run(TestCase tc)
+            {
+                ((PeriodicUpdateTest) tc).testGoodArguments();
+            }
+        }));
+
+        aSuite.addTest(new PeriodicUpdateTest("testLocationListenerDefault",
+                                              new TestMethod()
+        {
+            public void run(TestCase tc)
+            {
+                ((PeriodicUpdateTest) tc).testLocationListenerDefault();
+            }
+        }));
+
+        aSuite.addTest(new PeriodicUpdateTest(
+                           "testLocationListenerInterval_1s", new TestMethod()
+        {
+            public void run(TestCase tc)
+            {
+                ((PeriodicUpdateTest) tc)
+                .testLocationListenerInterval_1s();
+            }
+        }));
+
+        aSuite.addTest(new PeriodicUpdateTest(
+                           "testLocationListenerInterval_3s", new TestMethod()
+        {
+            public void run(TestCase tc)
+            {
+                ((PeriodicUpdateTest) tc)
+                .testLocationListenerInterval_3s();
+            }
+        }));
+
+        aSuite.addTest(new PeriodicUpdateTest(
+                           "testLocationListenerInterval_7s", new TestMethod()
+        {
+            public void run(TestCase tc)
+            {
+                ((PeriodicUpdateTest) tc)
+                .testLocationListenerInterval_7s();
+            }
+        }));
+
+        aSuite.addTest(new PeriodicUpdateTest("testChangeListener",
+                                              new TestMethod()
+        {
+            public void run(TestCase tc)
+            {
+                ((PeriodicUpdateTest) tc).testChangeListener();
+            }
+        }));
+
+        return aSuite;
+
+    }
+
+    private void assertContinue(String aReason, boolean aCond)
+    {
+        if (!aCond)
+            assertTrue(aReason, false);
+    }
+
+    public void testBadArguments()
+    {
+        providerSetUp(null);
+        assertContinue("LocationProvider is null", iLP != 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]);
+                }
+            }
+        }
+        assertTrue("", true);
+    }
+
+    public void testGoodArguments()
+    {
+        providerSetUp(null);
+        assertContinue("LocationProvider is null", iLP != 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);
+
+        assertTrue("", true);
+    }
+
+    public void testLocationListenerDefault()
+    {
+        final int MAXTIME = 1000 * (TIMETOFIX + 13 + 1); // Interval ~ 6.25
+
+        providerSetUp(null); // Simulation PSY should be default
+        assertContinue("LocationProvider is null", iLP != null);
+
+        // Start listening for location changes
+        iLP.setLocationListener(this, -1, -1, -1);
+
+        getUpdates(2, MAXTIME);
+
+        checkLocationData(iLocations[0]);
+        checkLocationData(iLocations[1]);
+
+        iLocations = null;
+        assertTrue("", true);
+    }
+
+    public void testLocationListenerInterval_1s()
+    {
+        testInterval(1, 4);
+        assertTrue("", true);
+    }
+
+    public void testLocationListenerInterval_3s()
+    {
+        testInterval(3, 5);
+        assertTrue("", true);
+    }
+
+    public void testLocationListenerInterval_7s()
+    {
+        testInterval(7, 3);
+        assertTrue("", true);
+    }
+
+    public void testChangeListener()
+    {
+        providerSetUp(null);
+        assertContinue("LocationProvider is null", iLP != 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);
+
+        try
+        {
+            if (iLP != null)
+                iLP.setLocationListener(null, -1, -1, -1);
+        }
+        catch (Exception e)
+        {
+        }
+        assertTrue("", true);
+    }
+
+    public void providerStateChanged(LocationProvider l, int event)
+    {
+    }
+
+    public void locationUpdated(LocationProvider l, Location fix)
+    {
+        iLocUpdateCallbackTime[iNumUpdates] = System.currentTimeMillis();
+
+        iLocations[iNumUpdates] = fix;
+        ++iNumUpdates;
+        assertContinue("LocationProvider is null", l != 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);
+            assertContinue("Bad arguments should throw exception: " + aInterval
+                           + "," + aTimeout + "," + aMaxAge, false);
+        }
+        catch (IllegalArgumentException iae)
+        {
+            // OK
+            assertContinue("no message allowed for the exception: " + iae, iae
+                           .getMessage() == null);
+        }
+        catch (Exception e)
+        {
+            assertContinue("Unknown error: " + e, false);
+        }
+    }
+
+    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)
+        {
+            assertContinue("setLocationListener(" + aListener + "," + aInterval
+                           + "," + aTimeout + "," + aMaxAge + ") threw exception:\n"
+                           + iae, false);
+        }
+
+        // remove listener
+        try
+        {
+            if (iLP != null)
+                iLP.setLocationListener(null, -1, -1, -1);
+        }
+        catch (Exception e)
+        {
+        }
+    }
+
+    private void testInterval(int aInterval, int aNumberOfFixes)
+    {
+        assertContinue("Must test with at least one fix!", aNumberOfFixes > 0);
+
+        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);
+        assertContinue("LocationProvider is null", iLP != 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;
+            assertContinue("Period difference is less than allowed for fix" + i
+                           + ": " + timeDiff, timeDiff > (aInterval - TIMEOUT) * 1000);
+            assertContinue("Period difference is more than allowed for fix" + i
+                           + ": " + timeDiff, timeDiff < (aInterval + TIMEOUT) * 1000);
+            assertContinue("Timestamp too late for fix" + i,
+                           (timeOfFix - startTime) < ((i + 1) * aInterval * 1000));
+            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)
+            {
+                timeout = true;
+                break;
+            }
+        }
+
+        try
+        {
+            if (iLP != null)
+                iLP.setLocationListener(null, -1, -1, -1);
+        }
+        catch (Exception e)
+        {
+        }
+
+        assertContinue("Got a timeout", !timeout);
+    }
+
+    protected void providerSetUp(Criteria aCriteria)
+    {
+        iLP = null;
+        try
+        {
+            iLP = LocationProvider.getInstance(aCriteria);
+            if (iLP != null)
+            {
+                int state = iLP.getState();
+                assertContinue("Initial state=" + state
+                               + ", expected AVAILABLE",
+                               state == LocationProvider.AVAILABLE);
+            }
+        }
+        catch (LocationException le)
+        {
+        }
+    }
+
+    protected void checkLocationData(Location aLoc)
+    {
+        assertContinue("Location is null", aLoc != null);
+        assertContinue("Location is invalid", aLoc.isValid());
+        assertContinue("Location is valid, but Coordinates are null", aLoc
+                       .getQualifiedCoordinates() != null);
+
+        long timestamp = aLoc.getTimestamp();
+        long now = System.currentTimeMillis();
+        assertContinue("Timestamp incorrect: t=" + timestamp + ", now=" + now,
+                       now >= timestamp && (now - timestamp < 30000) && timestamp > 0);
+
+        QualifiedCoordinates coords = aLoc.getQualifiedCoordinates();
+        double lat = coords.getLatitude();
+        double lon = coords.getLongitude();
+
+        assertContinue("Latitude out of range", lat >= -90.0 || lat <= 90.0);
+        assertContinue("Longitude out of range", lon >= -180.0 || lon < 180.0);
+
+        float hacc = coords.getHorizontalAccuracy();
+        assertContinue("Horizontal accuracy is negative", Float.isNaN(hacc)
+                       || hacc >= 0);
+
+        float vacc = coords.getVerticalAccuracy();
+        assertContinue("Vertical accuracy is negative", Float.isNaN(vacc)
+                       || vacc >= 0);
+
+        float speed = aLoc.getSpeed();
+        assertContinue("Speed is negative", Float.isNaN(speed) || speed >= 0);
+
+        float course = aLoc.getCourse();
+        assertContinue("Course out of range", Float.isNaN(course)
+                       || (course >= 0 && course < 360));
+
+        String nmea = aLoc.getExtraInfo("application/X-jsr179-location-nmea");
+        if (nmea != null)
+        {
+            assertTrue("Bad NMEA data", nmea.startsWith("$GP"));
+        }
+    }
+}
+
+// End of file