इस पेज का अनुवाद Cloud Translation API से किया गया है.

AndroidJUnitRunner

AndroidJUnitRunner क्लास, JUnit टेस्ट रननर है. इससे, Android डिवाइसों पर इंस्ट्रूमेंट किए गए JUnit 4 टेस्ट चलाए जा सकते हैं. इनमें Espresso, UI Automator, और Compose टेस्टिंग फ़्रेमवर्क का इस्तेमाल करने वाले डिवाइस भी शामिल हैं.

टेस्ट रनर, आपके टेस्ट पैकेज और टेस्ट किए जा रहे ऐप्लिकेशन को डिवाइस पर लोड करने, टेस्ट चलाने, और टेस्ट के नतीजों की रिपोर्ट करने की सुविधा देता है.

यह टेस्ट रननर, टेस्टिंग से जुड़े कई सामान्य टास्क के साथ काम करता है. जैसे:

JUnit टेस्ट लिखना
ऐप्लिकेशन का कॉन्टेक्स्ट ऐक्सेस करना
टेस्ट फ़िल्टर करना
शर्ड करने से जुड़े टेस्ट

JUnit टेस्ट लिखना

नीचे दिए गए कोड स्निपेट में, इंस्ट्रूमेंट किए गए JUnit 4 के टेस्ट को लिखने का तरीका बताया गया है. इससे यह पुष्टि की जा सकती है कि ChangeTextBehavior क्लास में changeText ऑपरेशन सही तरीके से काम कर रहा है या नहीं:

Kotlin

@RunWith(AndroidJUnit4::class)
@LargeTest // Optional runner annotation
class ChangeTextBehaviorTest {
 val stringToBeTyped = "Espresso"
 // ActivityTestRule accesses context through the runner
 @get:Rule
 val activityRule = ActivityTestRule(MainActivity::class.java)

 @Test fun changeText_sameActivity() {
 // Type text and then press the button.
 onView(withId(R.id.editTextUserInput))
 .perform(typeText(stringToBeTyped), closeSoftKeyboard())
 onView(withId(R.id.changeTextBt)).perform(click())

 // Check that the text was changed.
 onView(withId(R.id.textToBeChanged))
 .check(matches(withText(stringToBeTyped)))
 }
}

Java

@RunWith(AndroidJUnit4.class)
@LargeTest // Optional runner annotation
public class ChangeTextBehaviorTest {

    private static final String stringToBeTyped = "Espresso";

    @Rule
    public ActivityTestRule<MainActivity>; activityRule =
            new ActivityTestRule<>;(MainActivity.class);

    @Test
    public void changeText_sameActivity() {
        // Type text and then press the button.
        onView(withId(R.id.editTextUserInput))
                .perform(typeText(stringToBeTyped), closeSoftKeyboard());
        onView(withId(R.id.changeTextBt)).perform(click());

        // Check that the text was changed.
        onView(withId(R.id.textToBeChanged))
                .check(matches(withText(stringToBeTyped)));
    }
}

ऐप्लिकेशन का कॉन्टेक्स्ट ऐक्सेस करना

टेस्ट चलाने के लिए AndroidJUnitRunner का इस्तेमाल करने पर, स्टैटिक ApplicationProvider.getApplicationContext() तरीके को कॉल करके, टेस्ट किए जा रहे ऐप्लिकेशन का कॉन्टेक्स्ट ऐक्सेस किया जा सकता है. अगर आपने अपने ऐप्लिकेशन में Application का कस्टम सबक्लास बनाया है, तो यह तरीका आपके कस्टम सबक्लास का कॉन्टेक्स्ट दिखाता है.

अगर आप टूल लागू करने वाले व्यक्ति हैं, तो InstrumentationRegistry क्लास का इस्तेमाल करके, लो-लेवल टेस्टिंग एपीआई ऐक्सेस किए जा सकते हैं. इस क्लास में, Instrumentation ऑब्जेक्ट, टारगेट ऐप्लिकेशन Context ऑब्जेक्ट, टेस्ट ऐप्लिकेशन Context ऑब्जेक्ट, और आपके टेस्ट में पास किए गए कमांड लाइन आर्ग्युमेंट शामिल होते हैं.

टेस्ट फ़िल्टर करना

JUnit 4.x टेस्ट में, टेस्ट रन को कॉन्फ़िगर करने के लिए एनोटेशन का इस्तेमाल किया जा सकता है. इस सुविधा की मदद से, आपको अपने टेस्ट में बोइलरप्लेट और कंडीशनल कोड जोड़ने की ज़रूरत नहीं पड़ती. JUnit 4 के साथ काम करने वाले स्टैंडर्ड एनोटेशन के अलावा, टेस्ट रनर में Android के लिए खास तौर पर बने एनोटेशन भी काम करते हैं. इनमें ये शामिल हैं:

@RequiresDevice: इससे पता चलता है कि जांच सिर्फ़ असल डिवाइसों पर होनी चाहिए, न कि एमुलेटर पर.
@SdkSuppress: यह विकल्प, दिए गए लेवल से कम के Android एपीआई लेवल पर जांच को चलाने से रोकता है. उदाहरण के लिए, एपीआई लेवल 23 से कम के सभी टेस्ट को चलाने से रोकने के लिए, एनोटेशन @SDKSuppress(minSdkVersion=23) का इस्तेमाल करें.
@SmallTest, @MediumTest, और @LargeTest: तय करें कि किसी टेस्ट को चलाने में कितना समय लगना चाहिए. इससे यह भी तय होगा कि टेस्ट को कितनी बार चलाया जा सकता है. इस एनोटेशन का इस्तेमाल करके, यह फ़िल्टर किया जा सकता है कि कौनसे टेस्ट चलाने हैं. इसके लिए, android.testInstrumentationRunnerArguments.size प्रॉपर्टी को सेट करें:

-Pandroid.testInstrumentationRunnerArguments.size=small

शेयर किए गए डिवाइसों की जांच

अगर आपको अपने टेस्ट को तेज़ी से चलाने के लिए, उन्हें कई सर्वर पर शेयर करना है, तो उन्हें ग्रुप या शर्ड में बांटें. टेस्ट रनर की मदद से, किसी एक टेस्ट सुइट को कई स्hard में बांटा जा सकता है. इससे, एक ही स्hard से जुड़े टेस्ट को आसानी से एक ग्रुप के तौर पर चलाया जा सकता है. हर शर्ड की पहचान इंडेक्स नंबर से की जाती है. टेस्ट चलाते समय, -e numShards विकल्प का इस्तेमाल करके, अलग-अलग शर्ड बनाने की संख्या तय करें. साथ ही, -e shardIndex विकल्प का इस्तेमाल करके, यह तय करें कि कौनसा शर्ड चलाना है.

उदाहरण के लिए, टेस्ट सुइट को 10 हिस्सों में बांटने और सिर्फ़ दूसरे हिस्से में ग्रुप किए गए टेस्ट चलाने के लिए, यहां दिए गए adb कमांड का इस्तेमाल करें:

adb shell am instrument -w -e numShards 10 -e shardIndex 2

Android Test Orchestrator का इस्तेमाल करना

Android Test Orchestrator की मदद से, Instrumentation को खुद से शुरू करके, अपने ऐप्लिकेशन के सभी टेस्ट चलाए जा सकते हैं. AndroidJUnitRunner के 1.0 या इसके बाद के वर्शन का इस्तेमाल करने पर, आपके पास Android Test Orchestrator का ऐक्सेस होता है.

Android Test Orchestrator, टेस्टिंग के माहौल के लिए ये फ़ायदे देता है:

कम से कम शेयर की गई स्थिति: हर टेस्ट अपने Instrumentation इंस्टेंस में चलता है. इसलिए, अगर आपके टेस्ट में ऐप्लिकेशन की स्थिति शेयर की जाती है, तो हर टेस्ट के बाद, शेयर की गई ज़्यादातर स्थिति को आपके डिवाइस के सीपीयू या मेमोरी से हटा दिया जाता है. हर जांच के बाद, अपने डिवाइस के सीपीयू और मेमोरी से शेयर की गई सभी स्थिति को हटाने के लिए, clearPackageData फ़्लैग का इस्तेमाल करें. उदाहरण के लिए, Gradle से चालू करें सेक्शन देखें.
क्रैश अलग-अलग होते हैं: अगर कोई टेस्ट क्रैश होता है, तो वह Instrumentation के सिर्फ़ अपने इंस्टेंस को बंद करता है. इसका मतलब है कि आपके सुइट में मौजूद अन्य टेस्ट अब भी चलेंगे और आपको टेस्ट के पूरे नतीजे मिलेंगे.

इस अलगाव की वजह से, टेस्ट को पूरा होने में ज़्यादा समय लग सकता है. ऐसा इसलिए, क्योंकि Android Test Orchestrator हर टेस्ट के बाद ऐप्लिकेशन को रीस्टार्ट करता है.

Android Studio और Firebase Test Lab, दोनों में Android Test Orchestrator पहले से इंस्टॉल होता है. हालांकि, आपको Android Studio में यह सुविधा चालू करनी होगी.

Gradle से चालू करना

Gradle कमांड-लाइन टूल का इस्तेमाल करके, Android Test Orchestrator को चालू करने के लिए, यह तरीका अपनाएं:

पहला चरण: Gradle फ़ाइल में बदलाव करना. अपने प्रोजेक्ट की build.gradle फ़ाइल में ये स्टेटमेंट जोड़ें:

android {
 defaultConfig {
  ...
  testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"

  // The following argument makes the Android Test Orchestrator run its
  // "pm clear" command after each test invocation. This command ensures
  // that the app's state is completely cleared between tests.
  testInstrumentationRunnerArguments clearPackageData: 'true'
 }

 testOptions {
  execution 'ANDROIDX_TEST_ORCHESTRATOR'
 }
}

dependencies {
 androidTestImplementation 'androidx.test:runner:1.1.0'
 androidTestUtil 'androidx.test:orchestrator:1.1.0'
}

दूसरा चरण: यह कमांड चलाकर, Android Test Orchestrator चलाएं:

./gradlew connectedCheck

Android Studio से चालू करना

Android Studio में Android Test Orchestrator को चालू करने के लिए, अपने ऐप्लिकेशन की build.gradle फ़ाइल में, Gradle से चालू करें में दिखाए गए स्टेटमेंट जोड़ें.

कमांड लाइन से चालू करना

कमांड लाइन पर Android Test Orchestrator का इस्तेमाल करने के लिए, टर्मिनल विंडो में ये कमांड चलाएं:

DEVICE_API_LEVEL=$(adb shell getprop ro.build.version.sdk)

FORCE_QUERYABLE_OPTION=""
if [[ $DEVICE_API_LEVEL -ge 30 ]]; then
   FORCE_QUERYABLE_OPTION="--force-queryable"
fi

# uninstall old versions
adb uninstall androidx.test.services
adb uninstall androidx.test.orchestrator

# Install the test orchestrator.
adb install $FORCE_QUERYABLE_OPTION -r path/to/m2repository/androidx/test/orchestrator/1.4.2/orchestrator-1.4.2.apk

# Install test services.
adb install $FORCE_QUERYABLE_OPTION -r path/to/m2repository/androidx/test/services/test-services/1.4.2/test-services-1.4.2.apk

# Replace "com.example.test" with the name of the package containing your tests.
# Add "-e clearPackageData true" to clear your app's data in between runs.
adb shell 'CLASSPATH=$(pm path androidx.test.services) app_process / \
 androidx.test.services.shellexecutor.ShellMain am instrument -w -e \
 targetInstrumentation com.example.test/androidx.test.runner.AndroidJUnitRunner \
 androidx.test.orchestrator/.AndroidTestOrchestrator'

कमांड सिंटैक्स से पता चलता है कि Android Test Orchestrator को इंस्टॉल करने के बाद, उसका सीधे तौर पर इस्तेमाल किया जाता है.

adb shell pm list instrumentation

अलग-अलग टूलचैन का इस्तेमाल करना

अगर ऐप्लिकेशन की जांच करने के लिए किसी दूसरी टूलचेन का इस्तेमाल किया जाता है, तो भी Android Test Orchestrator का इस्तेमाल किया जा सकता है. इसके लिए, यह तरीका अपनाएं:

अपने ऐप्लिकेशन की बिल्ड फ़ाइल में ज़रूरी पैकेज शामिल करें.
कमांड-लाइन से Android Test Orchestrator को चालू करें.

भवन निर्माण

ऑर्केस्ट्रेटर सेवा का APK, जांच के लिए इस्तेमाल किए जाने वाले APK और जांचे जा रहे ऐप्लिकेशन के APK से अलग प्रोसेस में सेव किया जाता है:

ऑर्केस्ट्रेटर की मदद से, JUnit टेस्ट को कंट्रोल किया जा सकता है — **पहली इमेज**: Android टेस्ट ऑर्केस्ट्रेशन APK का स्ट्रक्चर.

Android Test Orchestrator, आपके टेस्ट सुइट के शुरू होने पर JUnit टेस्ट इकट्ठा करता है. हालांकि, इसके बाद यह हर टेस्ट को Instrumentation के अपने इंस्टेंस में अलग से चलाता है.

ज़्यादा जानकारी

AndroidJUnitRunner का इस्तेमाल करने के बारे में ज़्यादा जानने के लिए, एपीआई रेफ़रंस देखें.

अन्य संसाधन

AndroidJUnitRunner का इस्तेमाल करने के बारे में ज़्यादा जानने के लिए, यहां दिए गए संसाधन देखें.

सैंपल

AndroidJunitRunnerSample: इसमें टेस्ट एनोटेशन, पैरामीटर वाले टेस्ट, और टेस्ट सुइट बनाने की जानकारी दी गई है.