अलग-अलग स्क्रीन साइज़ की जांच करने के लिए लाइब्रेरी और टूल

Android कई तरह के टूल और एपीआई उपलब्ध कराता है. इनकी मदद से, अपने ऐप्लिकेशन के लिए टेस्ट तैयार किए जा सकते हैं अलग-अलग स्क्रीन और विंडो साइज़ों में फ़िल्टर किया जा सकता है.

डिवाइस कॉन्फ़िगरेशन ओवरराइड

के कलाकार

DeviceConfigurationOverride कंपोज़ेबल में बदला जा सकता है कॉन्फ़िगरेशन एट्रिब्यूट, ताकि Compose में एक से ज़्यादा स्क्रीन और विंडो साइज़ की जांच की जा सके लेआउट. ForcedSize ओवरराइड, उपलब्ध जगह के किसी भी लेआउट में फ़िट हो जाता है, जिससे आपको किसी भी समय अपनी साइट पर किसी भी स्क्रीन साइज़ के लिए यूज़र इंटरफ़ेस (यूआई) की जांच. उदाहरण के लिए, छोटे साइज़ वाले फ़ोन के नाप या आकार का इस्तेमाल किया जा सकता है यूज़र इंटरफ़ेस (यूआई) की जांच करने के लिए, इसमें बड़े फ़ोन, फ़ोल्ड किए जा सकने वाले डिवाइस, और टैबलेट.

   DeviceConfigurationOverride(
        DeviceConfigurationOverride.ForcedSize(DpSize(1280.dp, 800.dp))
    ) {
        MyScreen() // Will be rendered in the space for 1280dp by 800dp without clipping.
    }
पहली इमेज. डिवाइस के छोटे नाप या आकार वाले डिवाइस में टैबलेट के लेआउट को फ़िट करने के लिए, DeviceConfigurationEnabled का इस्तेमाल करना. जैसे, \*अब Android में*.

इसके अलावा, इस कंपोज़ेबल का इस्तेमाल फ़ॉन्ट स्केल, थीम वगैरह सेट करने के लिए भी किया जा सकता है प्रॉपर्टी, जिन्हें आप अलग-अलग विंडो साइज़ पर टेस्ट करना चाहें.

रोबोलेक्टिक

JVM पर, Compose या देखने पर आधारित यूज़र इंटरफ़ेस (यूआई) टेस्ट चलाने के लिए, Robolectric का इस्तेमाल करें स्थानीय तौर पर—किसी डिवाइस या एम्युलेटर की ज़रूरत नहीं है. आपके पास कॉन्फ़िगर करने का विकल्प होता है Robolectric, अन्य उपयोगी गुणों के साथ विशिष्ट स्क्रीन साइज़ का इस्तेमाल करने के लिए.

अब Android में के इस उदाहरण में, Robolectric कॉन्फ़िगर किया गया 480 डीपीआई के रिज़ॉल्यूशन वाली 1000x1000 dp की स्क्रीन साइज़ को एम्युलेट करने के लिए:

@RunWith(RobolectricTestRunner::class)
// Configure Robolectric to use a very large screen size that can fit all of the test sizes.
// This allows enough room to render the content under test without clipping or scaling.
@Config(qualifiers = "w1000dp-h1000dp-480dpi")
class NiaAppScreenSizesScreenshotTests { ... }

आपके पास इस स्निपेट में मौजूद जांच वाले मुख्य हिस्से के क्वालीफ़ायर को सेट करने का विकल्प भी है. इसके लिए, यहां जाएं: अब Android में उदाहरण:

val (width, height, dpi) = ...

// Set qualifiers from specs.
RuntimeEnvironment.setQualifiers("w${width}dp-h${height}dp-${dpi}dpi")

ध्यान दें कि RuntimeEnvironment.setQualifiers(), सिस्टम को अपडेट करता है और ऐप्लिकेशन संसाधन जोड़े जाएंगे, लेकिन उनसे कोई कार्रवाई नहीं होगी चालू गतिविधियों या अन्य कॉम्पोनेंट पर हो सकता है.

इस बारे में ज़्यादा जानकारी के लिए, Robolectric डिवाइस कॉन्फ़िगरेशन दस्तावेज़ पढ़ें.

ऐसे डिवाइस जिन्हें Gradle मैनेज करता है

Gradle से मैनेज किए जाने वाले डिवाइस (GMD) Android Gradle प्लग इन की जानकारी के आधार पर एम्युलेटर और वास्तविक डिवाइस के बारे में आपके इंस्ट्रुमेंट वाले टेस्ट चलते हैं. इस सुविधा वाले डिवाइसों के लिए खास निर्देश बनाएं जिसमें टेस्टिंग की रणनीति लागू की जा सके, जिसमें कुछ टेस्ट के लिए कुछ स्क्रीन साइज़ पर चलाए जा सकते हैं. लगातार इंटिग्रेशन के साथ जीएमडी का इस्तेमाल करके (सीआई), तो यह पक्का किया जा सकता है कि ज़रूरत पड़ने पर सही टेस्ट चलाए जाएं, एम्युलेटर का प्रावधान और लॉन्च करना. साथ ही, अपने सीआई सेटअप को आसान बनाना.

android {
    testOptions {
        managedDevices {
            devices {
                // Run with ./gradlew nexusOneApi30DebugAndroidTest.
                nexusOneApi30(com.android.build.api.dsl.ManagedVirtualDevice) {
                    device = "Nexus One"
                    apiLevel = 30
                    // Use the AOSP ATD image for better emulator performance
                    systemImageSource = "aosp-atd"
                }
                // Run with ./gradlew  foldApi34DebugAndroidTest.
                foldApi34(com.android.build.api.dsl.ManagedVirtualDevice) {
                    device = "Pixel Fold"
                    apiLevel = 34
                    systemImageSource = "aosp-atd"
                }
            }
        }
    }
}

टेस्टिंग-सैंपल प्रोजेक्ट में आपको जीएमडी के कई उदाहरण मिल सकते हैं.

Firebase टेस्ट लैब

Firebase टेस्ट लैब (एफ़टीएल) या इससे मिलते-जुलते डिवाइस फ़ार्म सर्विस का इस्तेमाल करें. ऐसे खास डिवाइसों पर टेस्ट करना जिनका ऐक्सेस शायद आपके पास न हो, जैसे कि फ़ोल्ड किए जा सकने वाले डिवाइस या अलग-अलग साइज़ के टैबलेट. Firebase टेस्ट लैब के लिए पैसे चुकाकर सदस्यता ली जा सकती है फ़्री टियर वाली सेवा उपलब्ध कराते हैं. FTL, एम्युलेटर पर चलाए जा रहे टेस्ट के साथ भी काम करते हैं. ये सेवाएं इंस्ट्रुमेंटेड टेस्टिंग की विश्वसनीयता और स्पीड को बेहतर बनाती हैं, क्योंकि वे डिवाइस और एम्युलेटर का प्रावधान समय से पहले कर सकें.

GMD के साथ FTL का इस्तेमाल करने के बारे में जानकारी पाने के लिए, ऐसे डिवाइस जिन्हें Gradle मैनेज करता है.

टेस्ट रनर की मदद से फ़िल्टर की जांच करना

जांच करने की एक बेहतर रणनीति बनाने के लिए, एक ही चीज़ की पुष्टि दो बार नहीं होनी चाहिए. इसलिए, आपके ज़्यादातर यूज़र इंटरफ़ेस (यूआई) की जांच को कई डिवाइसों पर चलाने की ज़रूरत नहीं है. आम तौर पर, यूज़र इंटरफ़ेस (यूआई) को फ़िल्टर किया जाता है सभी या ज़्यादातर को फ़ोन के नाप या आकार पर चलाकर जांच की जाती है. साथ ही, अलग-अलग स्क्रीन साइज़ वाले डिवाइसों पर.

आपके पास कुछ ऐसे टेस्ट की जानकारी देने का विकल्प होता है जिन्हें सिर्फ़ चुनिंदा डिवाइसों पर चलाया जा सके. इसके बाद, AndroidJUnitRunner को चलाने वाले निर्देश का इस्तेमाल करके टेस्ट.

उदाहरण के लिए, अलग-अलग तरह के एनोटेशन बनाए जा सकते हैं:

annotation class TestExpandedWidth
annotation class TestCompactWidth

और अलग-अलग टेस्ट में उनका इस्तेमाल करें:

class MyTestClass {

    @Test
    @TestExpandedWidth
    fun myExample_worksOnTablet() {
        ...
    }

    @Test
    @TestCompactWidth
    fun myExample_worksOnPortraitPhone() {
        ...
    }

}

इसके बाद, android.testInstrumentationRunnerArguments.annotation का इस्तेमाल किया जा सकता है प्रॉपर्टी का इस्तेमाल करें. उदाहरण के लिए, अगर आपको Gradle से मैनेज किए जाने वाले डिवाइसों का इस्तेमाल करके:

$ ./gradlew pixelTabletApi30DebugAndroidTest -Pandroid.testInstrumentationRunnerArguments.annotation='com.sample.TestExpandedWidth'

अगर आपने GMD का इस्तेमाल नहीं किया है और CI पर एम्युलेटर मैनेज किए जा रहे हैं, तो पहले पक्का करें कि सही एम्युलेटर या डिवाइस तैयार है और कनेक्ट है. इसके बाद, पैरामीटर को पास करें इंस्ट्रुमेंट वाले टेस्ट चलाने के लिए, Gradle कमांड में से एक पर जाएं:

$ ./gradlew connectedAndroidTest -Pandroid.testInstrumentationRunnerArguments.annotation='com.sample.TestExpandedWidth'

ध्यान दें कि Espresso Device (अगला सेक्शन देखें) डिवाइस प्रॉपर्टी.

एस्प्रेसो डिवाइस

किसी भी टेस्ट में, एम्युलेटर पर कार्रवाइयां करने के लिए Espresso डिवाइस का इस्तेमाल करें इसमें इंस्ट्रुमेंटेड टेस्ट के टाइप शामिल हैं. इनमें Espresso, Compose या यूज़र इंटरफ़ेस (यूआई) ऑटोमेटर टेस्ट शामिल हैं. इन कार्रवाइयों में, स्क्रीन का साइज़ सेट करना या फ़ोल्ड किए जा सकने वाले स्टेटस टॉगल करना शामिल हो सकता है या पोस्चर. उदाहरण के लिए, फ़ोल्ड किए जा सकने वाले एम्युलेटर को कंट्रोल किया जा सकता है और टेबलटॉप मोड चालू करना. Espresso Device में JUnit के नियम और एनोटेशन भी शामिल हैं कुछ सुविधाओं की ज़रूरत:

@RunWith(AndroidJUnit4::class)
class OnDeviceTest {

    @get:Rule(order=1) val activityScenarioRule = activityScenarioRule<MainActivity>()

    @get:Rule(order=2) val screenOrientationRule: ScreenOrientationRule =
        ScreenOrientationRule(ScreenOrientation.PORTRAIT)

    @Test
    fun tabletopMode_playerIsDisplayed() {
        // Set the device to tabletop mode.
        onDevice().setTabletopMode()
        onView(withId(R.id.player)).check(matches(isDisplayed()))
    }
}

ध्यान दें कि Espresso डिवाइस अब भी ऐल्फ़ा स्टेज में है और उसमें ये शामिल हैं ज़रूरतें:

  • Android Gradle प्लग इन 8.3 या इसके बाद वाला वर्शन
  • Android Emulator 33.1.10 या उसके बाद वाला वर्शन
  • Android वर्चुअल डिवाइस, जो एपीआई लेवल 24 या उसके बाद के वर्शन पर काम करता है

टेस्ट फ़िल्टर करें

Espresso डिवाइस कनेक्ट किए गए डिवाइसों की प्रॉपर्टी पढ़ सकता है, ताकि आप ये काम कर सकें एनोटेशन का इस्तेमाल करके फ़िल्टर टेस्ट करना. अगर बताई गई ज़रूरी शर्तें पूरी नहीं होती हैं, टेस्ट को स्किप कर दिया जाता है.

DeviceMode व्याख्या ज़रूरी है

RequiresDeviceMode एनोटेशन का इस्तेमाल, अलग-अलग जानकारी देने के लिए कई बार किया जा सकता है ऐसी जांच जो सभी DeviceMode वैल्यू के काम करने पर ही चलेगी डिवाइस पर.

class OnDeviceTest {
    ...
    @Test
    @RequiresDeviceMode(TABLETOP)
    @RequiresDeviceMode(BOOK)
    fun tabletopMode_playerIdDisplayed() {
        // Set the device to tabletop mode.
        onDevice().setTabletopMode()
        onView(withId(R.id.player)).check(matches(isDisplayed()))
    }
}

इसके लिए, Display से जुड़ा एनोटेशन ज़रूरी है

RequiresDisplay एनोटेशन की मदद से, वीडियो की चौड़ाई और ऊंचाई की जानकारी दी जा सकती है डिवाइस की स्क्रीन पर साइज़ क्लास का इस्तेमाल किया जाता है, जो डाइमेंशन बकेट तय करती हैं विंडो के साइज़ की आधिकारिक क्लास के बाद.

class OnDeviceTest {
    ...
    @Test
    @RequiresDisplay(EXPANDED, COMPACT)
    fun myScreen_expandedWidthCompactHeight() {
        ...
    }
}

डिसप्ले का साइज़ बदलें

स्क्रीन के डाइमेंशन का साइज़ बदलने के लिए, setDisplaySize() तरीके का इस्तेमाल करें इस्तेमाल करते हैं. DisplaySizeRule के साथ इस तरीके का इस्तेमाल करें क्लास का इस्तेमाल करती है, जिससे यह पक्का होता है कि टेस्ट के दौरान किए गए सभी बदलाव अगला टेस्ट.

@RunWith(AndroidJUnit4::class)
class ResizeDisplayTest {

    @get:Rule(order = 1) val activityScenarioRule = activityScenarioRule<MainActivity>()

    // Test rule for restoring device to its starting display size when a test case finishes.
    @get:Rule(order = 2) val displaySizeRule: DisplaySizeRule = DisplaySizeRule()

    @Test
    fun resizeWindow_compact() {
        onDevice().setDisplaySize(
            widthSizeClass = WidthSizeClass.COMPACT,
            heightSizeClass = HeightSizeClass.COMPACT
        )
        // Verify visual attributes or state restoration.
    }
}

setDisplaySize() वाले डिसप्ले का साइज़ बदलने पर, डिसप्ले की सघनता पर कोई असर नहीं पड़ता इस तरह किया जाता है, इसलिए अगर कोई डाइमेंशन, टारगेट किए गए डिवाइस में फ़िट नहीं होता है, तो टेस्ट UnsupportedDeviceOperationException से जुड़ी गड़बड़ी. टेस्ट को रोकने के लिए, तो उन्हें फ़िल्टर करने के लिए RequiresDisplay एनोटेशन का इस्तेमाल करें.

@RunWith(AndroidJUnit4::class)
class ResizeDisplayTest {

    @get:Rule(order = 1) var activityScenarioRule = activityScenarioRule<MainActivity>()

    // Test rule for restoring device to its starting display size when a test case finishes.
    @get:Rule(order = 2) var displaySizeRule: DisplaySizeRule = DisplaySizeRule()

    /**
     * Setting the display size to EXPANDED would fail in small devices, so the [RequiresDisplay]
     * annotation prevents this test from being run on devices outside the EXPANDED buckets.
     */
    @RequiresDisplay(
        widthSizeClass = WidthSizeClassEnum.EXPANDED,
        heightSizeClass = HeightSizeClassEnum.EXPANDED
    )
    @Test
    fun resizeWindow_expanded() {
        onDevice().setDisplaySize(
            widthSizeClass = WidthSizeClass.EXPANDED,
            heightSizeClass = HeightSizeClass.EXPANDED
        )
        // Verify visual attributes or state restoration.
    }
}

स्टेटरिस्टोरेशनटेस्टर

राज्य के डेटा को वापस लाने की प्रोसेस की जांच करने के लिए, StateRestorationTester क्लास का इस्तेमाल किया जाता है कंपोज़ेबल कॉम्पोनेंट के लिए डिज़ाइन किया गया है. इससे जांच कम समय में हो जाती है और भरोसेमंद भी, क्योंकि गतिविधि को फिर से बनाना एक जटिल प्रक्रिया है जिसमें कई सिंक करने के तरीके:

@Test
fun compactDevice_selectedEmailEmailRetained_afterConfigChange() {
    val stateRestorationTester = StateRestorationTester(composeTestRule)

    // Set content through the StateRestorationTester object.
    stateRestorationTester.setContent {
        MyApp()
    }

    // Simulate a config change.
    stateRestorationTester.emulateSavedInstanceStateRestore()
}

विंडो टेस्टिंग लाइब्रेरी

विंडो टेस्टिंग लाइब्रेरी में ऐसी सुविधाएं होती हैं जो आपके लिए ऐसे टेस्ट लिखने में मदद करती हैं जो विंडो मैनेजमेंट से जुड़ी सुविधाओं की पुष्टि करेगा या उनकी पुष्टि करेगा, जैसे कि गतिविधि एम्बेड करने या फ़ोल्ड की जा सकने वाली सुविधाएं. आर्टफ़ैक्ट को Google के Maven रिपॉज़िटरी.

उदाहरण के लिए, FoldingFeature() फ़ंक्शन का इस्तेमाल करके पसंद के मुताबिक बनाया गया FoldingFeature, जिसका इस्तेमाल झलक 'लिखें' सुविधा में किया जा सकता है. Java में, createFoldingFeature() फ़ंक्शन का इस्तेमाल करें.

कंपोज़ की झलक में, FoldingFeature को इस तरह लागू किया जा सकता है:

@Preview(showBackground = true, widthDp = 480, heightDp = 480)
@Composable private fun FoldablePreview() =
    MyApplicationTheme {
        ExampleScreen(
            displayFeatures = listOf(FoldingFeature(Rect(0, 240, 480, 240)))
        )
 }

साथ ही, यूज़र इंटरफ़ेस (यूआई) टेस्ट में डिसप्ले सुविधाओं को एम्युलेट करने के लिए, TestWindowLayoutInfo() फ़ंक्शन का इस्तेमाल करें. नीचे दिया गया उदाहरण, FoldingFeature को सिम्युलेट करता है. इसमें HALF_OPENED के बीच में वर्टिकल हिंज है, जो जांच करता है कि क्या लेआउट उम्मीद के मुताबिक है:

Compose

import androidx.window.layout.FoldingFeature.Orientation.Companion.VERTICAL
import androidx.window.layout.FoldingFeature.State.Companion.HALF_OPENED
import androidx.window.testing.layout.FoldingFeature
import androidx.window.testing.layout.TestWindowLayoutInfo
import androidx.window.testing.layout.WindowLayoutInfoPublisherRule

@RunWith(AndroidJUnit4::class)
class MediaControlsFoldingFeatureTest {

    @get:Rule(order=1)
    val composeTestRule = createAndroidComposeRule<ComponentActivity>()

    @get:Rule(order=2)
    val windowLayoutInfoPublisherRule = WindowLayoutInfoPublisherRule()

    @Test
    fun foldedWithHinge_foldableUiDisplayed() {
        composeTestRule.setContent {
            MediaPlayerScreen()
        }

        val hinge = FoldingFeature(
            activity = composeTestRule.activity,
            state = HALF_OPENED,
            orientation = VERTICAL,
            size = 2
        )

        val expected = TestWindowLayoutInfo(listOf(hinge))
        windowLayoutInfoPublisherRule.overrideWindowLayoutInfo(expected)

        composeTestRule.waitForIdle()

        // Verify that the folding feature is detected and media controls shown.
        composeTestRule.onNodeWithTag("MEDIA_CONTROLS").assertExists()
    }
}

व्यू

import androidx.window.layout.FoldingFeature.Orientation
import androidx.window.layout.FoldingFeature.State
import androidx.window.testing.layout.FoldingFeature
import androidx.window.testing.layout.TestWindowLayoutInfo
import androidx.window.testing.layout.WindowLayoutInfoPublisherRule

@RunWith(AndroidJUnit4::class)
class MediaControlsFoldingFeatureTest {

    @get:Rule(order=1)
    val activityRule = ActivityScenarioRule(MediaPlayerActivity::class.java)

    @get:Rule(order=2)
    val windowLayoutInfoPublisherRule = WindowLayoutInfoPublisherRule()

    @Test
    fun foldedWithHinge_foldableUiDisplayed() {
        activityRule.scenario.onActivity { activity ->
            val feature = FoldingFeature(
                activity = activity,
                state = State.HALF_OPENED,
                orientation = Orientation.VERTICAL)
            val expected = TestWindowLayoutInfo(listOf(feature))
            windowLayoutInfoPublisherRule.overrideWindowLayoutInfo(expected)
        }

        // Verify that the folding feature is detected and media controls shown.
        onView(withId(R.id.media_controls)).check(matches(isDisplayed()))
    }
}

आपको WindowManager प्रोजेक्ट में और सैंपल मिल सकते हैं.

अन्य संसाधन

दस्तावेज़

सैंपल

कोड लैब