Added Roboelectric tests to test the new DesiredYawCalculator, and applying it to the DroneService. Thanks @nenick for your Roboelectric project!

Author: rocboronat

app/build.gradle

@@ -20,11 +20,18 @@ android {
     }
 }
 
+apply from: 'build.workaround-missing-resource.gradle'
+
 dependencies {
     compile fileTree(dir: 'libs', include: ['*.jar'])
     compile 'com.android.support:appcompat-v7:21.0.3'
     compile 'de.greenrobot:eventbus:2.4.0'
     compile 'com.google.code.gson:gson:2.3.1'
     compile 'com.squareup.phrase:phrase:1.1.0'
     compile 'com.android.support:design:22.2.0'
+
+    testCompile 'junit:junit:4.12'
+    testCompile "org.mockito:mockito-core:1.9.5"
+    testCompile 'org.apache.maven:maven-ant-tasks:2.1.3'
+    testCompile "org.robolectric:robolectric:3.0-rc3"
 }

app/build.workaround-missing-resource.gradle

@@ -0,0 +1,45 @@
+// Workaround for missing test resources when run unit tests within android studio.
+// This copy the test resources next to the test classes for each variant.
+// Tracked at https://github.com/nenick/AndroidStudioAndRobolectric/issues/7
+// Original solution comes from https://code.google.com/p/android/issues/detail?id=136013#c10
+
+gradle.projectsEvaluated {
+    // Base path which is recognized by android studio.
+    def testClassesPath = "${buildDir}/intermediates/classes/test/"
+    // Copy must be done for each variant.
+    def variants = android.applicationVariants.collect()
+
+    variants.each { variant ->
+        def variationName = variant.name.capitalize()
+
+        // Get the flavor and also merge flavor groups.
+        def productFlavorNames = variant.productFlavors.collect { it.name.capitalize() }
+        if (productFlavorNames.isEmpty()) {
+            productFlavorNames = [""]
+        }
+        productFlavorNames = productFlavorNames.join('')
+
+        // Base path addition for this specific variant.
+        def variationPath = variant.buildType.name;
+        if (productFlavorNames != null && !productFlavorNames.isEmpty()) {
+            variationPath = uncapitalize(productFlavorNames) + "/${variationPath}"
+        }
+
+        // Specific copy task for each variant
+        def copyTestResourcesTask = project.tasks.create("copyTest${variationName}Resources", Copy)
+        copyTestResourcesTask.from("${projectDir}/src/test/resources")
+        copyTestResourcesTask.into("${testClassesPath}/${variationPath}")
+        copyTestResourcesTask.execute()
+    }
+}
+
+def uncapitalize(String str) {
+    int strLen;
+    if (str == null || (strLen = str.length()) == 0) {
+        return str;
+    }
+    return new StringBuffer(strLen)
+            .append(Character.toLowerCase(str.charAt(0)))
+            .append(str.substring(1))
+            .toString();
+}

app/src/androidTest/java/com/fewlaps/flone/ApplicationTest.java

@@ -0,0 +1,22 @@
+package com.fewlaps.flone;
+
+/**
+ * A tool to get the yaw the user wants to send to the drone. The idea is that
+ * droneHeading and desiresHeading are values from -180 to 180.
+ *
+ * @author Roc Boronat ([email protected])
+ * @date 05/07/2015
+ */
+public class DesiredYawCalculator {
+    public double getYaw(double droneHeading, double phoneHeading) {
+        double difference = phoneHeading - droneHeading;
+
+        if (difference > 180) {
+            difference = difference - 180 * 2;
+        } else if (difference < -180) {
+            difference = difference + 180 * 2;
+        }
+
+        return difference;
+    }
+}

app/src/main/java/com/fewlaps/flone/DesiredYawCalculator.java

@@ -4,6 +4,7 @@
 import android.os.Handler;
 import android.util.Log;
 
+import com.fewlaps.flone.DesiredYawCalculator;
 import com.fewlaps.flone.data.KnownDronesDatabase;
 import com.fewlaps.flone.data.bean.Drone;
 import com.fewlaps.flone.io.bean.DroneConnectionStatusChanged;
@@ -50,6 +51,7 @@ public class DroneService extends BaseService {
     private PhoneOutputData phoneOutputData = new PhoneOutputData();
 
     public static final RCSignals rc = new RCSignals(); //Created at startup, never changed, never destroyed, totally reused at every request
+    DesiredYawCalculator yawCalculator = new DesiredYawCalculator();
 
     @Override
     public int onStartCommand(Intent intent, int flags, int startId) {
@@ -92,8 +94,10 @@ public void onEventMainThread(DroneConnectionStatusChanged status) {
      * to do before sending the RC to the drone, to make it fly as the user excepts
      */
     private void updateRCWithInputData() {
-        int yaw = (int) (userInput.getHeading() - droneInput.getHeading());
-        int pitch = (int) (userInput.getPitch());
+        Log.i("HEADING", "phone: " + userInput.getHeading() + "   drone: " + droneInput.getHeading());
+
+        int yaw = (int) yawCalculator.getYaw(droneInput.getHeading(), userInput.getHeading());
+        int pitch = (int) userInput.getPitch();
         int roll = (int) userInput.getRoll();
 
         rc.setThrottle(userInput.getThrottle());

app/src/main/java/com/fewlaps/flone/service/DroneService.java

@@ -0,0 +1,49 @@
+package com.fewlaps.flone;
+
+
+import org.junit.runners.model.InitializationError;
+import org.robolectric.RobolectricGradleTestRunner;
+import org.robolectric.annotation.Config;
+import org.robolectric.manifest.AndroidManifest;
+import org.robolectric.res.FileFsFile;
+import org.robolectric.res.FsFile;
+
+
+/**
+ * More dynamic path resolution.
+ *
+ * This workaround is only for Mac Users necessary and only if they don't use the $MODULE_DIR$
+ * workaround mentioned at http://robolectric.org/getting-started/.
+ *
+ * Follow this issue at https://code.google.com/p/android/issues/detail?id=158015
+ */
+public class CustomRobolectricRunner extends RobolectricGradleTestRunner {
+
+
+    public CustomRobolectricRunner(Class<?> klass) throws InitializationError {
+        super(klass);
+    }
+
+
+    protected AndroidManifest getAppManifest(Config config) {
+        AndroidManifest appManifest = super.getAppManifest(config);
+        FsFile androidManifestFile = appManifest.getAndroidManifestFile();
+
+
+        if (androidManifestFile.exists()) {
+            return appManifest;
+        } else {
+            String moduleRoot = getModuleRootPath(config);
+            androidManifestFile = FileFsFile.from(moduleRoot, appManifest.getAndroidManifestFile().getPath().replace("bundles", "manifests/full"));
+            FsFile resDirectory = FileFsFile.from(moduleRoot, appManifest.getResDirectory().getPath().replace("/res", "").replace("bundles", "res"));
+            FsFile assetsDirectory = FileFsFile.from(moduleRoot, appManifest.getAssetsDirectory().getPath().replace("/assets", "").replace("bundles", "assets"));
+            return new AndroidManifest(androidManifestFile, resDirectory, assetsDirectory);
+        }
+    }
+
+
+    private String getModuleRootPath(Config config) {
+        String moduleRoot = config.constants().getResource("").toString().replace("file:", "");
+        return moduleRoot.substring(0, moduleRoot.indexOf("/build"));
+    }
+}

app/src/test/java/com/fewlaps/flone/CustomRobolectricRunner.java

@@ -0,0 +1,77 @@
+package com.fewlaps.flone;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import static junit.framework.Assert.assertEquals;
+
+/**
+ * @author Roc Boronat ([email protected])
+ * @date 05/07/2015
+ */
+public class DesiredYawTest {
+
+    DesiredYawCalculator desiredYaw;
+
+    @Before
+    public void init(){
+        desiredYaw = new DesiredYawCalculator();
+    }
+
+    @Test
+    public void shouldReturn0ForSameValues() {
+        double sameValue = 42;
+        double yaw = desiredYaw.getYaw(sameValue, sameValue);
+
+        assertEquals(0d, yaw);
+    }
+
+    @Test
+     public void shouldReturn20ForDroneAt0AndPhoneAt20() {
+        double yaw = desiredYaw.getYaw(0, 20);
+
+        assertEquals(20d, yaw);
+    }
+
+    @Test
+    public void shouldReturn30ForDroneAt50AndPhoneAt80() {
+        double yaw = desiredYaw.getYaw(50, 80);
+
+        assertEquals(30d, yaw);
+    }
+
+    @Test
+    public void shouldReturn20ForDroneAtMinus10AndPhoneAt10() {
+        double yaw = desiredYaw.getYaw(-10, 10);
+
+        assertEquals(20d, yaw);
+    }
+
+    @Test
+    public void shouldReturn20ForDroneAtMinus170AndPhoneAtMinus150() {
+        double yaw = desiredYaw.getYaw(-170, -150);
+
+        assertEquals(20d, yaw);
+    }
+
+    @Test
+    public void shouldReturnMinus20ForDroneAtMinus170AndPhoneAt170() {
+        double yaw = desiredYaw.getYaw(-170, 170);
+
+        assertEquals(-20d, yaw);
+    }
+
+    @Test
+    public void shouldReturn20ForDroneAt170AndPhoneAtMinus170() {
+        double yaw = desiredYaw.getYaw(170, -170);
+
+        assertEquals(20d, yaw);
+    }
+
+    @Test
+    public void shouldReturn170ForDroneAtMinus20AndPhoneAt150() {
+        double yaw = desiredYaw.getYaw(-20, 150);
+
+        assertEquals(170d, yaw);
+    }
+}

app/src/test/java/com/fewlaps/flone/DesiredYawTest.java

@@ -0,0 +1 @@
+constants=com.fewlaps.flone.BuildConfig