compat/src/androidTest/java/androidx/core/content/res/ResourcesCompatTest.java - platform/frameworks/support - Git at Google

 /*
  * Copyright (C) 2015 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package androidx.core.content.res;

 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
 import static org.junit.Assert.assertNotSame;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;

 import android.content.Context;
 import android.content.res.ColorStateList;
 import android.content.res.Resources;
 import android.graphics.Typeface;
 import android.graphics.drawable.Drawable;
 import android.os.Build;
 import android.support.test.InstrumentationRegistry;
 import android.support.test.filters.SmallTest;
 import android.support.v4.testutils.TestUtils;
 import android.util.DisplayMetrics;

 import androidx.annotation.NonNull;
 import androidx.core.provider.FontsContractCompat;
 import androidx.core.provider.MockFontProvider;
 import androidx.core.test.R;

 import org.junit.Before;
 import org.junit.Test;

 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;

 @SmallTest
 public class ResourcesCompatTest {
     private Context mContext;
     private Resources mResources;

     @Before
     public void setup() {
         mContext = InstrumentationRegistry.getContext();
         mResources = mContext.getResources();
         MockFontProvider.prepareFontFiles(mContext);
     }

     @Test
     public void testGetColor() throws Throwable {
         assertEquals("Unthemed color load",
                 ResourcesCompat.getColor(mResources, R.color.text_color, null),
                 0xFFFF8090);

         if (Build.VERSION.SDK_INT >= 23) {
             // The following tests are only expected to pass on v23+ devices. The result of
             // calling theme-aware getColor() in pre-v23 is undefined.
             final Resources.Theme yellowTheme = mResources.newTheme();
             yellowTheme.applyStyle(R.style.YellowTheme, true);
             assertEquals("Themed yellow color load", 0xFFF0B000,
                     ResourcesCompat.getColor(mResources, R.color.simple_themed_selector,
                             yellowTheme));

             final Resources.Theme lilacTheme = mResources.newTheme();
             lilacTheme.applyStyle(R.style.LilacTheme, true);
             assertEquals("Themed lilac color load", 0xFFF080F0,
                     ResourcesCompat.getColor(mResources, R.color.simple_themed_selector,
                             lilacTheme));
         }
     }

     @Test
     public void testGetColorStateList() throws Throwable {
         final ColorStateList unthemedColorStateList =
                 ResourcesCompat.getColorStateList(mResources, R.color.complex_unthemed_selector,
                         null);
         assertEquals("Unthemed color state list load: default", 0xFF70A0C0,
                 unthemedColorStateList.getDefaultColor());
         assertEquals("Unthemed color state list load: focused", 0xFF70B0F0,
                 unthemedColorStateList.getColorForState(
                         new int[]{android.R.attr.state_focused}, 0));
         assertEquals("Unthemed color state list load: pressed", 0xFF6080B0,
                 unthemedColorStateList.getColorForState(
                         new int[]{android.R.attr.state_pressed}, 0));

         if (Build.VERSION.SDK_INT >= 23) {
             // The following tests are only expected to pass on v23+ devices. The result of
             // calling theme-aware getColorStateList() in pre-v23 is undefined.
             final Resources.Theme yellowTheme = mResources.newTheme();
             yellowTheme.applyStyle(R.style.YellowTheme, true);
             final ColorStateList themedYellowColorStateList =
                     ResourcesCompat.getColorStateList(mResources, R.color.complex_themed_selector,
                             yellowTheme);
             assertEquals("Themed yellow color state list load: default", 0xFFF0B000,
                     themedYellowColorStateList.getDefaultColor());
             assertEquals("Themed yellow color state list load: focused", 0xFFF0A020,
                     themedYellowColorStateList.getColorForState(
                             new int[]{android.R.attr.state_focused}, 0));
             assertEquals("Themed yellow color state list load: pressed", 0xFFE0A040,
                     themedYellowColorStateList.getColorForState(
                             new int[]{android.R.attr.state_pressed}, 0));

             final Resources.Theme lilacTheme = mResources.newTheme();
             lilacTheme.applyStyle(R.style.LilacTheme, true);
             final ColorStateList themedLilacColorStateList =
                     ResourcesCompat.getColorStateList(mResources, R.color.complex_themed_selector,
                             lilacTheme);
             assertEquals("Themed lilac color state list load: default", 0xFFF080F0,
                     themedLilacColorStateList.getDefaultColor());
             assertEquals("Themed lilac color state list load: focused", 0xFFF070D0,
                     themedLilacColorStateList.getColorForState(
                             new int[]{android.R.attr.state_focused}, 0));
             assertEquals("Themed lilac color state list load: pressed", 0xFFE070A0,
                     themedLilacColorStateList.getColorForState(
                             new int[]{android.R.attr.state_pressed}, 0));
         }
     }

     @Test
     public void testGetDrawable() throws Throwable {
         final Drawable unthemedDrawable =
                 ResourcesCompat.getDrawable(mResources, R.drawable.test_drawable_red, null);
         TestUtils.assertAllPixelsOfColor("Unthemed drawable load",
                 unthemedDrawable, mResources.getColor(R.color.test_red));

         if (Build.VERSION.SDK_INT >= 23) {
             // The following tests are only expected to pass on v23+ devices. The result of
             // calling theme-aware getDrawable() in pre-v23 is undefined.
             final Resources.Theme yellowTheme = mResources.newTheme();
             yellowTheme.applyStyle(R.style.YellowTheme, true);
             final Drawable themedYellowDrawable =
                     ResourcesCompat.getDrawable(mResources, R.drawable.themed_drawable,
                             yellowTheme);
             TestUtils.assertAllPixelsOfColor("Themed yellow drawable load",
                     themedYellowDrawable, 0xFFF0B000);

             final Resources.Theme lilacTheme = mResources.newTheme();
             lilacTheme.applyStyle(R.style.LilacTheme, true);
             final Drawable themedLilacDrawable =
                     ResourcesCompat.getDrawable(mResources, R.drawable.themed_drawable, lilacTheme);
             TestUtils.assertAllPixelsOfColor("Themed lilac drawable load",
                     themedLilacDrawable, 0xFFF080F0);
         }
     }

     @Test
     public void testGetDrawableForDensityUnthemed() throws Throwable {
         // Density-aware drawable loading for now only works on raw bitmap drawables.

         // Different variants of density_aware_drawable are set up in the following way:
         //    mdpi - 12x12 px which is 12x12 dip
         //    hdpi - 21x21 px which is 14x14 dip
         //   xhdpi - 32x32 px which is 16x16 dip
         //  xxhdpi - 54x54 px which is 18x18 dip
         // The tests below (on v15+ devices) are checking that an unthemed density-aware
         // loading of raw bitmap drawables returns a drawable with matching intrinsic
         // dimensions.

         final Drawable unthemedDrawableForMediumDensity =
                 ResourcesCompat.getDrawableForDensity(mResources, R.drawable.density_aware_drawable,
                         DisplayMetrics.DENSITY_MEDIUM, null);
         // For pre-v15 devices we should get a drawable that corresponds to the density of the
         // current device. For v15+ devices we should get a drawable that corresponds to the
         // density requested in the API call.
         final int expectedSizeForMediumDensity = (Build.VERSION.SDK_INT < 15) ?
                 mResources.getDimensionPixelSize(R.dimen.density_aware_size) : 12;
         assertEquals("Unthemed density-aware drawable load: medium width",
                 expectedSizeForMediumDensity, unthemedDrawableForMediumDensity.getIntrinsicWidth());
         assertEquals("Unthemed density-aware drawable load: medium height",
                 expectedSizeForMediumDensity,
                 unthemedDrawableForMediumDensity.getIntrinsicHeight());

         final Drawable unthemedDrawableForHighDensity =
                 ResourcesCompat.getDrawableForDensity(mResources, R.drawable.density_aware_drawable,
                         DisplayMetrics.DENSITY_HIGH, null);
         // For pre-v15 devices we should get a drawable that corresponds to the density of the
         // current device. For v15+ devices we should get a drawable that corresponds to the
         // density requested in the API call.
         final int expectedSizeForHighDensity = (Build.VERSION.SDK_INT < 15) ?
                 mResources.getDimensionPixelSize(R.dimen.density_aware_size) : 21;
         assertEquals("Unthemed density-aware drawable load: high width",
                 expectedSizeForHighDensity, unthemedDrawableForHighDensity.getIntrinsicWidth());
         assertEquals("Unthemed density-aware drawable load: high height",
                 expectedSizeForHighDensity, unthemedDrawableForHighDensity.getIntrinsicHeight());

         final Drawable unthemedDrawableForXHighDensity =
                 ResourcesCompat.getDrawableForDensity(mResources, R.drawable.density_aware_drawable,
                         DisplayMetrics.DENSITY_XHIGH, null);
         // For pre-v15 devices we should get a drawable that corresponds to the density of the
         // current device. For v15+ devices we should get a drawable that corresponds to the
         // density requested in the API call.
         final int expectedSizeForXHighDensity = (Build.VERSION.SDK_INT < 15) ?
                 mResources.getDimensionPixelSize(R.dimen.density_aware_size) : 32;
         assertEquals("Unthemed density-aware drawable load: xhigh width",
                 expectedSizeForXHighDensity, unthemedDrawableForXHighDensity.getIntrinsicWidth());
         assertEquals("Unthemed density-aware drawable load: xhigh height",
                 expectedSizeForXHighDensity, unthemedDrawableForXHighDensity.getIntrinsicHeight());

         final Drawable unthemedDrawableForXXHighDensity =
                 ResourcesCompat.getDrawableForDensity(mResources, R.drawable.density_aware_drawable,
                         DisplayMetrics.DENSITY_XXHIGH, null);
         // For pre-v15 devices we should get a drawable that corresponds to the density of the
         // current device. For v15+ devices we should get a drawable that corresponds to the
         // density requested in the API call.
         final int expectedSizeForXXHighDensity = (Build.VERSION.SDK_INT < 15) ?
                 mResources.getDimensionPixelSize(R.dimen.density_aware_size) : 54;
         assertEquals("Unthemed density-aware drawable load: xxhigh width",
                 expectedSizeForXXHighDensity, unthemedDrawableForXXHighDensity.getIntrinsicWidth());
         assertEquals("Unthemed density-aware drawable load: xxhigh height",
                 expectedSizeForXXHighDensity,
                 unthemedDrawableForXXHighDensity.getIntrinsicHeight());
     }

     @Test
     public void testGetDrawableForDensityThemed() throws Throwable {
         if (Build.VERSION.SDK_INT < 21) {
             // The following tests are only expected to pass on v21+ devices. The result of
             // calling theme-aware getDrawableForDensity() in pre-v21 is undefined.
             return;
         }

         // Density- and theme-aware drawable loading for now only works partially. This test
         // checks only for theming of a tinted bitmap XML drawable, but not correct scaling.

         // Set up the two test themes, yellow and lilac.
         final Resources.Theme yellowTheme = mResources.newTheme();
         yellowTheme.applyStyle(R.style.YellowTheme, true);

         final Resources.Theme lilacTheme = mResources.newTheme();
         lilacTheme.applyStyle(R.style.LilacTheme, true);

         Drawable themedYellowDrawableForMediumDensity =
                 ResourcesCompat.getDrawableForDensity(mResources, R.drawable.themed_bitmap,
                         DisplayMetrics.DENSITY_MEDIUM, yellowTheme);
         // We should get a drawable that corresponds to the theme requested in the API call.
         TestUtils.assertAllPixelsOfColor("Themed yellow density-aware drawable load : medium color",
                 themedYellowDrawableForMediumDensity, 0xFFF0B000);

         Drawable themedLilacDrawableForMediumDensity =
                 ResourcesCompat.getDrawableForDensity(mResources, R.drawable.themed_bitmap,
                         DisplayMetrics.DENSITY_MEDIUM, lilacTheme);
         // We should get a drawable that corresponds to the theme requested in the API call.
         TestUtils.assertAllPixelsOfColor("Themed lilac density-aware drawable load : medium color",
                 themedLilacDrawableForMediumDensity, 0xFFF080F0);

         Drawable themedYellowDrawableForHighDensity =
                 ResourcesCompat.getDrawableForDensity(mResources, R.drawable.themed_bitmap,
                         DisplayMetrics.DENSITY_HIGH, yellowTheme);
         // We should get a drawable that corresponds to the theme requested in the API call.
         TestUtils.assertAllPixelsOfColor("Themed yellow density-aware drawable load : high color",
                 themedYellowDrawableForHighDensity, 0xFFF0B000);

         Drawable themedLilacDrawableForHighDensity =
                 ResourcesCompat.getDrawableForDensity(mResources, R.drawable.themed_bitmap,
                         DisplayMetrics.DENSITY_HIGH, lilacTheme);
         // We should get a drawable that corresponds to the theme requested in the API call.
         TestUtils.assertAllPixelsOfColor("Themed lilac density-aware drawable load : high color",
                 themedLilacDrawableForHighDensity, 0xFFF080F0);

         Drawable themedYellowDrawableForXHighDensity =
                 ResourcesCompat.getDrawableForDensity(mResources, R.drawable.themed_bitmap,
                         DisplayMetrics.DENSITY_XHIGH, yellowTheme);
         // We should get a drawable that corresponds to the theme requested in the API call.
         TestUtils.assertAllPixelsOfColor("Themed yellow density-aware drawable load : xhigh color",
                 themedYellowDrawableForXHighDensity, 0xFFF0B000);

         Drawable themedLilacDrawableForXHighDensity =
                 ResourcesCompat.getDrawableForDensity(mResources, R.drawable.themed_bitmap,
                         DisplayMetrics.DENSITY_XHIGH, lilacTheme);
         // We should get a drawable that corresponds to the theme requested in the API call.
         TestUtils.assertAllPixelsOfColor("Themed lilac density-aware drawable load : xhigh color",
                 themedLilacDrawableForXHighDensity, 0xFFF080F0);

         Drawable themedYellowDrawableForXXHighDensity =
                 ResourcesCompat.getDrawableForDensity(mResources, R.drawable.themed_bitmap,
                         DisplayMetrics.DENSITY_XXHIGH, yellowTheme);
         // We should get a drawable that corresponds to the theme requested in the API call.
         TestUtils.assertAllPixelsOfColor("Themed yellow density-aware drawable load : xxhigh color",
                 themedYellowDrawableForXXHighDensity, 0xFFF0B000);

         Drawable themedLilacDrawableForXXHighDensity =
                 ResourcesCompat.getDrawableForDensity(mResources, R.drawable.themed_bitmap,
                         DisplayMetrics.DENSITY_XXHIGH, lilacTheme);
         // We should get a drawable that corresponds to the theme requested in the API call.
         TestUtils.assertAllPixelsOfColor("Themed lilac density-aware drawable load : xxhigh color",
                 themedLilacDrawableForXXHighDensity, 0xFFF080F0);
     }

     @Test(expected = Resources.NotFoundException.class)
     public void testGetFont_invalidResourceId() {
         ResourcesCompat.getFont(mContext, -1);
     }

     @Test
     public void testGetFont_fontFile_sync() {
         Typeface font = ResourcesCompat.getFont(mContext, R.font.samplefont);

         assertNotNull(font);
         assertNotSame(Typeface.DEFAULT, font);
     }

     private static final class FontCallback extends ResourcesCompat.FontCallback {
         private final CountDownLatch mLatch;
         Typeface mTypeface;

         FontCallback(CountDownLatch latch) {
             mLatch = latch;
         }

         @Override
         public void onFontRetrieved(@NonNull Typeface typeface) {
             mTypeface = typeface;
             mLatch.countDown();
         }

         @Override
         public void onFontRetrievalFailed(int reason) {
             mLatch.countDown();
         }
     }

     @Test
     public void testGetFont_fontFile_async() throws InterruptedException {
         final CountDownLatch latch = new CountDownLatch(1);
         final FontCallback callback = new FontCallback(latch);
         FontsContractCompat.resetCache();

         ResourcesCompat.getFont(mContext, R.font.samplefont, callback, null);

         assertTrue(latch.await(5L, TimeUnit.SECONDS));

         assertNotNull(callback.mTypeface);
         assertNotSame(Typeface.DEFAULT, callback.mTypeface);
     }

     @Test
     public void testGetFont_xmlFile_sync() {
         Typeface font = ResourcesCompat.getFont(mContext, R.font.samplexmlfont);

         assertNotNull(font);
         assertNotSame(Typeface.DEFAULT, font);
     }

     @Test
     public void testGetFont_xmlFile_async() throws InterruptedException {
         final CountDownLatch latch = new CountDownLatch(1);
         final FontCallback callback = new FontCallback(latch);

         ResourcesCompat.getFont(mContext, R.font.samplexmlfont, callback, null);

         assertTrue(latch.await(5L, TimeUnit.SECONDS));

         assertNotNull(callback.mTypeface);
         assertNotSame(Typeface.DEFAULT, callback.mTypeface);
     }

     @Test
     public void testGetFont_xmlProviderFile_sync() {
         Typeface font = ResourcesCompat.getFont(mContext, R.font.samplexmldownloadedfont);

         assertNotNull(font);
         assertNotSame(Typeface.DEFAULT, font);
     }

     @Test
     public void testGetFont_xmlProviderFile_async() throws InterruptedException {
         final CountDownLatch latch = new CountDownLatch(1);
         final FontCallback callback = new FontCallback(latch);

         // Font provider non-blocking requests post on the calling thread so can't run on
         // the test thread as it doesn't have a Looper.
         InstrumentationRegistry.getInstrumentation().runOnMainSync(new Runnable() {
             @Override
             public void run() {
                 ResourcesCompat.getFont(mContext, R.font.samplexmldownloadedfont, callback, null);
             }
         });

         assertTrue(latch.await(5L, TimeUnit.SECONDS));

         assertNotNull(callback.mTypeface);
         assertNotSame(Typeface.DEFAULT, callback.mTypeface);
     }

     @Test
     public void testGetFont_invalidXmlFile() {
         try {
             assertNull(
                     ResourcesCompat.getFont(mContext, R.font.invalid_xmlfamily));
         } catch (Resources.NotFoundException e) {
             // pass
         }

         try {
             assertNull(ResourcesCompat.getFont(mContext, R.font.invalid_xmlempty));
         } catch (Resources.NotFoundException e) {
             // pass
         }
     }

     @Test
     public void testGetFont_fontFileIsCached() {
         Typeface font = ResourcesCompat.getFont(mContext, R.font.samplefont);
         Typeface font2 = ResourcesCompat.getFont(mContext, R.font.samplefont);

         assertSame(font, font2);
     }

     @Test
     public void testGetFont_xmlFileIsCached() {
         Typeface font = ResourcesCompat.getFont(mContext, R.font.samplexmlfont);
         Typeface font2 = ResourcesCompat.getFont(mContext, R.font.samplexmlfont);

         assertSame(font, font2);
     }
 }
	/*
	* Copyright (C) 2015 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	package androidx.core.content.res;

	import static org.junit.Assert.assertEquals;
	import static org.junit.Assert.assertNotNull;
	import static org.junit.Assert.assertNotSame;
	import static org.junit.Assert.assertNull;
	import static org.junit.Assert.assertSame;
	import static org.junit.Assert.assertTrue;

	import android.content.Context;
	import android.content.res.ColorStateList;
	import android.content.res.Resources;
	import android.graphics.Typeface;
	import android.graphics.drawable.Drawable;
	import android.os.Build;
	import android.support.test.InstrumentationRegistry;
	import android.support.test.filters.SmallTest;
	import android.support.v4.testutils.TestUtils;
	import android.util.DisplayMetrics;

	import androidx.annotation.NonNull;
	import androidx.core.provider.FontsContractCompat;
	import androidx.core.provider.MockFontProvider;
	import androidx.core.test.R;

	import org.junit.Before;
	import org.junit.Test;

	import java.util.concurrent.CountDownLatch;
	import java.util.concurrent.TimeUnit;

	@SmallTest
	public class ResourcesCompatTest {
	private Context mContext;
	private Resources mResources;

	@Before
	public void setup() {
	mContext = InstrumentationRegistry.getContext();
	mResources = mContext.getResources();
	MockFontProvider.prepareFontFiles(mContext);
	}

	@Test
	public void testGetColor() throws Throwable {
	assertEquals("Unthemed color load",
	ResourcesCompat.getColor(mResources, R.color.text_color, null),
	0xFFFF8090);

	if (Build.VERSION.SDK_INT >= 23) {
	// The following tests are only expected to pass on v23+ devices. The result of
	// calling theme-aware getColor() in pre-v23 is undefined.
	final Resources.Theme yellowTheme = mResources.newTheme();
	yellowTheme.applyStyle(R.style.YellowTheme, true);
	assertEquals("Themed yellow color load", 0xFFF0B000,
	ResourcesCompat.getColor(mResources, R.color.simple_themed_selector,
	yellowTheme));

	final Resources.Theme lilacTheme = mResources.newTheme();
	lilacTheme.applyStyle(R.style.LilacTheme, true);
	assertEquals("Themed lilac color load", 0xFFF080F0,
	ResourcesCompat.getColor(mResources, R.color.simple_themed_selector,
	lilacTheme));
	}
	}

	@Test
	public void testGetColorStateList() throws Throwable {
	final ColorStateList unthemedColorStateList =
	ResourcesCompat.getColorStateList(mResources, R.color.complex_unthemed_selector,
	null);
	assertEquals("Unthemed color state list load: default", 0xFF70A0C0,
	unthemedColorStateList.getDefaultColor());
	assertEquals("Unthemed color state list load: focused", 0xFF70B0F0,
	unthemedColorStateList.getColorForState(
	new int[]{android.R.attr.state_focused}, 0));
	assertEquals("Unthemed color state list load: pressed", 0xFF6080B0,
	unthemedColorStateList.getColorForState(
	new int[]{android.R.attr.state_pressed}, 0));

	if (Build.VERSION.SDK_INT >= 23) {
	// The following tests are only expected to pass on v23+ devices. The result of
	// calling theme-aware getColorStateList() in pre-v23 is undefined.
	final Resources.Theme yellowTheme = mResources.newTheme();
	yellowTheme.applyStyle(R.style.YellowTheme, true);
	final ColorStateList themedYellowColorStateList =
	ResourcesCompat.getColorStateList(mResources, R.color.complex_themed_selector,
	yellowTheme);
	assertEquals("Themed yellow color state list load: default", 0xFFF0B000,
	themedYellowColorStateList.getDefaultColor());
	assertEquals("Themed yellow color state list load: focused", 0xFFF0A020,
	themedYellowColorStateList.getColorForState(
	new int[]{android.R.attr.state_focused}, 0));
	assertEquals("Themed yellow color state list load: pressed", 0xFFE0A040,
	themedYellowColorStateList.getColorForState(
	new int[]{android.R.attr.state_pressed}, 0));

	final Resources.Theme lilacTheme = mResources.newTheme();
	lilacTheme.applyStyle(R.style.LilacTheme, true);
	final ColorStateList themedLilacColorStateList =
	ResourcesCompat.getColorStateList(mResources, R.color.complex_themed_selector,
	lilacTheme);
	assertEquals("Themed lilac color state list load: default", 0xFFF080F0,
	themedLilacColorStateList.getDefaultColor());
	assertEquals("Themed lilac color state list load: focused", 0xFFF070D0,
	themedLilacColorStateList.getColorForState(
	new int[]{android.R.attr.state_focused}, 0));
	assertEquals("Themed lilac color state list load: pressed", 0xFFE070A0,
	themedLilacColorStateList.getColorForState(
	new int[]{android.R.attr.state_pressed}, 0));
	}
	}

	@Test
	public void testGetDrawable() throws Throwable {
	final Drawable unthemedDrawable =
	ResourcesCompat.getDrawable(mResources, R.drawable.test_drawable_red, null);
	TestUtils.assertAllPixelsOfColor("Unthemed drawable load",
	unthemedDrawable, mResources.getColor(R.color.test_red));

	if (Build.VERSION.SDK_INT >= 23) {
	// The following tests are only expected to pass on v23+ devices. The result of
	// calling theme-aware getDrawable() in pre-v23 is undefined.
	final Resources.Theme yellowTheme = mResources.newTheme();
	yellowTheme.applyStyle(R.style.YellowTheme, true);
	final Drawable themedYellowDrawable =
	ResourcesCompat.getDrawable(mResources, R.drawable.themed_drawable,
	yellowTheme);
	TestUtils.assertAllPixelsOfColor("Themed yellow drawable load",
	themedYellowDrawable, 0xFFF0B000);

	final Resources.Theme lilacTheme = mResources.newTheme();
	lilacTheme.applyStyle(R.style.LilacTheme, true);
	final Drawable themedLilacDrawable =
	ResourcesCompat.getDrawable(mResources, R.drawable.themed_drawable, lilacTheme);
	TestUtils.assertAllPixelsOfColor("Themed lilac drawable load",
	themedLilacDrawable, 0xFFF080F0);
	}
	}

	@Test
	public void testGetDrawableForDensityUnthemed() throws Throwable {
	// Density-aware drawable loading for now only works on raw bitmap drawables.

	// Different variants of density_aware_drawable are set up in the following way:
	// mdpi - 12x12 px which is 12x12 dip
	// hdpi - 21x21 px which is 14x14 dip
	// xhdpi - 32x32 px which is 16x16 dip
	// xxhdpi - 54x54 px which is 18x18 dip
	// The tests below (on v15+ devices) are checking that an unthemed density-aware
	// loading of raw bitmap drawables returns a drawable with matching intrinsic
	// dimensions.

	final Drawable unthemedDrawableForMediumDensity =
	ResourcesCompat.getDrawableForDensity(mResources, R.drawable.density_aware_drawable,
	DisplayMetrics.DENSITY_MEDIUM, null);
	// For pre-v15 devices we should get a drawable that corresponds to the density of the
	// current device. For v15+ devices we should get a drawable that corresponds to the
	// density requested in the API call.
	final int expectedSizeForMediumDensity = (Build.VERSION.SDK_INT < 15) ?
	mResources.getDimensionPixelSize(R.dimen.density_aware_size) : 12;
	assertEquals("Unthemed density-aware drawable load: medium width",
	expectedSizeForMediumDensity, unthemedDrawableForMediumDensity.getIntrinsicWidth());
	assertEquals("Unthemed density-aware drawable load: medium height",
	expectedSizeForMediumDensity,
	unthemedDrawableForMediumDensity.getIntrinsicHeight());

	final Drawable unthemedDrawableForHighDensity =
	ResourcesCompat.getDrawableForDensity(mResources, R.drawable.density_aware_drawable,
	DisplayMetrics.DENSITY_HIGH, null);
	// For pre-v15 devices we should get a drawable that corresponds to the density of the
	// current device. For v15+ devices we should get a drawable that corresponds to the
	// density requested in the API call.
	final int expectedSizeForHighDensity = (Build.VERSION.SDK_INT < 15) ?
	mResources.getDimensionPixelSize(R.dimen.density_aware_size) : 21;
	assertEquals("Unthemed density-aware drawable load: high width",
	expectedSizeForHighDensity, unthemedDrawableForHighDensity.getIntrinsicWidth());
	assertEquals("Unthemed density-aware drawable load: high height",
	expectedSizeForHighDensity, unthemedDrawableForHighDensity.getIntrinsicHeight());

	final Drawable unthemedDrawableForXHighDensity =
	ResourcesCompat.getDrawableForDensity(mResources, R.drawable.density_aware_drawable,
	DisplayMetrics.DENSITY_XHIGH, null);
	// For pre-v15 devices we should get a drawable that corresponds to the density of the
	// current device. For v15+ devices we should get a drawable that corresponds to the
	// density requested in the API call.
	final int expectedSizeForXHighDensity = (Build.VERSION.SDK_INT < 15) ?
	mResources.getDimensionPixelSize(R.dimen.density_aware_size) : 32;
	assertEquals("Unthemed density-aware drawable load: xhigh width",
	expectedSizeForXHighDensity, unthemedDrawableForXHighDensity.getIntrinsicWidth());
	assertEquals("Unthemed density-aware drawable load: xhigh height",
	expectedSizeForXHighDensity, unthemedDrawableForXHighDensity.getIntrinsicHeight());

	final Drawable unthemedDrawableForXXHighDensity =
	ResourcesCompat.getDrawableForDensity(mResources, R.drawable.density_aware_drawable,
	DisplayMetrics.DENSITY_XXHIGH, null);
	// For pre-v15 devices we should get a drawable that corresponds to the density of the
	// current device. For v15+ devices we should get a drawable that corresponds to the
	// density requested in the API call.
	final int expectedSizeForXXHighDensity = (Build.VERSION.SDK_INT < 15) ?
	mResources.getDimensionPixelSize(R.dimen.density_aware_size) : 54;
	assertEquals("Unthemed density-aware drawable load: xxhigh width",
	expectedSizeForXXHighDensity, unthemedDrawableForXXHighDensity.getIntrinsicWidth());
	assertEquals("Unthemed density-aware drawable load: xxhigh height",
	expectedSizeForXXHighDensity,
	unthemedDrawableForXXHighDensity.getIntrinsicHeight());
	}

	@Test
	public void testGetDrawableForDensityThemed() throws Throwable {
	if (Build.VERSION.SDK_INT < 21) {
	// The following tests are only expected to pass on v21+ devices. The result of
	// calling theme-aware getDrawableForDensity() in pre-v21 is undefined.
	return;
	}

	// Density- and theme-aware drawable loading for now only works partially. This test
	// checks only for theming of a tinted bitmap XML drawable, but not correct scaling.

	// Set up the two test themes, yellow and lilac.
	final Resources.Theme yellowTheme = mResources.newTheme();
	yellowTheme.applyStyle(R.style.YellowTheme, true);

	final Resources.Theme lilacTheme = mResources.newTheme();
	lilacTheme.applyStyle(R.style.LilacTheme, true);

	Drawable themedYellowDrawableForMediumDensity =
	ResourcesCompat.getDrawableForDensity(mResources, R.drawable.themed_bitmap,
	DisplayMetrics.DENSITY_MEDIUM, yellowTheme);
	// We should get a drawable that corresponds to the theme requested in the API call.
	TestUtils.assertAllPixelsOfColor("Themed yellow density-aware drawable load : medium color",
	themedYellowDrawableForMediumDensity, 0xFFF0B000);

	Drawable themedLilacDrawableForMediumDensity =
	ResourcesCompat.getDrawableForDensity(mResources, R.drawable.themed_bitmap,
	DisplayMetrics.DENSITY_MEDIUM, lilacTheme);
	// We should get a drawable that corresponds to the theme requested in the API call.
	TestUtils.assertAllPixelsOfColor("Themed lilac density-aware drawable load : medium color",
	themedLilacDrawableForMediumDensity, 0xFFF080F0);

	Drawable themedYellowDrawableForHighDensity =
	ResourcesCompat.getDrawableForDensity(mResources, R.drawable.themed_bitmap,
	DisplayMetrics.DENSITY_HIGH, yellowTheme);
	// We should get a drawable that corresponds to the theme requested in the API call.
	TestUtils.assertAllPixelsOfColor("Themed yellow density-aware drawable load : high color",
	themedYellowDrawableForHighDensity, 0xFFF0B000);

	Drawable themedLilacDrawableForHighDensity =
	ResourcesCompat.getDrawableForDensity(mResources, R.drawable.themed_bitmap,
	DisplayMetrics.DENSITY_HIGH, lilacTheme);
	// We should get a drawable that corresponds to the theme requested in the API call.
	TestUtils.assertAllPixelsOfColor("Themed lilac density-aware drawable load : high color",
	themedLilacDrawableForHighDensity, 0xFFF080F0);

	Drawable themedYellowDrawableForXHighDensity =
	ResourcesCompat.getDrawableForDensity(mResources, R.drawable.themed_bitmap,
	DisplayMetrics.DENSITY_XHIGH, yellowTheme);
	// We should get a drawable that corresponds to the theme requested in the API call.
	TestUtils.assertAllPixelsOfColor("Themed yellow density-aware drawable load : xhigh color",
	themedYellowDrawableForXHighDensity, 0xFFF0B000);

	Drawable themedLilacDrawableForXHighDensity =
	ResourcesCompat.getDrawableForDensity(mResources, R.drawable.themed_bitmap,
	DisplayMetrics.DENSITY_XHIGH, lilacTheme);
	// We should get a drawable that corresponds to the theme requested in the API call.
	TestUtils.assertAllPixelsOfColor("Themed lilac density-aware drawable load : xhigh color",
	themedLilacDrawableForXHighDensity, 0xFFF080F0);

	Drawable themedYellowDrawableForXXHighDensity =
	ResourcesCompat.getDrawableForDensity(mResources, R.drawable.themed_bitmap,
	DisplayMetrics.DENSITY_XXHIGH, yellowTheme);
	// We should get a drawable that corresponds to the theme requested in the API call.
	TestUtils.assertAllPixelsOfColor("Themed yellow density-aware drawable load : xxhigh color",
	themedYellowDrawableForXXHighDensity, 0xFFF0B000);

	Drawable themedLilacDrawableForXXHighDensity =
	ResourcesCompat.getDrawableForDensity(mResources, R.drawable.themed_bitmap,
	DisplayMetrics.DENSITY_XXHIGH, lilacTheme);
	// We should get a drawable that corresponds to the theme requested in the API call.
	TestUtils.assertAllPixelsOfColor("Themed lilac density-aware drawable load : xxhigh color",
	themedLilacDrawableForXXHighDensity, 0xFFF080F0);
	}

	@Test(expected = Resources.NotFoundException.class)
	public void testGetFont_invalidResourceId() {
	ResourcesCompat.getFont(mContext, -1);
	}

	@Test
	public void testGetFont_fontFile_sync() {
	Typeface font = ResourcesCompat.getFont(mContext, R.font.samplefont);

	assertNotNull(font);
	assertNotSame(Typeface.DEFAULT, font);
	}

	private static final class FontCallback extends ResourcesCompat.FontCallback {
	private final CountDownLatch mLatch;
	Typeface mTypeface;

	FontCallback(CountDownLatch latch) {
	mLatch = latch;
	}

	@Override
	public void onFontRetrieved(@NonNull Typeface typeface) {
	mTypeface = typeface;
	mLatch.countDown();
	}

	@Override
	public void onFontRetrievalFailed(int reason) {
	mLatch.countDown();
	}
	}

	@Test
	public void testGetFont_fontFile_async() throws InterruptedException {
	final CountDownLatch latch = new CountDownLatch(1);
	final FontCallback callback = new FontCallback(latch);
	FontsContractCompat.resetCache();

	ResourcesCompat.getFont(mContext, R.font.samplefont, callback, null);

	assertTrue(latch.await(5L, TimeUnit.SECONDS));

	assertNotNull(callback.mTypeface);
	assertNotSame(Typeface.DEFAULT, callback.mTypeface);
	}

	@Test
	public void testGetFont_xmlFile_sync() {
	Typeface font = ResourcesCompat.getFont(mContext, R.font.samplexmlfont);

	assertNotNull(font);
	assertNotSame(Typeface.DEFAULT, font);
	}

	@Test
	public void testGetFont_xmlFile_async() throws InterruptedException {
	final CountDownLatch latch = new CountDownLatch(1);
	final FontCallback callback = new FontCallback(latch);

	ResourcesCompat.getFont(mContext, R.font.samplexmlfont, callback, null);

	assertTrue(latch.await(5L, TimeUnit.SECONDS));

	assertNotNull(callback.mTypeface);
	assertNotSame(Typeface.DEFAULT, callback.mTypeface);
	}

	@Test
	public void testGetFont_xmlProviderFile_sync() {
	Typeface font = ResourcesCompat.getFont(mContext, R.font.samplexmldownloadedfont);

	assertNotNull(font);
	assertNotSame(Typeface.DEFAULT, font);
	}

	@Test
	public void testGetFont_xmlProviderFile_async() throws InterruptedException {
	final CountDownLatch latch = new CountDownLatch(1);
	final FontCallback callback = new FontCallback(latch);

	// Font provider non-blocking requests post on the calling thread so can't run on
	// the test thread as it doesn't have a Looper.
	InstrumentationRegistry.getInstrumentation().runOnMainSync(new Runnable() {
	@Override
	public void run() {
	ResourcesCompat.getFont(mContext, R.font.samplexmldownloadedfont, callback, null);
	}
	});

	assertTrue(latch.await(5L, TimeUnit.SECONDS));

	assertNotNull(callback.mTypeface);
	assertNotSame(Typeface.DEFAULT, callback.mTypeface);
	}

	@Test
	public void testGetFont_invalidXmlFile() {
	try {
	assertNull(
	ResourcesCompat.getFont(mContext, R.font.invalid_xmlfamily));
	} catch (Resources.NotFoundException e) {
	// pass
	}

	try {
	assertNull(ResourcesCompat.getFont(mContext, R.font.invalid_xmlempty));
	} catch (Resources.NotFoundException e) {
	// pass
	}
	}

	@Test
	public void testGetFont_fontFileIsCached() {
	Typeface font = ResourcesCompat.getFont(mContext, R.font.samplefont);
	Typeface font2 = ResourcesCompat.getFont(mContext, R.font.samplefont);

	assertSame(font, font2);
	}

	@Test
	public void testGetFont_xmlFileIsCached() {
	Typeface font = ResourcesCompat.getFont(mContext, R.font.samplexmlfont);
	Typeface font2 = ResourcesCompat.getFont(mContext, R.font.samplexmlfont);

	assertSame(font, font2);
	}
	}