Added tests for Util.java and optimized tests for Log.java

Author: hiteshsondhi88

FFmpegAndroid/build.gradle

@@ -13,13 +13,6 @@ android {
         versionName "0.2.2"
     }
 
-    packagingOptions {
-        exclude 'LICENSE.txt'
-        exclude 'META-INF/LICENSE'
-        exclude 'META-INF/LICENSE.txt'
-        exclude 'META-INF/NOTICE'
-    }
-
     sourceSets.main {
         assets.srcDirs = ['assets']
         jni.srcDirs = [] //disable automatic ndk-build
@@ -37,32 +30,6 @@ android {
 dependencies {
     compile fileTree(dir: 'libs', include: ['*.jar'])
 
-    androidTestCompile('junit:junit:4.11') {
-        exclude module: 'hamcrest-core'
-    }
-
-    androidTestCompile 'org.hamcrest:hamcrest-integration:1.1'
-    androidTestCompile 'org.hamcrest:hamcrest-core:1.1'
-    androidTestCompile 'org.hamcrest:hamcrest-library:1.1'
-
-    androidTestCompile('org.robolectric:robolectric:2.3') {
-        exclude module: 'classworlds'
-        exclude module: 'commons-logging'
-        exclude module: 'httpclient'
-        exclude module: 'maven-artifact'
-        exclude module: 'maven-artifact-manager'
-        exclude module: 'maven-error-diagnostics'
-        exclude module: 'maven-model'
-        exclude module: 'maven-project'
-        exclude module: 'maven-settings'
-        exclude module: 'plexus-container-default'
-        exclude module: 'plexus-interpolation'
-        exclude module: 'plexus-utils'
-        exclude module: 'wagon-file'
-        exclude module: 'wagon-http-lightweight'
-        exclude module: 'wagon-provider-api'
-    }
-
     androidTestCompile 'com.squareup.assertj:assertj-android:1.0.0'
 }
 

FFmpegAndroid/src/androidTest/java/com/github/hiteshsondhi88/libffmpeg/LogTest.java

@@ -1,12 +1,10 @@
 package com.github.hiteshsondhi88.libffmpeg;
 
-import org.junit.runner.RunWith;
-import org.robolectric.RobolectricTestRunner;
+import com.github.hiteshsondhi88.libffmpeg.utils.AssertionHelper;
 
 /**
  * Trying Logging everything I can Log.java class should never throw any error
  */
-@RunWith(RobolectricTestRunner.class)
 public class LogTest extends CommonTestCase {
 
     private Object[] OBJECTS_TO_TEST = {null, "", "test string", 1, 1.00123, 2.45225747946181e-072};
@@ -86,7 +84,7 @@ public void print(Throwable throwable) throws Exception {
                 try {
                     Log.e(obj, throwable);
                 } catch (Exception e) {
-                    AssertionHelper.assertError("Logging failed for object "+obj+" and throwable "+throwable);
+                    AssertionHelper.assertError("Logging failed for object " + obj + " and throwable " + throwable);
                 }
             }
         }

FFmpegAndroid/src/androidTest/java/com/github/hiteshsondhi88/libffmpeg/UtilTest.java

@@ -0,0 +1,110 @@
+package com.github.hiteshsondhi88.libffmpeg;
+
+import android.os.AsyncTask;
+
+import com.github.hiteshsondhi88.libffmpeg.utils.AssertionHelper;
+import com.github.hiteshsondhi88.libffmpeg.utils.StubInputStream;
+import com.github.hiteshsondhi88.libffmpeg.utils.StubOutputStream;
+
+import java.io.ByteArrayInputStream;
+import java.io.InputStream;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+public class UtilTest extends CommonTestCase {
+
+    public void testIsDebug() throws Exception {
+        // do nothing for now
+    }
+
+    public void testCloseInputStream() throws Exception {
+        StubInputStream stubInputStream = new StubInputStream();
+        // initially input stream shouldn't be closed
+        assertEquals(false, stubInputStream.isClosed());
+
+        // closing input stream
+        Util.close(stubInputStream);
+
+        // Input stream should be closed now
+        assertEquals(true, stubInputStream.isClosed());
+    }
+
+    public void testCloseOutputStream() throws Exception {
+        StubOutputStream stubOutputStream = new StubOutputStream();
+        // initially output stream shouldn't be closed
+        assertEquals(false, stubOutputStream.isClosed());
+
+        // closing output stream
+        Util.close(stubOutputStream);
+
+        // Output stream should be closed now
+        assertEquals(true, stubOutputStream.isClosed());
+    }
+
+    public void testConvertInputStreamToString() throws Exception {
+        String exampleString1 = "Example to provide source to InputStream";
+        String exampleString2 = "";
+        String exampleString3 = 1+"";
+        InputStream stream1 = new ByteArrayInputStream(exampleString1.getBytes());
+        InputStream stream2 = new ByteArrayInputStream(exampleString2.getBytes());
+        InputStream stream3 = new ByteArrayInputStream(exampleString3.getBytes());
+        String output1 = Util.convertInputStreamToString(stream1);
+        String output2 = Util.convertInputStreamToString(stream2);
+        String output3 = Util.convertInputStreamToString(stream3);
+
+        assertEquals(output1, exampleString1);
+        assertEquals(output2, exampleString2);
+        assertEquals(output3, exampleString3);
+    }
+
+    public void testDestroyProcessAndIsProcessCompleted() throws Exception {
+        final Process process = Runtime.getRuntime().exec("logcat");
+        assertEquals(false, Util.isProcessCompleted(process));
+
+        Util.destroyProcess(process);
+
+        ExecutorService executor = Executors.newSingleThreadExecutor();
+
+        Future<?> future = executor.submit(new Runnable() {
+            @Override
+            public void run() {
+                String errorStream = Util.convertInputStreamToString(process.getErrorStream());
+                String inputStream = Util.convertInputStreamToString(process.getInputStream());
+
+                assertEquals(null, errorStream);
+                assertEquals(null, inputStream);
+            }
+        });
+
+        try {
+            future.get(1, TimeUnit.SECONDS);
+        } catch (TimeoutException e) {
+            AssertionHelper.assertError("could not destroy process");
+        }
+
+        executor.shutdownNow();
+    }
+
+    public void testKillAsync() throws Exception {
+        AsyncTask<Void, Void, Void> asyncTask = new AsyncTask<Void, Void, Void>() {
+            @Override
+            protected Void doInBackground(Void... params) {
+                try {
+                    Log.d("AsyncTask started and putting to sleep");
+                    Thread.sleep(5000);
+                    Log.d("could not kill AsyncTask");
+                    AssertionHelper.assertError("could not kill AsyncTask");
+                } catch (InterruptedException e) {
+                    Log.d("AsyncTask has been terminated");
+                    AssertionHelper.assertError("AsyncTask has been terminated");
+                }
+                return null;
+            }
+        };
+        asyncTask.execute();
+        assertEquals(true, Util.killAsync(asyncTask));
+    }
+}

…hsondhi88/libffmpeg/AssertionHelper.java …i88/libffmpeg/utils/AssertionHelper.javaFFmpegAndroid/src/androidTest/java/com/github/hiteshsondhi88/libffmpeg/AssertionHelper.java renamed to FFmpegAndroid/src/androidTest/java/com/github/hiteshsondhi88/libffmpeg/utils/AssertionHelper.java FFmpegAndroid/src/androidTest/java/com/github/hiteshsondhi88/libffmpeg/AssertionHelper.java renamed to FFmpegAndroid/src/androidTest/java/com/github/hiteshsondhi88/libffmpeg/utils/AssertionHelper.java

@@ -1,7 +1,8 @@
-package com.github.hiteshsondhi88.libffmpeg;
+package com.github.hiteshsondhi88.libffmpeg.utils;
 
 import static junit.framework.Assert.assertTrue;
 
+@SuppressWarnings("unused")
 public class AssertionHelper {
 
     public static void assertError(String message) {

FFmpegAndroid/src/androidTest/java/com/github/hiteshsondhi88/libffmpeg/utils/StubInputStream.java

@@ -0,0 +1,25 @@
+package com.github.hiteshsondhi88.libffmpeg.utils;
+
+import java.io.IOException;
+import java.io.InputStream;
+
+public class StubInputStream extends InputStream {
+
+    private boolean closed = false;
+
+    @Override
+    public int read() throws IOException {
+        // Do nothing for now, just need to test if input stream is closed
+        return 0;
+    }
+
+    @Override
+    public void close() throws IOException {
+        super.close();
+        closed = true;
+    }
+
+    public boolean isClosed() {
+        return closed;
+    }
+}

FFmpegAndroid/src/androidTest/java/com/github/hiteshsondhi88/libffmpeg/utils/StubOutputStream.java

@@ -0,0 +1,24 @@
+package com.github.hiteshsondhi88.libffmpeg.utils;
+
+import java.io.IOException;
+import java.io.OutputStream;
+
+public class StubOutputStream extends OutputStream {
+
+    private boolean closed = false;
+
+    @Override
+    public void write(int oneByte) throws IOException {
+        // Do nothing for now, just need to test if output stream is closed
+    }
+
+    @Override
+    public void close() throws IOException {
+        super.close();
+        closed = true;
+    }
+
+    public boolean isClosed() {
+        return closed;
+    }
+}

FFmpegAndroid/src/androidTest/java/com/github/hiteshsondhi88/libffmpeg/utils/StubProcess.java

@@ -0,0 +1,15 @@
+package com.github.hiteshsondhi88.libffmpeg.utils;
+
+public abstract class StubProcess extends Process {
+
+    private boolean isDestroyed = false;
+
+    @Override
+    public void destroy() {
+        isDestroyed = true;
+    }
+
+    public boolean isDestroyed() {
+        return isDestroyed;
+    }
+}