/*
* 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 GetLocationTest extends TestCase
{
private Location iLoc;
final static int TIMETOFIX = 5;
protected LocationProvider iLP = null;
long[] iTimeArray;
public GetLocationTest()
{
}
public GetLocationTest(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 GetLocationTest("testBadArguments",
new TestMethod()
{
public void run(TestCase tc)
{
((GetLocationTest) tc).testBadArguments();
}
}));
aSuite.addTest(new GetLocationTest("testGetLocation", new TestMethod()
{
public void run(TestCase tc)
{
((GetLocationTest) tc).testGetLocation();
}
}));
aSuite.addTest(new GetLocationTest("testAltitudeData",
new TestMethod()
{
public void run(TestCase tc)
{
((GetLocationTest) tc).testAltitudeData();
}
}));
aSuite.addTest(new GetLocationTest("testSpeedData", new TestMethod()
{
public void run(TestCase tc)
{
((GetLocationTest) tc).testSpeedData();
}
}));
aSuite.addTest(new GetLocationTest("testAddressInfo", new TestMethod()
{
public void run(TestCase tc)
{
((GetLocationTest) tc).testAddressInfo();
}
}));
aSuite.addTest(new GetLocationTest("testGetLocationTimeout",
new TestMethod()
{
public void run(TestCase tc)
{
((GetLocationTest) tc).testGetLocationTimeout();
}
}));
aSuite.addTest(new GetLocationTest("testGetLatest", new TestMethod()
{
public void run(TestCase tc)
{
((GetLocationTest) tc).testGetLatest();
}
}));
return aSuite;
}
private void assertContinue(String aReason, boolean aCond)
{
if (!aCond)
assertTrue(aReason, false);
}
public void testBadArguments()
{
try
{
providerSetUp(null);
assertContinue("LocationProvider is null", iLP != null);
assertBad(0);
assertBad(-2);
assertBad(-12345); // Sanity check
assertBad(Integer.MIN_VALUE);
assertTrue("", true);
}
catch (Exception e)
{
assertTrue(e.getMessage(), false);
}
}
public void testGetLocation()
{
try
{
providerSetUp(null);
assertContinue("LocationProvider is null", iLP != null);
simpleGetLocation();
assertTrue("", true);
}
catch (Exception e)
{
assertTrue(e.getMessage(), false);
}
}
public void testAltitudeData()
{
try
{
Criteria criteria = new Criteria();
criteria.setAltitudeRequired(true);
criteria.setPreferredResponseTime(100); // 100 ms
providerSetUp(criteria);
assertContinue("LocationProvider is null", iLP != null);
simpleGetLocation();
QualifiedCoordinates coords = iLoc.getQualifiedCoordinates();
float altitude = coords.getAltitude();
assertContinue("No altitude included", !Float.isNaN(altitude));
assertTrue("", true);
}
catch (Exception e)
{
assertTrue(e.getMessage(), false);
}
}
public void testSpeedData()
{
try
{
Criteria criteria = new Criteria();
criteria.setPreferredResponseTime(100); // 100 ms
criteria.setSpeedAndCourseRequired(true);
providerSetUp(criteria);
assertContinue("LocationProvider is null", iLP != null);
simpleGetLocation();
float speed = iLoc.getSpeed();
assertContinue("No speed included", !Float.isNaN(speed));
float course = iLoc.getCourse();
assertContinue("No course included", !Float.isNaN(course));
assertTrue("", true);
}
catch (Exception e)
{
assertTrue(e.getMessage(), false);
}
}
public void testAddressInfo()
{
try
{
Criteria criteria = new Criteria();
criteria.setPreferredResponseTime(100); // 100 ms
criteria.setAddressInfoRequired(true);
providerSetUp(criteria);
if (iLP != null)
{
assertContinue("LocationProvider is null", iLP != null);
simpleGetLocation();
AddressInfo addr = iLoc.getAddressInfo();
if (addr != null)
{
boolean hasNonNullField = false;
for (int i = 1; i <= 17; ++i)
{
String field = addr.getField(i);
if (field != null)
{
hasNonNullField = true;
}
}
assertContinue("All AddressInfo fields are null",
hasNonNullField);
}
}
assertTrue("", true);
}
catch (Exception e)
{
assertTrue(e.getMessage(), false);
}
}
public void testGetLocationTimeout()
{
try
{
Criteria criteria = new Criteria();
criteria.setCostAllowed(false); // This will select the right
// provider
providerSetUp(criteria);
assertContinue("LocationProvider is null", iLP != null);
iLoc = null;
try
{
int TIMEOUT = 1; // seconds
iLoc = iLP.getLocation(TIMEOUT);
assertContinue("No timeout for getLocation", false);
}
catch (LocationException le)
{
// Timed out correctly
}
// Sanity check - test that normal request works ok
simpleGetLocation();
try
{
int TIMEOUT = 10; // seconds
long startTime = System.currentTimeMillis();
iLoc = iLP.getLocation(TIMEOUT);
long duration = System.currentTimeMillis() - startTime;
assertContinue("GetLocation took too long",
duration <= TIMEOUT * 1000);
checkLocationData(iLoc);
}
catch (LocationException le)
{
assertContinue("Illegal timeout", false);
}
assertTrue("", true);
}
catch (Exception e)
{
assertTrue(e.getMessage(), false);
}
}
public void testGetLatest()
{
iLP = null;
iLoc = null;
// Get the last known location
iLoc = LocationProvider.getLastKnownLocation();
assertTrue("", true);
}
public void testGetLocationOutOfService()
{
try
{
Criteria criteria = new Criteria();
criteria.setCostAllowed(false); // This will select the right
// provider
providerSetUp(criteria);
assertContinue("LocationProvider is null", iLP != null);
simpleGetLocation();
// now we get the last known Location:
Location lastKnownLocation = LocationProvider
.getLastKnownLocation();
checkLocationData(lastKnownLocation);
assertContinue("Not the last known location returned",
lastKnownLocation.getTimestamp() == iLoc.getTimestamp());
long start = System.currentTimeMillis();
long end = 0;
try
{
iLoc = iLP.getLocation(-1);
assertContinue("No exception thrown for getLocation", false);
}
catch (LocationException le)
{
// Exception thrown correctly
end = System.currentTimeMillis();
}
assertContinue("Expected LocationException immediately", end
- start < 500);
assertTrue("", true);
}
catch (Exception e)
{
assertTrue(e.getMessage(), false);
}
}
// ------------------------ Helper methods -----------------------
private void simpleGetLocation() throws Exception
{
iLoc = null;
try
{
iLoc = iLP.getLocation(-1);
checkLocationData(iLoc);
}
catch (LocationException le)
{
assertContinue("Could not get location: " + le, false);
}
}
private void assertBad(int aBadParam) throws Exception
{
try
{
iLoc = iLP.getLocation(aBadParam);
assertContinue("IllegalArgumentException was not thrown for: "
+ aBadParam, false);
}
catch (IllegalArgumentException iae)
{
// Exception thrown correctly
}
}
// ------------------------ Helper class -----------------------
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