tests/tests/location/src/android/location/cts/GnssMeasurementWhenNoLocationTest.java - platform/cts - Git at Google

 /*
  * Copyright (C) 2015 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 android.location.cts;

 import android.location.GnssMeasurement;
 import android.location.GnssMeasurementsEvent;
 import android.location.GpsStatus;
 import android.util.Log;

 import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;

 /**
  * Test for {@link GnssMeasurement} without a location fix.
  *
  * Test steps:
  * 1. Clear A-GPS: this ensures that the device is not in a warm mode and it has 4+ satellites
  *    acquired already.
  * 2. Register a listener for:
  *      - {@link GnssMeasurementsEvent}s,
  *      - location updates and
  *      - {@link GpsStatus} events.
  * 3. Wait for {@link GnssMeasurementsEvent}s to provide {@link EVENTS_COUNT} measurements
  * 4. Ensure that zero locations have been received
  * 5. Check {@link GnssMeasurementsEvent} status: if the status is not
  *    {@link GnssMeasurementsEvent#STATUS_READY}, the test will be skipped because one of the
  *    following reasons:
  *          4.1 the device does not support the feature,
  *          4.2 GPS Locaiton is disabled in the device && the test is CTS non-verifier
  * 6. Check whether the device is deep indoor. This is done by performing the following steps:
  *          4.1 If no {@link GpsStatus} is received this will mean that the device is located
  *              indoor. The test will be skipped if not strict (CTS or pre-2016.)
  * 7. When the device is not indoor, verify that we receive {@link GnssMeasurementsEvent}s before
  *    a GPS location is calculated, and reported by GPS HAL. If {@link GnssMeasurementsEvent}s are
  *    only received after a location update is received:
  *          4.1.1 The test will pass with a warning for the M release.
  *          4.1.2 The test will fail on N with CTS-Verifier & newer (2016+) GPS hardware.
  * 8. If {@link GnssMeasurementsEvent}s are received: verify all mandatory fields, the test will
  *    fail if any of the mandatory fields is not populated or in the expected range.
  */
 public class GnssMeasurementWhenNoLocationTest extends GnssTestCase {

     private static final String TAG = "GnssMeasBeforeLocTest";
     private TestGnssMeasurementListener mMeasurementListener;
     private TestGpsStatusListener mGpsStatusListener;
     private TestLocationListener mLocationListener;
     private static final int EVENTS_COUNT = 2;
     private static final int LOCATIONS_COUNT = 1;

     // Command to delete cached A-GPS data to get a truer GPS fix.
     private static final String AGPS_DELETE_COMMAND = "delete_aiding_data";

     @Override
     protected void setUp() throws Exception {
         super.setUp();

         mTestLocationManager = new TestLocationManager(getContext());
     }

     @Override
     protected void tearDown() throws Exception {
         // Unregister listeners
         if (mLocationListener != null) {
             mTestLocationManager.removeLocationUpdates(mLocationListener);
         }
         if (mMeasurementListener != null) {
             mTestLocationManager.unregisterGnssMeasurementCallback(mMeasurementListener);
         }
         if (mGpsStatusListener != null) {
             mTestLocationManager.removeGpsStatusListener(mGpsStatusListener);
         }
         super.tearDown();
     }

     /**
      * Test for GPS measurements before a location fix.
      */
     public void testGnssMeasurementWhenNoLocation() throws Exception {
         // Checks if GPS hardware feature is present, skips test (pass) if not,
         // and hard asserts that Location/GPS (Provider) is turned on if is Cts Verifier.
         if (!TestMeasurementUtil.canTestRunOnCurrentDevice(mTestLocationManager,
                 TAG, MIN_HARDWARE_YEAR_MEASUREMENTS_REQUIRED, isCtsVerifierTest())) {
             return;
         }

         // Clear A-GPS and skip the test if the operation fails.
         if (!mTestLocationManager.sendExtraCommand(AGPS_DELETE_COMMAND)) {
             Log.i(TAG, "A-GPS failed to clear. Skip test.");
             return;
         }

         // Register for GPS measurements.
         mMeasurementListener = new TestGnssMeasurementListener(TAG, EVENTS_COUNT);
         mTestLocationManager.registerGnssMeasurementCallback(mMeasurementListener);

         // Register for Gps Status updates.
         mGpsStatusListener = new TestGpsStatusListener(EVENTS_COUNT, mTestLocationManager);
         mTestLocationManager.addGpsStatusListener(mGpsStatusListener);

         // Register for location updates.
         mLocationListener = new TestLocationListener(LOCATIONS_COUNT);
         mTestLocationManager.requestLocationUpdates(mLocationListener);

         mMeasurementListener.awaitStatus();
         if (!mMeasurementListener.verifyStatus(isMeasurementTestStrict())) {
             return; // exit peacefully (if not already asserted out inside verifyStatus)
         }

         // Wait for two measurement events - this is better than waiting for a location calculation
         // because the test generally completes much faster.
         mMeasurementListener.await();

         Log.i(TAG, "mLocationListener.isLocationReceived(): "
                 + mLocationListener.isLocationReceived());

         SoftAssert.failOrWarning(isMeasurementTestStrict(),
                 "No Satellites are visible. Device may be indoors.  Retry outdoors?",
                 mGpsStatusListener.isGpsStatusReceived());

         List<GnssMeasurementsEvent> events = mMeasurementListener.getEvents();
         Log.i(TAG, "Number of GPS measurement events received = " + events.size());

         // Ensure that after getting a few (at least 2) measurements, that we still don't have
         // location (i.e. that we got measurements before location.)  Fail, if strict, warn, if not.
         SoftAssert.failOrWarning(isMeasurementTestStrict(),
                 "Location was received before " + events.size() +
                         " GnssMeasurementEvents with measurements were reported. " +
                         "Test expects at least " + EVENTS_COUNT +
                         " GnssMeasurementEvents before a location, given the cold start start. " +
                         "Ensure no other active GPS apps (so the cold start command works) " +
                         "and retry?",
                 !mLocationListener.isLocationReceived());
         if (mLocationListener.isLocationReceived() && !isMeasurementTestStrict()) {
             return; // allow a (passing) return, if not strict, otherwise continue
         }

         // If device is not indoors, verify
         // 1) that we receive GPS measurements before being able to calculate the position solution
         // 2) that mandatory fields of GnssMeasurement are in expected ranges.
         GnssMeasurementsEvent firstEvent = events.get(0);
         Collection<GnssMeasurement> gpsMeasurements = firstEvent.getMeasurements();
         int satelliteCount = gpsMeasurements.size();
         int[] gpsPrns = new int[satelliteCount];
         int i = 0;
         for (GnssMeasurement measurement : gpsMeasurements) {
             gpsPrns[i] = measurement.getSvid();
             ++i;
         }
         Log.i(TAG, "First GnssMeasurementsEvent with PRNs=" + Arrays.toString(gpsPrns));

         SoftAssert softAssert = new SoftAssert(TAG);
         long timeInNs = firstEvent.getClock().getTimeNanos();
         softAssert.assertTrue("GPS measurement satellite count check: ",
                 timeInNs, // event time in ns
                 "satelliteCount > 0", // expected value
                 Integer.toString(satelliteCount), // actual value
                 satelliteCount > 0); // condition

         TestMeasurementUtil.assertGnssClockFields(firstEvent.getClock(), softAssert, timeInNs);

         // Verify mandatory fields of GnssMeasurement
         for (GnssMeasurement measurement : gpsMeasurements) {
             TestMeasurementUtil.assertAllGnssMeasurementMandatoryFields(measurement,
                     softAssert, timeInNs);
         }
         softAssert.assertAll();
     }
 }
	/*
	* Copyright (C) 2015 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 android.location.cts;

	import android.location.GnssMeasurement;
	import android.location.GnssMeasurementsEvent;
	import android.location.GpsStatus;
	import android.util.Log;

	import java.util.Arrays;
	import java.util.Collection;
	import java.util.List;

	/**
	* Test for {@link GnssMeasurement} without a location fix.
	*
	* Test steps:
	* 1. Clear A-GPS: this ensures that the device is not in a warm mode and it has 4+ satellites
	* acquired already.
	* 2. Register a listener for:
	* - {@link GnssMeasurementsEvent}s,
	* - location updates and
	* - {@link GpsStatus} events.
	* 3. Wait for {@link GnssMeasurementsEvent}s to provide {@link EVENTS_COUNT} measurements
	* 4. Ensure that zero locations have been received
	* 5. Check {@link GnssMeasurementsEvent} status: if the status is not
	* {@link GnssMeasurementsEvent#STATUS_READY}, the test will be skipped because one of the
	* following reasons:
	* 4.1 the device does not support the feature,
	* 4.2 GPS Locaiton is disabled in the device && the test is CTS non-verifier
	* 6. Check whether the device is deep indoor. This is done by performing the following steps:
	* 4.1 If no {@link GpsStatus} is received this will mean that the device is located
	* indoor. The test will be skipped if not strict (CTS or pre-2016.)
	* 7. When the device is not indoor, verify that we receive {@link GnssMeasurementsEvent}s before
	* a GPS location is calculated, and reported by GPS HAL. If {@link GnssMeasurementsEvent}s are
	* only received after a location update is received:
	* 4.1.1 The test will pass with a warning for the M release.
	* 4.1.2 The test will fail on N with CTS-Verifier & newer (2016+) GPS hardware.
	* 8. If {@link GnssMeasurementsEvent}s are received: verify all mandatory fields, the test will
	* fail if any of the mandatory fields is not populated or in the expected range.
	*/
	public class GnssMeasurementWhenNoLocationTest extends GnssTestCase {

	private static final String TAG = "GnssMeasBeforeLocTest";
	private TestGnssMeasurementListener mMeasurementListener;
	private TestGpsStatusListener mGpsStatusListener;
	private TestLocationListener mLocationListener;
	private static final int EVENTS_COUNT = 2;
	private static final int LOCATIONS_COUNT = 1;

	// Command to delete cached A-GPS data to get a truer GPS fix.
	private static final String AGPS_DELETE_COMMAND = "delete_aiding_data";

	@Override
	protected void setUp() throws Exception {
	super.setUp();

	mTestLocationManager = new TestLocationManager(getContext());
	}

	@Override
	protected void tearDown() throws Exception {
	// Unregister listeners
	if (mLocationListener != null) {
	mTestLocationManager.removeLocationUpdates(mLocationListener);
	}
	if (mMeasurementListener != null) {
	mTestLocationManager.unregisterGnssMeasurementCallback(mMeasurementListener);
	}
	if (mGpsStatusListener != null) {
	mTestLocationManager.removeGpsStatusListener(mGpsStatusListener);
	}
	super.tearDown();
	}

	/**
	* Test for GPS measurements before a location fix.
	*/
	public void testGnssMeasurementWhenNoLocation() throws Exception {
	// Checks if GPS hardware feature is present, skips test (pass) if not,
	// and hard asserts that Location/GPS (Provider) is turned on if is Cts Verifier.
	if (!TestMeasurementUtil.canTestRunOnCurrentDevice(mTestLocationManager,
	TAG, MIN_HARDWARE_YEAR_MEASUREMENTS_REQUIRED, isCtsVerifierTest())) {
	return;
	}

	// Clear A-GPS and skip the test if the operation fails.
	if (!mTestLocationManager.sendExtraCommand(AGPS_DELETE_COMMAND)) {
	Log.i(TAG, "A-GPS failed to clear. Skip test.");
	return;
	}

	// Register for GPS measurements.
	mMeasurementListener = new TestGnssMeasurementListener(TAG, EVENTS_COUNT);
	mTestLocationManager.registerGnssMeasurementCallback(mMeasurementListener);

	// Register for Gps Status updates.
	mGpsStatusListener = new TestGpsStatusListener(EVENTS_COUNT, mTestLocationManager);
	mTestLocationManager.addGpsStatusListener(mGpsStatusListener);

	// Register for location updates.
	mLocationListener = new TestLocationListener(LOCATIONS_COUNT);
	mTestLocationManager.requestLocationUpdates(mLocationListener);

	mMeasurementListener.awaitStatus();
	if (!mMeasurementListener.verifyStatus(isMeasurementTestStrict())) {
	return; // exit peacefully (if not already asserted out inside verifyStatus)
	}

	// Wait for two measurement events - this is better than waiting for a location calculation
	// because the test generally completes much faster.
	mMeasurementListener.await();

	Log.i(TAG, "mLocationListener.isLocationReceived(): "
	+ mLocationListener.isLocationReceived());

	SoftAssert.failOrWarning(isMeasurementTestStrict(),
	"No Satellites are visible. Device may be indoors. Retry outdoors?",
	mGpsStatusListener.isGpsStatusReceived());

	List<GnssMeasurementsEvent> events = mMeasurementListener.getEvents();
	Log.i(TAG, "Number of GPS measurement events received = " + events.size());

	// Ensure that after getting a few (at least 2) measurements, that we still don't have
	// location (i.e. that we got measurements before location.) Fail, if strict, warn, if not.
	SoftAssert.failOrWarning(isMeasurementTestStrict(),
	"Location was received before " + events.size() +
	" GnssMeasurementEvents with measurements were reported. " +
	"Test expects at least " + EVENTS_COUNT +
	" GnssMeasurementEvents before a location, given the cold start start. " +
	"Ensure no other active GPS apps (so the cold start command works) " +
	"and retry?",
	!mLocationListener.isLocationReceived());
	if (mLocationListener.isLocationReceived() && !isMeasurementTestStrict()) {
	return; // allow a (passing) return, if not strict, otherwise continue
	}

	// If device is not indoors, verify
	// 1) that we receive GPS measurements before being able to calculate the position solution
	// 2) that mandatory fields of GnssMeasurement are in expected ranges.
	GnssMeasurementsEvent firstEvent = events.get(0);
	Collection<GnssMeasurement> gpsMeasurements = firstEvent.getMeasurements();
	int satelliteCount = gpsMeasurements.size();
	int[] gpsPrns = new int[satelliteCount];
	int i = 0;
	for (GnssMeasurement measurement : gpsMeasurements) {
	gpsPrns[i] = measurement.getSvid();
	++i;
	}
	Log.i(TAG, "First GnssMeasurementsEvent with PRNs=" + Arrays.toString(gpsPrns));

	SoftAssert softAssert = new SoftAssert(TAG);
	long timeInNs = firstEvent.getClock().getTimeNanos();
	softAssert.assertTrue("GPS measurement satellite count check: ",
	timeInNs, // event time in ns
	"satelliteCount > 0", // expected value
	Integer.toString(satelliteCount), // actual value
	satelliteCount > 0); // condition

	TestMeasurementUtil.assertGnssClockFields(firstEvent.getClock(), softAssert, timeInNs);

	// Verify mandatory fields of GnssMeasurement
	for (GnssMeasurement measurement : gpsMeasurements) {
	TestMeasurementUtil.assertAllGnssMeasurementMandatoryFields(measurement,
	softAssert, timeInNs);
	}
	softAssert.assertAll();
	}
	}