/*
* Copyright (C) 2012, Katy Hilgenberg.
* Special acknowledgments to: Knowledge & Data Engineering Group, University of Kassel (http://www.kde.cs.uni-kassel.de).
* Contact: sdcf@cs.uni-kassel.de
*
* This file is part of the SDCFramework (Sensor Data Collection Framework) project.
*
* The SDCFramework is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* The SDCFramework is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License
* along with the SDCFramework. If not, see <http://www.gnu.org/licenses/>.
*/
package de.unikassel.android.sdcframework.devices.tests;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import de.unikassel.android.sdcframework.data.Sample;
import de.unikassel.android.sdcframework.data.independent.TemperatureSampleData;
import de.unikassel.android.sdcframework.data.independent.SampleData;
import de.unikassel.android.sdcframework.devices.TemperatureDevice;
import de.unikassel.android.sdcframework.devices.TemperatureDeviceScanner;
import de.unikassel.android.sdcframework.devices.facade.SensorDeviceIdentifier;
import de.unikassel.android.sdcframework.test.DelegatingMockContext;
import de.unikassel.android.sdcframework.test.TestUtils;
import de.unikassel.android.sdcframework.util.TimeProvider;
import de.unikassel.android.sdcframework.util.tests.SampleEventObserverForTest;
import android.content.Context;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorManager;
import android.test.AndroidTestCase;
/**
* Tests for the temperature device and scanner classes
*
* @author Katy Hilgenberg
*
*/
public class TestTemperatureDeviceAndScanner extends AndroidTestCase
{
/**
* Flag for hardware availability
*/
private boolean isDeviceInGeneralAvailable = false;
/*
* (non-Javadoc)
*
* @see android.test.AndroidTestCase#setUp()
*/
protected void setUp() throws Exception
{
setContext( new DelegatingMockContext( getContext() ) );
if( !TimeProvider.getInstance().isSynced() )
TimeProvider.getInstance().updateTime( getContext() );
SensorManager sensorManager =
(SensorManager) getContext().getSystemService( Context.SENSOR_SERVICE );
isDeviceInGeneralAvailable =
sensorManager.getSensorList( Sensor.TYPE_TEMPERATURE ).size() > 0;
super.setUp();
}
/*
* (non-Javadoc)
*
* @see android.test.AndroidTestCase#tearDown()
*/
protected void tearDown() throws Exception
{
super.tearDown();
}
/**
* Test method to assure hardware is available in environment
*/
public void testPreconditions()
{
assertTrue( "Test environment does not support temperature",
isDeviceInGeneralAvailable );
assertTrue( "Timeprovider not initiallized - is internet access possible ( wlan or mobile)?",
TimeProvider.getInstance().isSynced() );
}
/**
* Test for device and scanner creation
*/
public void testDeviceAndScannerCreation()
{
testPreconditions();
// create device and scanner and link with each other
TemperatureDevice device = new TemperatureDevice( getContext() );
TemperatureDeviceScanner scanner = new TemperatureDeviceScanner();
device.setScanner( scanner, getContext() );
assertFalse( "Expected device scanning disabled initally",
device.isDeviceScanningEnabled() );
assertEquals( "Wrong device type", SensorDeviceIdentifier.Temperature,
device.getDeviceIdentifier() );
assertEquals( "Wrong sensor type", Sensor.TYPE_TEMPERATURE,
device.getSensor().getType() );
assertNotNull( "Expected sample not null", device.getSample() );
SampleData data = device.getSample().getData();
assertTrue( "Expected a sample of type TemperatureSample",
data instanceof TemperatureSampleData );
TemperatureSampleData convData = (TemperatureSampleData) data;
assertEquals( "Wrong initialisation", Float.MIN_VALUE, convData.getTemperature() );
assertEquals( "Expected device associated with scanner", scanner,
device.getScanner() );
assertEquals( "Expected scanner associated with device", device,
scanner.getDevice() );
assertFalse( "Expected scanner disabled initally", scanner.isEnabled() );
device.onDestroy( getContext() );
}
/**
* Test for device and scanner enable/disable
*/
public void testEnableDisableDeviceScanning()
{
testPreconditions();
// create device and scanner and link with each other
TemperatureDevice device = new TemperatureDevice( getContext() );
TemperatureDeviceScanner scanner = new TemperatureDeviceScanner();
device.setScanner( scanner, getContext() );
assertFalse( "Expected device scanning disabled",
device.isDeviceScanningEnabled() );
assertFalse( "Expected scanner disabled", scanner.isEnabled() );
device.getConfiguration().setEnabled( true );
device.enableDeviceScanning( true, getContext() );
assertTrue( "Expected device scanning enabled",
device.isDeviceScanningEnabled() );
assertTrue( "Expected scanner enabled", scanner.isEnabled() );
device.getConfiguration().setEnabled( false );
device.enableDeviceScanning( false, getContext() );
assertFalse( "Expected device scanning disabled",
device.isDeviceScanningEnabled() );
assertFalse( "Expected scanner disabled", scanner.isEnabled() );
device.onDestroy( getContext() );
}
/**
* Test for valid device sample updates
*/
public void testSampleUpdate()
{
testPreconditions();
// we do test the device here for injected sensor data and created samples
TemperatureDevice device = new TemperatureDevice( getContext() );
try
{
// create sensor event by using evil reflection to access the
// hidden constructor
Constructor< SensorEvent > constr =
SensorEvent.class.getDeclaredConstructor( int.class );
constr.setAccessible( true );
SensorEvent event = constr.newInstance( new Object[] { 3 } );
// add sensor values
event.values[ 0 ] = 12.4F;
device.doHandleSensorChanged( event );
TemperatureSampleData sampleData =
(TemperatureSampleData) device.getSample().getData();
assertEquals( "Unexpected sample value for temperature", event.values[ 0 ],
sampleData.getTemperature() );
device.onDestroy( getContext() );
}
catch ( InvocationTargetException e )
{
e.printStackTrace();
fail( "Unexpected InvocationTargetException" );
}
catch ( NoSuchMethodException e )
{
e.printStackTrace();
fail( "Unexpected NoSuchMethodException" );
}
catch ( InstantiationException e )
{
e.printStackTrace();
fail( "Unexpected InstantiationException" );
}
catch ( IllegalAccessException e )
{
e.printStackTrace();
fail( "Unexpected IllegalAccessException" );
}
}
/**
* Test for device and scanner sample performance
*/
public void testSampling()
{
testPreconditions();
final int maxSleepTime = 10000;
// create a sample observer
final SampleEventObserverForTest observer =
new SampleEventObserverForTest();
// create and configure a device
final TemperatureDevice device = new TemperatureDevice( getContext() );
device.getConfiguration().setEnabled( true );
// create scanner in looper thread to allow asynchronous event handling
/**
* Internal looper test thread
*
* @author Katy Hilgenberg
*
*/
class LooperThread extends LooperThreadForTest
{
/*
* (non-Javadoc)
*
* @see
* de.unikassel.android.sdcframework.devices.tests.LooperThreadForTest#
* doPrepareTest()
*/
@Override
public void doPrepareTest()
{
// create the scanner in the looper thread context to implicitly
// associate handler with the threads looper
TemperatureDeviceScanner scanner = new TemperatureDeviceScanner();
// attach scanner to device
device.setScanner( scanner, getContext() );
// add the event observer to the scanner
scanner.registerEventObserver( observer );
}
}
;
// create a looper thread instance
LooperThread looperThread = new LooperThread();
// start the looper thread and wait for preparation finished
looperThread.start();
while ( !looperThread.hasPreparationDone.get() )
{
TestUtils.sleep( 100 );
}
long ts = System.currentTimeMillis();
while( observer.observedEvents.size() < 1 &&
( System.currentTimeMillis() - ts ) < maxSleepTime )
{
TestUtils.sleep( 100 );
}
// disable device scanning
device.enableDeviceScanning( false, getContext() );
// test for samples taken ( uncommented due to low change rate, can not be tested that way )
// int sampleCount = observer.observedEvents.size();
// assertTrue( "Expected more samples taken", sampleCount >= 1 );
for ( Sample sample : observer.observedEvents )
{
assertEquals( "Unexpected device identifier",
SensorDeviceIdentifier.Temperature.toString(), sample.getDeviceIdentifier() );
assertTrue( "Unexpected sample data type",
sample.getData() instanceof TemperatureSampleData );
}
// stop looper thread
device.onDestroy( getContext() );
looperThread.interrupt();
}
}