Add more transformation regression tests.

Author: sjudd

instrumentation/build.gradle

@@ -10,7 +10,9 @@ dependencies {
     // loading classes functions. It's not clear why androidTestCompile isn't sufficient, but for
     // whatever reason, compile is the only dependency that seems to work.
     compile "com.android.support:appcompat-v7:${ANDROID_SUPPORT_VERSION}"
-    androidTestCompile project(":annotation:compiler")
+    annotationProcessor project(":annotation:compiler")
+    compile project(":library")
+
     androidTestCompile project(':library')
     androidTestCompile "org.mockito:mockito-android:${MOCKITO_ANDROID_VERSION}"
     androidTestCompile "com.android.support:support-fragment:${ANDROID_SUPPORT_VERSION}"

instrumentation/src/androidTest/java/com/bumptech/glide/CenterCropRegressionTest.java

@@ -0,0 +1,96 @@
+package com.bumptech.glide;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.support.test.InstrumentationRegistry;
+import android.support.test.runner.AndroidJUnit4;
+import com.bumptech.glide.test.BitmapRegressionTester;
+import com.bumptech.glide.test.CanonicalBitmap;
+import com.bumptech.glide.test.GlideApp;
+import com.bumptech.glide.test.RegressionTest;
+import com.bumptech.glide.test.SplitByCpu;
+import com.bumptech.glide.test.SplitBySdk;
+import com.bumptech.glide.test.TearDownGlide;
+import java.util.concurrent.ExecutionException;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.TestName;
+import org.junit.runner.RunWith;
+
+@RunWith(AndroidJUnit4.class)
+@RegressionTest
+@SplitByCpu
+@SplitBySdk({24, 21, 16})
+public class CenterCropRegressionTest {
+  @Rule public TestName testName = new TestName();
+  @Rule public TearDownGlide tearDownGlide = new TearDownGlide();
+  private BitmapRegressionTester bitmapRegressionTester;
+  private Context context;
+  private CanonicalBitmap canonical;
+
+  @Before
+  public void setUp() {
+    context = InstrumentationRegistry.getTargetContext();
+    bitmapRegressionTester = new BitmapRegressionTester(getClass(), testName);
+    canonical = new CanonicalBitmap();
+  }
+
+  @Test
+  public void centerCrop_withSquareSmallerThanImage_returnsSquareImage()
+      throws ExecutionException, InterruptedException {
+    Bitmap result =
+        bitmapRegressionTester.test(
+            GlideApp.with(context)
+                .asBitmap()
+                .load(canonical.getBitmap())
+                .centerCrop()
+                .override(50));
+    assertThat(result.getWidth()).isEqualTo(50);
+    assertThat(result.getHeight()).isEqualTo(50);
+  }
+
+  @Test
+  public void centerCrop_withRectangleSmallerThanImage_returnsRectangularImage()
+      throws ExecutionException, InterruptedException {
+     Bitmap result =
+        bitmapRegressionTester.test(
+            GlideApp.with(context)
+                .asBitmap()
+                .load(canonical.getBitmap())
+                .centerCrop()
+                .override(60, 70));
+    assertThat(result.getWidth()).isEqualTo(60);
+    assertThat(result.getHeight()).isEqualTo(70);
+  }
+
+  @Test
+  public void centerCrop_withSquareLargerThanImage_returnsUpscaledRectangularImage()
+      throws ExecutionException, InterruptedException {
+    Bitmap result =
+          bitmapRegressionTester.test(
+            GlideApp.with(context)
+                .asBitmap()
+                .load(canonical.getBitmap())
+                .centerCrop()
+                .override(canonical.getWidth() * 2));
+    assertThat(result.getWidth()).isEqualTo(canonical.getWidth() * 2);
+    assertThat(result.getHeight()).isEqualTo(canonical.getWidth() * 2);
+  }
+
+  @Test
+  public void centerCrop_withRectangleLargerThanImage_returnsUpscaledRectangularImage()
+      throws ExecutionException, InterruptedException {
+    Bitmap result =
+        bitmapRegressionTester.test(
+            GlideApp.with(context)
+                .asBitmap()
+                .load(canonical.getBitmap())
+                .centerCrop()
+                .override(canonical.getWidth() * 2, canonical.getHeight() * 2));
+    assertThat(result.getWidth()).isEqualTo(canonical.getWidth() * 2);
+    assertThat(result.getHeight()).isEqualTo(canonical.getHeight() * 2);
+  }
+}

instrumentation/src/androidTest/java/com/bumptech/glide/CenterInsideRegressionTest.java

@@ -0,0 +1,105 @@
+package com.bumptech.glide;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.support.test.InstrumentationRegistry;
+import android.support.test.runner.AndroidJUnit4;
+import com.bumptech.glide.test.BitmapRegressionTester;
+import com.bumptech.glide.test.CanonicalBitmap;
+import com.bumptech.glide.test.GlideApp;
+import com.bumptech.glide.test.RegressionTest;
+import com.bumptech.glide.test.SplitByCpu;
+import com.bumptech.glide.test.SplitBySdk;
+import com.bumptech.glide.test.TearDownGlide;
+import java.util.concurrent.ExecutionException;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.junit.rules.TestName;
+import org.junit.runner.RunWith;
+
+@RunWith(AndroidJUnit4.class)
+@SplitByCpu
+@SplitBySdk({24, 21, 16})
+@RegressionTest
+public class CenterInsideRegressionTest {
+  @Rule public TestName testName = new TestName();
+  @Rule public ExpectedException expectedException = ExpectedException.none();
+  @Rule public TearDownGlide tearDownGlide = new TearDownGlide();
+  private BitmapRegressionTester bitmapRegressionTester;
+  private Context context;
+  private CanonicalBitmap canonical;
+
+  @Before
+  public void setUp() {
+    context = InstrumentationRegistry.getTargetContext();
+    bitmapRegressionTester = new BitmapRegressionTester(getClass(), testName);
+    canonical = new CanonicalBitmap();
+  }
+
+  @Test
+  public void centerInside_withSquareSmallerThanImage_returnsImageFitWithinSquare()
+      throws ExecutionException, InterruptedException {
+
+    Bitmap result =
+        bitmapRegressionTester.test(
+            GlideApp.with(context)
+                .asBitmap()
+                .load(canonical.getBitmap())
+                .centerInside()
+                .override(50));
+
+    assertThat(result.getWidth()).isEqualTo(50);
+    assertThat(result.getHeight()).isEqualTo(37);
+  }
+
+  @Test
+  public void centerInside_withSquareLargerThanImage_returnsOriginalImage()
+      throws ExecutionException, InterruptedException {
+    float multiplier = 1.1f;
+    int multipliedWidth = (int) (canonical.getWidth() * multiplier);
+    Bitmap result =
+        bitmapRegressionTester.test(
+            GlideApp.with(context)
+              .asBitmap()
+              .load(canonical.getBitmap())
+              .centerInside()
+              .override(multipliedWidth));
+
+    assertThat(result.getWidth()).isEqualTo(canonical.getWidth());
+    assertThat(result.getHeight()).isEqualTo(canonical.getHeight());
+  }
+
+  @Test
+  public void centerInside_withNarrowRectangle_fitsWithinMaintainingAspectRatio()
+      throws ExecutionException, InterruptedException {
+    Bitmap result =
+        bitmapRegressionTester.test(
+            GlideApp.with(context)
+              .asBitmap()
+              .load(canonical.getBitmap())
+              .centerInside()
+              .override(canonical.getWidth() / 10, canonical.getHeight()));
+
+    assertThat(result.getWidth()).isEqualTo(canonical.getWidth() / 10);
+    assertThat(result.getHeight()).isEqualTo(canonical.getHeight() / 10);
+  }
+
+  @Test
+  public void centerInside_withShortRectangle_fitsWithinMaintainingAspectRatio()
+      throws ExecutionException, InterruptedException {
+     Bitmap result =
+        bitmapRegressionTester.test(
+            GlideApp.with(context)
+              .asBitmap()
+              .load(canonical.getBitmap())
+              .centerInside()
+              .override(canonical.getWidth(), canonical.getHeight() / 2));
+
+    assertThat(result.getWidth()).isEqualTo(canonical.getWidth() / 2);
+    assertThat(result.getHeight()).isEqualTo(canonical.getHeight() / 2);
+  }
+}

instrumentation/src/androidTest/java/com/bumptech/glide/CircleCropRegressionTest.java

@@ -0,0 +1,105 @@
+package com.bumptech.glide;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import android.content.Context;
+import android.graphics.Bitmap;
+import android.support.test.InstrumentationRegistry;
+import android.support.test.runner.AndroidJUnit4;
+import com.bumptech.glide.test.BitmapRegressionTester;
+import com.bumptech.glide.test.CanonicalBitmap;
+import com.bumptech.glide.test.GlideApp;
+import com.bumptech.glide.test.RegressionTest;
+import com.bumptech.glide.test.SplitByCpu;
+import com.bumptech.glide.test.SplitBySdk;
+import com.bumptech.glide.test.TearDownGlide;
+import java.util.concurrent.ExecutionException;
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.rules.ExpectedException;
+import org.junit.rules.TestName;
+import org.junit.runner.RunWith;
+
+@RunWith(AndroidJUnit4.class)
+@SplitByCpu
+@SplitBySdk({26, 24, 23, 21, 18, 16})
+@RegressionTest
+public class CircleCropRegressionTest {
+  @Rule public TestName testName = new TestName();
+  @Rule public ExpectedException expectedException = ExpectedException.none();
+  @Rule public TearDownGlide tearDownGlide = new TearDownGlide();
+  private BitmapRegressionTester bitmapRegressionTester;
+  private Context context;
+  private CanonicalBitmap canonical;
+
+  @Before
+  public void setUp() {
+    context = InstrumentationRegistry.getTargetContext();
+    bitmapRegressionTester = new BitmapRegressionTester(getClass(), testName);
+    canonical = new CanonicalBitmap();
+  }
+
+  @Test
+  public void circleCrop_withSquareSmallerThanImage_returnsSquaredImage()
+      throws ExecutionException, InterruptedException {
+    Bitmap result =
+        bitmapRegressionTester.test(
+            GlideApp.with(context)
+                .asBitmap()
+                .load(canonical.getBitmap())
+                .circleCrop()
+                .override(50));
+
+    assertThat(result.getWidth()).isEqualTo(50);
+    assertThat(result.getHeight()).isEqualTo(50);
+  }
+
+  @Test
+  public void circleCrop_withSquareLargerThanImage_returnsUpscaledFitImage()
+      throws ExecutionException, InterruptedException {
+    float multiplier = 1.1f;
+    int multipliedWidth = (int) (canonical.getWidth() * multiplier);
+    int multipliedHeight = (int) (canonical.getHeight() * multiplier);
+    Bitmap result =
+        bitmapRegressionTester.test(
+            GlideApp.with(context)
+              .asBitmap()
+              .load(canonical.getBitmap())
+              .circleCrop()
+              .override(multipliedWidth));
+
+    assertThat(result.getWidth()).isEqualTo(multipliedWidth);
+    assertThat(result.getHeight()).isEqualTo(multipliedWidth);
+  }
+
+  @Test
+  public void circleCrop_withNarrowRectangle_cropsWithin()
+      throws ExecutionException, InterruptedException {
+    Bitmap result =
+        bitmapRegressionTester.test(
+            GlideApp.with(context)
+              .asBitmap()
+              .load(canonical.getBitmap())
+              .circleCrop()
+              .override(canonical.getWidth() / 10, canonical.getHeight()));
+
+    assertThat(result.getWidth()).isEqualTo(canonical.getWidth() / 10);
+    assertThat(result.getHeight()).isEqualTo(canonical.getWidth() / 10);
+  }
+
+  @Test
+  public void circleCrop_withShortRectangle_fitsWithinMaintainingAspectRatio()
+      throws ExecutionException, InterruptedException {
+     Bitmap result =
+        bitmapRegressionTester.test(
+            GlideApp.with(context)
+              .asBitmap()
+              .load(canonical.getBitmap())
+              .circleCrop()
+              .override(canonical.getWidth(), canonical.getHeight() / 2));
+
+    assertThat(result.getWidth()).isEqualTo(canonical.getHeight() / 2);
+    assertThat(result.getHeight()).isEqualTo(canonical.getHeight() / 2);
+  }
+}

instrumentation/src/androidTest/java/com/bumptech/glide/FitCenterRegressionTest.java

@@ -12,6 +12,7 @@
 import com.bumptech.glide.test.RegressionTest;
 import com.bumptech.glide.test.SplitByCpu;
 import com.bumptech.glide.test.SplitBySdk;
+import com.bumptech.glide.test.TearDownGlide;
 import java.util.concurrent.ExecutionException;
 import org.junit.Before;
 import org.junit.Rule;
@@ -27,6 +28,7 @@
 public class FitCenterRegressionTest {
   @Rule public TestName testName = new TestName();
   @Rule public ExpectedException expectedException = ExpectedException.none();
+  @Rule public TearDownGlide tearDownGlide = new TearDownGlide();
   private BitmapRegressionTester bitmapRegressionTester;
   private Context context;
   private CanonicalBitmap canonical;
@@ -39,7 +41,7 @@ public void setUp() {
   }
 
   @Test
-  public void fitCenter_withSquareSmallerThanImage_returnsSquareImage()
+  public void fitCenter_withSquareSmallerThanImage_returnsImageFitWithinSquare()
       throws ExecutionException, InterruptedException {
 
     Bitmap result =
@@ -105,10 +107,10 @@ public void fitCenter_withShortRectangle_fitsWithinMaintainingAspectRatio()
   @Test
   public void fitCenter_withHugeRectangle_throwsOOM()
       throws ExecutionException, InterruptedException {
-    expectedException.expect(ExecutionException.class);
     float multiplier = Integer.MAX_VALUE / (canonical.getWidth() * canonical.getHeight() * 2);
     int overrideWidth = (int) multiplier * canonical.getWidth();
     int overrideHeight = (int) multiplier * canonical.getHeight();
+    expectedException.expect(ExecutionException.class);
     GlideApp
         .with(context)
         .asBitmap()

instrumentation/src/androidTest/java/com/bumptech/glide/test/InstrumentationAppGlideModule.java instrumentation/src/main/java/com/bumptech/glide/test/InstrumentationAppGlideModule.java

@@ -161,6 +161,7 @@ do
     done
     adb -s emulator-5554 emu kill
     sleep 1
+    kill -9 $pid
     pkill emulator64-crash-service
     pkill emulator-crash-service
     echo "Finished API ${api}" 1>&3 2>&4