अपने टेस्ट सिंक करना

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

आम तौर पर, आपको कोई कार्रवाई नहीं करनी होती. हालांकि, कुछ किनारे हैं जिनके बारे में आपको पता होना चाहिए.

जब कोई परीक्षण सिंक किया जाता है, तो आपका Compose ऐप्लिकेशन समय पर वर्चुअल घड़ी. इसका मतलब है कि 'लिखें' टेस्ट रीयल टाइम में नहीं चल सकते, इसलिए वे इस टेस्ट को पास कर सकते हैं जितनी जल्दी हो सके.

हालांकि, अगर टेस्ट को सिंक करने वाले तरीकों का इस्तेमाल नहीं किया जाता है, तो इसमें बदलाव किया जाएगा और यूज़र इंटरफ़ेस (यूआई) रोका गया दिखेगा.

@Test
fun counterTest() {
    val myCounter = mutableStateOf(0) // State that can cause recompositions.
    var lastSeenValue = 0 // Used to track recompositions.
    composeTestRule.setContent {
        Text(myCounter.value.toString())
        lastSeenValue = myCounter.value
    }
    myCounter.value = 1 // The state changes, but there is no recomposition.

    // Fails because nothing triggered a recomposition.
    assertTrue(lastSeenValue == 1)

    // Passes because the assertion triggers recomposition.
    composeTestRule.onNodeWithText("1").assertExists()
}

ध्यान दें कि यह शर्त सिर्फ़ 'लिखें' कैटगरी पर लागू होती है, न कि ऐप्लिकेशन के बाकी हिस्से में.

अपने-आप सिंक होने की सुविधा बंद करें

जब आप ComposeTestRule के ज़रिए किसी दावे या कार्रवाई को कॉल करते हैं, जैसे कि assertExists(), आपका टेस्ट Compose के यूज़र इंटरफ़ेस (यूआई) के साथ सिंक हो गया है. कुछ मामलों में हो सकता है कि आप यह सिंक्रोनाइज़ेशन बंद करना चाहें और खुद घड़ी को कंट्रोल करना चाहें. इसके लिए उदाहरण के लिए, आप एनिमेशन के सटीक स्क्रीनशॉट लेने का समय वह पॉइंट जहां से यूज़र इंटरफ़ेस (यूआई) अब भी व्यस्त होगा. अपने-आप सिंक होने की सुविधा बंद करने के लिए, mainClock में autoAdvance प्रॉपर्टी को false पर सेट करें:

composeTestRule.mainClock.autoAdvance = false

आम तौर पर, आपको खुद ही सेशन को आगे बढ़ाने का मौका मिलेगा. आप सिर्फ़ एक बार आगे बढ़ सकते हैं फ़्रेम को advanceTimeByFrame() या तय अवधि के हिसाब से advanceTimeBy():

composeTestRule.mainClock.advanceTimeByFrame()
composeTestRule.mainClock.advanceTimeBy(milliseconds)

ऐसे संसाधन जो कुछ समय से इस्तेमाल में नहीं हैं

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

अपने टेस्ट में इस्तेमाल में नहीं रहने वाले रिसॉर्स बनाएं और रजिस्टर करें, ताकि उन्हें टेस्ट में शामिल किया जा सके यह तय करते समय कि ऐप्लिकेशन व्यस्त है या इस्तेमाल में नहीं है. आपको ये नहीं करना है आपको अतिरिक्त आइडलिंग संसाधनों का पंजीकरण होने तक कार्रवाई नहीं करनी होगी, उदाहरण के लिए, अगर आप कोई ऐसा बैकग्राउंड जॉब चलाते हैं जो Espresso के साथ सिंक नहीं है या लिखें.

यह एपीआई, Espresso के Idलिंग रिसॉर्स से काफ़ी मिलता-जुलता है. इससे पता चलता है कि जिस विषय की जांच की जा रही है वह कुछ समय से इस्तेमाल में नहीं है या व्यस्त है. रजिस्टर करने के लिए, जांच के लिए 'लिखें' बॉक्स इस्तेमाल करने का नियम IdlingResource को लागू करना.

composeTestRule.registerIdlingResource(idlingResource)
composeTestRule.unregisterIdlingResource(idlingResource)

मैन्युअल सिंक करना

कुछ मामलों में, आपको लिखें यूज़र इंटरफ़ेस (यूआई) को इसके दूसरे हिस्सों के साथ सिंक करना होगा या आपके टेस्ट किए जा रहे ऐप्लिकेशन को चुनें.

waitForIdle() फ़ंक्शन, कंपोज़ के इस्तेमाल में नहीं होने का इंतज़ार करता है, लेकिन फ़ंक्शन autoAdvance प्रॉपर्टी पर निर्भर करता है:

composeTestRule.mainClock.autoAdvance = true // Default
composeTestRule.waitForIdle() // Advances the clock until Compose is idle.

composeTestRule.mainClock.autoAdvance = false
composeTestRule.waitForIdle() // Only waits for idling resources to become idle.

ध्यान दें कि दोनों स्थितियों में, waitForIdle() लंबित ड्रॉ और लेआउट की इंतज़ार करता है पास.

साथ ही, किसी खास शर्त के पूरा होने तक, इस घड़ी को आगे बढ़ाया जा सकता है advanceTimeUntil().

composeTestRule.mainClock.advanceTimeUntil(timeoutMs) { condition }

ध्यान दें कि दी गई शर्त में उस स्थिति की जांच होनी चाहिए जिस पर असर पड़ सकता है (यह सिर्फ़ 'लिखें' स्थिति में काम करता है).

शर्तों का इंतज़ार करें

ऐसी कोई भी स्थिति जो बाहरी काम पर निर्भर करती है, जैसे कि डेटा लोड करना या Android का मेज़र या ड्रॉ करना (यानी, कॉन्टेंट को कंपोज़ की मदद से मेज़र या ड्रॉ करना) है, तो सामान्य कॉन्सेप्ट, जैसे कि waitUntil():

composeTestRule.waitUntil(timeoutMs) { condition }

इस टूल का इस्तेमाल करने के लिए, waitUntil हेल्पर:

composeTestRule.waitUntilAtLeastOneExists(matcher, timeoutMs)

composeTestRule.waitUntilDoesNotExist(matcher, timeoutMs)

composeTestRule.waitUntilExactlyOneExists(matcher, timeoutMs)

composeTestRule.waitUntilNodeCount(matcher, count, timeoutMs)

अतिरिक्त संसाधन

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