Java Config类代码示例

import org.robolectric.annotation.Config; //导入依赖的package包/类
@Test
public void testRecyclesTransformedResourceAfterWritingIfTransformedResourceIsDifferent() {
  when(decoder.getFrameCount()).thenReturn(1);
  Bitmap expected = Bitmap.createBitmap(100, 200, Bitmap.Config.RGB_565);
  when(transformedResource.get()).thenReturn(expected);
  when(frameTransformation.transform(anyContext(), eq(frameResource), anyInt(), anyInt()))
      .thenReturn(transformedResource);

  when(gifEncoder.start(any(OutputStream.class))).thenReturn(true);

  encoder.encode(resource, file, options);

  InOrder order = inOrder(transformedResource, gifEncoder);
  order.verify(gifEncoder).addFrame(eq(expected));
  order.verify(transformedResource).recycle();
}
 

import org.robolectric.annotation.Config; //导入依赖的package包/类
/**
 * Detects which build system is in use and returns the appropriate ManifestFactory implementation.
 *
 * Custom TestRunner subclasses may wish to override this method to provide alternate configuration.
 *
 * @param config Specification of the SDK version, manifest file, package name, etc.
 */
private ManifestFactory getManifestFactory(Config config) {
    Properties buildSystemApiProperties = getBuildSystemApiProperties();
    if (buildSystemApiProperties != null) {
        return new DefaultManifestFactory(buildSystemApiProperties);
    }

    Class<?> buildConstants = config.constants();
    //noinspection ConstantConditions
    if (BuckManifestFactory.isBuck()) {
        return new BuckManifestFactory();
    } else if (buildConstants != Void.class) {
        return new GradleManifestFactory();
    } else {
        return new MavenManifestFactory();
    }
}
 

import org.robolectric.annotation.Config; //导入依赖的package包/类
@Test
public void startFromFirstFrame_withPendingFrame_clearsPendingFrame() {
  loader = createGifFrameLoader(/*handler=*/ null);
  DelayTarget loaded = mock(DelayTarget.class);
  when(loaded.getResource()).thenReturn(Bitmap.createBitmap(100, 100, Bitmap.Config.ARGB_8888));
  loader.onFrameReady(loaded);
  loader.unsubscribe(callback);

  DelayTarget nextFrame = mock(DelayTarget.class);
  Bitmap expected = Bitmap.createBitmap(200, 200, Bitmap.Config.ARGB_8888);
  when(nextFrame.getResource())
      .thenReturn(expected);
  loader.onFrameReady(nextFrame);

  loader.setNextStartFromFirstFrame();
  verify(requestManager).clear(nextFrame);

  loader.subscribe(callback);
  verify(callback, times(1)).onFrameReady();
}
 

import org.robolectric.annotation.Config; //导入依赖的package包/类
@Test
public void
testCenterCropSetsOutBitmapToNotHaveAlphaIfInBitmapDoesNotHaveAlphaAndOutBitmapIsReused() {
  Bitmap toTransform = Bitmap.createBitmap(100, 100, Bitmap.Config.ARGB_8888);

  Bitmap toReuse = Bitmap.createBitmap(50, 50, Bitmap.Config.ARGB_8888);
  reset(bitmapPool);
  when(bitmapPool.get(eq(50), eq(50), eq(Bitmap.Config.ARGB_8888))).thenReturn(toReuse);

  toReuse.setHasAlpha(true);
  toTransform.setHasAlpha(false);

  Bitmap result = TransformationUtils.centerCrop(bitmapPool, toTransform, toReuse.getWidth(),
      toReuse.getHeight());

  assertEquals(toReuse, result);
  assertFalse(result.hasAlpha());
}
 

import org.robolectric.annotation.Config; //导入依赖的package包/类
@Test
public void
testFitCenterSetsOutBitmapToNotHaveAlphaIfInBitmapDoesNotHaveAlphaAndOutBitmapIsReused() {
  Bitmap toTransform = Bitmap.createBitmap(100, 100, Bitmap.Config.ARGB_8888);

  Bitmap toReuse = Bitmap.createBitmap(50, 50, Bitmap.Config.ARGB_8888);
  reset(bitmapPool);
  when(bitmapPool.get(eq(toReuse.getWidth()), eq(toReuse.getHeight()), eq(toReuse.getConfig())))
      .thenReturn(toReuse);

  toReuse.setHasAlpha(true);
  toTransform.setHasAlpha(false);

  Bitmap result = TransformationUtils.fitCenter(bitmapPool, toTransform, toReuse.getWidth(),
      toReuse.getHeight());

  assertEquals(toReuse, result);
  assertFalse(result.hasAlpha());
}
 

import org.robolectric.annotation.Config; //导入依赖的package包/类
@Test
public void testOnFrameReadyClearsPreviousFrame() {
  // Force the loader to create a real Handler.
  loader = createGifFrameLoader(null);

  DelayTarget previous = mock(DelayTarget.class);
  Request previousRequest = mock(Request.class);
  when(previous.getRequest()).thenReturn(previousRequest);
  when(previous.getResource()).thenReturn(Bitmap.createBitmap(100, 100, Bitmap.Config.ARGB_8888));

  DelayTarget current = mock(DelayTarget.class);
  when(current.getResource()).thenReturn(Bitmap.createBitmap(100, 100, Bitmap.Config.RGB_565));
  loader.onFrameReady(previous);
  loader.onFrameReady(current);

  verify(requestManager).clear(eq(previous));
}
 

import org.robolectric.annotation.Config; //导入依赖的package包/类
@Test
public void testReturnsBitmapWithExactlyGivenDimensionsIfBitmapIsLargerThanTarget() {
  int expectedWidth = 75;
  int expectedHeight = 74;

  for (int[] dimens : new int[][] { new int[] { 800, 200 }, new int[] { 450, 100 },
      new int[] { 78, 78 } }) {
    Bitmap toTransform = Bitmap.createBitmap(dimens[0], dimens[1], Bitmap.Config.ARGB_4444);
    when(resource.get()).thenReturn(toTransform);

    Resource<Bitmap> result =
        centerCrop.transform(context, resource, expectedWidth, expectedHeight);
    Bitmap transformed = result.get();
    assertEquals(expectedWidth, transformed.getWidth());
    assertEquals(expectedHeight, transformed.getHeight());
  }
}
 

import org.robolectric.annotation.Config; //导入依赖的package包/类
@Test
public void testCenterCropSetsOutBitmapToHaveAlphaIfInBitmapHasAlphaAndOutBitmapIsReused() {
  Bitmap toTransform = Bitmap.createBitmap(100, 100, Bitmap.Config.ARGB_8888);

  Bitmap toReuse = Bitmap.createBitmap(50, 50, Bitmap.Config.ARGB_8888);
  reset(bitmapPool);
  when(bitmapPool.get(eq(50), eq(50), eq(Bitmap.Config.ARGB_8888)))
      .thenReturn(toReuse);

  toReuse.setHasAlpha(false);
  toTransform.setHasAlpha(true);

  Bitmap result = TransformationUtils.centerCrop(bitmapPool, toTransform, toReuse.getWidth(),
      toReuse.getHeight());

  assertEquals(toReuse, result);
  assertTrue(result.hasAlpha());
}
 

import org.robolectric.annotation.Config; //导入依赖的package包/类
@Test
public void onFrameReady_whenNotRunning_clearsOldFrameOnStart() {
  loader = createGifFrameLoader(/*handler=*/ null);
  DelayTarget loaded = mock(DelayTarget.class);
  when(loaded.getResource()).thenReturn(Bitmap.createBitmap(100, 100, Bitmap.Config.ARGB_8888));
  loader.onFrameReady(loaded);
  loader.unsubscribe(callback);

  DelayTarget nextFrame = mock(DelayTarget.class);
  when(nextFrame.getResource())
      .thenReturn(Bitmap.createBitmap(100, 100, Bitmap.Config.ARGB_8888));
  loader.onFrameReady(nextFrame);

  loader.subscribe(callback);
  verify(requestManager).clear(loaded);
}
 

import org.robolectric.annotation.Config; //导入依赖的package包/类
@Test
public void testReturnsNewResourceWhenBitmapTransformed() {
  final Bitmap transformed = Bitmap.createBitmap(100, 100, Bitmap.Config.ARGB_4444);
  BitmapTransformation transformation = new BitmapTransformation() {
    @Override
    public void updateDiskCacheKey(MessageDigest messageDigest) { }

    @Override
    protected Bitmap transform(@NonNull BitmapPool pool, @NonNull Bitmap bitmap, int outWidth,
        int outHeight) {
      return transformed;
    }
  };

  Resource<Bitmap> resource = mockResource(1, 2);
  assertNotSame(resource, transformation.transform(context, resource, 100, 100));
}
 

import org.robolectric.annotation.Config; //导入依赖的package包/类
@Test
public void testReturnsNewResourceIfTransformationDoesTransform() {
  int outWidth = 999;
  int outHeight = 555;

  Bitmap transformedBitmap = Bitmap.createBitmap(outWidth, outHeight, Bitmap.Config.RGB_565);
  Resource<Bitmap> transformedBitmapResource = Util.mockResource();
  when(transformedBitmapResource.get()).thenReturn(transformedBitmap);
  when(wrapped.transform(anyContext(), Util.<Bitmap>anyResource(), eq(outWidth), eq(outHeight)))
      .thenReturn(transformedBitmapResource);

  Resource<BitmapDrawable> transformed =
      transformation.transform(context, drawableResourceToTransform, outWidth, outHeight);

  assertThat(transformed.get().getBitmap()).isEqualTo(transformedBitmap);
}
 

import org.robolectric.annotation.Config; //导入依赖的package包/类
@Override
protected AndroidManifest getAppManifest(Config config) {

    final String manifestPath = PathResolver.resolveAndroidManifestPath();
    final String resourcesPath = PathResolver.resolveResPath();
    final String assetsPath = PathResolver.resolveAssetsPath();

    AndroidManifest manifest = new AndroidManifest(
            Fs.fileFromPath(manifestPath),
            Fs.fileFromPath(resourcesPath),
            Fs.fileFromPath(assetsPath)) {
        @Override
        public int getTargetSdkVersion() {
            return TARGET_SDK_VERSION;
        }

        @Override
        public int getMinSdkVersion() {
            return MIN_SDK_VERSION;
        }
    };

    return manifest;
}
 

import org.robolectric.annotation.Config; //导入依赖的package包/类
@Test
public void testAddsBitmapsToMemoryCacheIfMemoryCacheHasEnoughSpaceRemaining() {
  Bitmap bitmap = Bitmap.createBitmap(100, 100, Bitmap.Config.ARGB_8888);
  when(cache.getMaxSize()).thenReturn(Util.getBitmapByteSize(bitmap));

  PreFillType size =
      new PreFillType.Builder(bitmap.getWidth(), bitmap.getHeight()).setConfig(bitmap.getConfig())
          .build();
  Map<PreFillType, Integer> allocationOrder = new HashMap<>();
  allocationOrder.put(size, 1);

  getHandler(allocationOrder).run();

  verify(cache).put(any(Key.class), anyResource());
  verify(pool, never()).put(any(Bitmap.class));
  // TODO(b/20335397): This code was relying on Bitmap equality which Robolectric removed
  // assertThat(addedBitmaps).containsExactly(bitmap);
}
 

import org.robolectric.annotation.Config; //导入依赖的package包/类
@Test
public void testWritesTransformedBitmaps() {
  final Bitmap frame = Bitmap.createBitmap(100, 100, Bitmap.Config.ARGB_8888);
  when(decoder.getFrameCount()).thenReturn(1);
  when(decoder.getNextFrame()).thenReturn(frame);

  when(gifEncoder.start(any(OutputStream.class))).thenReturn(true);

  int expectedWidth = 123;
  int expectedHeight = 456;
  when(gifDrawable.getIntrinsicWidth()).thenReturn(expectedWidth);
  when(gifDrawable.getIntrinsicHeight()).thenReturn(expectedHeight);

  Bitmap transformedFrame = Bitmap.createBitmap(200, 200, Bitmap.Config.RGB_565);
  when(transformedResource.get()).thenReturn(transformedFrame);
  when(frameTransformation.transform(
      anyContext(), eq(frameResource), eq(expectedWidth), eq(expectedHeight)))
      .thenReturn(transformedResource);
  when(gifDrawable.getFrameTransformation()).thenReturn(frameTransformation);

  encoder.encode(resource, file, options);

  verify(gifEncoder).addFrame(eq(transformedFrame));
}
 

import org.robolectric.annotation.Config; //导入依赖的package包/类
@Test
public void testAddsBitmapsToPoolIfMemoryCacheIsNotFullButCannotFitBitmap() {
  Bitmap bitmap = Bitmap.createBitmap(100, 100, Bitmap.Config.ARGB_8888);
  when(cache.getMaxSize()).thenReturn(Util.getBitmapByteSize(bitmap) / 2);

  PreFillType size =
      new PreFillType.Builder(bitmap.getWidth(), bitmap.getHeight()).setConfig(bitmap.getConfig())
          .build();
  Map<PreFillType, Integer> allocationOrder = new HashMap<>();
  allocationOrder.put(size, 1);

  getHandler(allocationOrder).run();

  verify(cache, never()).put(any(Key.class), anyResource());
  // TODO(b/20335397): This code was relying on Bitmap equality which Robolectric removed
  //verify(pool).put(eq(bitmap));
  //assertThat(addedBitmaps).containsExactly(bitmap);
}