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

इंस्ट्रुमेंटेशन टेस्ट करना शुरू करें

इस गाइड में, Firebase Test Lab का इस्तेमाल करके इंस्ट्रुमेंटेशन टेस्ट तैयार करने और उसे चलाने का तरीका बताया गया है. इस गाइड का इस्तेमाल करने के लिए, आपको इंस्ट्रुमेंटेशन टेस्ट की ज़रूरत होगी. यह टेस्ट, आपने या आपकी टीम ने लिखा हो. साथ ही, इसमें Espresso या UI Automator Android टेस्ट फ़्रेमवर्क का इस्तेमाल किया गया हो. इंस्ट्रुमेंटेशन टेस्ट, फ़िज़िकल डिवाइसों पर 45 मिनट तक और वर्चुअल डिवाइसों पर 60 मिनट तक चल सकते हैं.

बाद के चरणों में, आपको अपने ऐप्लिकेशन का APK और टेस्ट का APK, Firebase पर अपलोड करना होगा.

(ज़रूरी नहीं) अपने ऐप्लिकेशन में स्क्रीनशॉट लाइब्रेरी जोड़ना

Firebase Test Lab में एक लाइब्रेरी (testlab-instr-lib) शामिल है. इसका इस्तेमाल, इंस्ट्रुमेंटेशन टेस्ट चलाते समय AndroidX के ScreenCapture की मदद से लिए गए किसी भी स्क्रीनशॉट को प्रोसेस करने के लिए किया जा सकता है. जैसे, Espresso test framework का इस्तेमाल करके लिखे गए टेस्ट. इस सेक्शन में, AndroidX लाइब्रेरी की मदद से ScreenCapture ऑब्जेक्ट बनाने का तरीका बताया गया है. साथ ही, testlab-instr-lib का इस्तेमाल करके उन्हें प्रोसेस करने का तरीका भी बताया गया है.

इंस्ट्रुमेंटेशन टेस्ट पूरा होने के बाद, कैप्चर की गई स्क्रीनशॉट को Firebase कंसोल में देखा जा सकता है.

सैंपल ऐप्लिकेशन आज़माकर देखें

इस सुविधा को आज़माने के लिए, NotePad का सैंपल ऐप्लिकेशन डाउनलोड करें. स्क्रीनशॉट लेने की सुविधा, NotePad प्रोजेक्ट में पहले से ही शामिल है.

पहला चरण. अपने प्रोजेक्ट में स्क्रीनशॉट लाइब्रेरी जोड़ना

अपने टेस्ट प्रोजेक्ट की रूट-लेवल की सेटिंग वाली Gradle फ़ाइल (settings.gradle.kts या settings.gradle) में, हर repositories सेक्शन में Google की Maven रिपॉज़िटरी जोड़ें:

pluginManagement {
    repositories {
        // Add the following line:
        google() // Google's Maven repository
        mavenCentral()
        gradlePluginPortal()
    }
}
dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        // Add the following line:
        google() // Google's Maven repository
        mavenCentral()
    }
}
// ...

अपनी मॉड्यूल (ऐप्लिकेशन-लेवल) Gradle फ़ाइल में, Test Lab स्क्रीनशॉट लाइब्रेरी के लिए डिपेंडेंसी जोड़ें. यह फ़ाइल आम तौर पर <project>/<app-module>/build.gradle.kts या <project>/<app-module>/build.gradle होती है.
```
dependencies {
  // ...
  // Add Test Lab's instrumentation test screenshot library:
  androidTestImplementation("com.google.firebase:testlab-instr-lib:0.2")
  // ...
```
अपनी जांच की AndroidManifest.xml फ़ाइल में, <instrumentation> एलिमेंट के मेटा-डेटा टैग में FirebaseScreenCaptureProcessor रजिस्टर करें. इसके अलावा, AndroidJUnitRunner में प्रोसेसर को आर्ग्युमेंट के तौर पर भी तय किया जा सकता है. इसके बारे में जानने के लिए, AndroidJUnitRunner के रेफ़रंस दस्तावेज़ देखें.
```
<instrumentation
  // Check that you have the following line (if not, add it):
  android:name="androidx.test.runner.AndroidJUnitRunner" // Specifies AndroidJUnitRunner as the test runner
  android:targetPackage="com.your.package.name">

// Add the following:
<meta-data
  android:name="screenCaptureProcessors"
  android:value="com.google.firebase.testlab.screenshot.FirebaseScreenCaptureProcessor" />
</instrumentation>
...
```
अपने ऐप्लिकेशन की AndroidManifest.xml फ़ाइल में, <manifest> एलिमेंट में ये लाइनें जोड़ें:
```
 <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
```
अपनी AndroidManifest.xml फ़ाइल में, अपने ऐप्लिकेशन के लिए सिस्टम अनुमतियां तय करें. इसके लिए, <manifest> टैग में ये लाइनें जोड़ें. अगर आपको Android 10 (एपीआई लेवल 29) या उसके बाद के वर्शन पर टेस्टिंग करनी है, तो WRITE_EXTERNAL_STORAGE अनुमति को छोड़ दें. डिवाइस पर स्क्रीनशॉट पढ़ने और लिखने के लिए, आपके ऐप्लिकेशन को इस अनुमति की ज़रूरत नहीं होती.
```
<manifest ... >
    
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
    <uses-permission android:name="android.permission.INTERNET"/>
    ...
</manifest>
```

दूसरा चरण. परीक्षा के दौरान स्क्रीनशॉट लेना

जांच के दौरान किसी भी समय स्क्रीनशॉट लेने के लिए, AndroidX लाइब्रेरी से Screenshot.capture() तरीके को कॉल करें. इससे ScreenCapture ऑब्जेक्ट जनरेट होता है. ScreenCapture ऑब्जेक्ट पर process() को कॉल करने पर, इसे ScreenCaptureProcessor का इस्तेमाल करके प्रोसेस किया जाता है. यह AndroidManifest.xml में रजिस्टर होता है. ध्यान दें कि अगर कोई प्रोसेसर रजिस्टर नहीं किया गया है, तो BasicScreenCaptureProcessor का इस्तेमाल किया जाता है. आपने FirebaseScreenCaptureProcessor के लिए रजिस्टर किया है. इसलिए, आपके स्क्रीनशॉट FirebaseScreenCaptureProcessor के ज़रिए प्रोसेस किए जाएंगे. साथ ही, जब Firebase Test Lab की मदद से टेस्ट चलाया जाएगा, तब ये स्क्रीनशॉट आपको नतीजों के साथ उपलब्ध होंगे.

`ScreenCapture` बनाने के लिए, इस्तेमाल के उदाहरण:

API Build.VERSION_CODES.JELLY_BEAN_MR2 और इसके बाद के वर्शन पर, पूरी स्क्रीन का स्क्रीनशॉट लेने के लिए:
```
Screenshot.capture()
```
किसी भी एपीआई लेवल पर, गतिविधि का ScreenCapture लें. ध्यान दें कि Build.VERSION_CODES.JELLY_BEAN_MR2 से नीचे के वर्शन वाले डिवाइसों के लिए, यह एकमात्र विकल्प है.
```
@Rule
  public ActivityTestRule<MainActivity> activityRule = new ActivityTestRule<>(MainActivity.class);
...
Screenshot.capture(activityRule.getActivity());
...
```

ScreenCapture को प्रोसेस करने के लिए, इस्तेमाल के उदाहरण

FirebaseScreenCaptureProcessor के ज़रिए ScreenCapture को प्रोसेस करें:
```
Screenshot.capture().process();
```
किसी तय किए गए ScreenCaptureProcessor के ज़रिए ScreenCapture को प्रोसेस करें (इससे आपको प्रोसेसर को रजिस्टर करने की ज़रूरत नहीं पड़ती):
```
Set<ScreenCaptureProcessor> processors = new HashSet<>();
processors.add(new FirebaseScreenCaptureProcessor());
Screenshot.capture().process(processors);
```
ScreenCapture का नाम और फ़ॉर्मैट सेट करें. साथ ही, रजिस्टर किए गए प्रोसेसर का इस्तेमाल करके इसे प्रोसेस करें:
```
Screenshot.capture().setName("myscreenshot").setFormat(CompressFormat.JPEG).process();
```

चरण 3. टेस्ट बनाना और उसे चलाना

अपना ऐप्लिकेशन बनाएं और APK की जांच करें. निर्देशों के लिए, अपने ऐप्लिकेशन की जांच करना लेख पढ़ें.
APK फ़ाइलों को Firebase कंसोल के Test Lab डैशबोर्ड पर अपलोड करें.
आखिर में, अपना टेस्ट चलाएं.

चौथा चरण. टेस्ट के स्क्रीनशॉट देखना

टेस्ट पूरा होने के बाद, Firebase कंसोल में लिए गए सभी स्क्रीनशॉट देखे जा सकते हैं.

टेस्ट टैब में जाकर, पूरा हो चुका टेस्ट चुनें. इसके बाद, नतीजे टैब पर क्लिक करें.
अपनी जांच को फिर से चुनें. इसके बाद, दिखने वाले स्क्रीनशॉट टैब पर क्लिक करें.

(वैकल्पिक) टेस्ट की अन्य सुविधाएं चालू करना

Test Lab के साथ टेस्ट चलाने से पहले, टेस्ट में ये सुविधाएं चालू की जा सकती हैं:

ऑर्केस्ट्रेटर चालू करना

Android Test Orchestrator एक ऐसा टूल है जो आपके ऐप्लिकेशन के हर इंस्ट्रुमेंटेशन टेस्ट को अलग-अलग चलाता है. Test Lab हमेशा Orchestrator के नए वर्शन का इस्तेमाल करता है.

Test Lab के लिए Orchestrator को चालू करने के लिए, इंस्ट्रुमेंटेशन टेस्ट सेटअप में जाकर,ज़्यादा विकल्प > Orchestrator के साथ चलाएं पर क्लिक करें.

चेतावनी: खराबी वाली जांचों पर कोटा खर्च होने या उनके लिए बिल मिलने से बचने के लिए, Test Lab में इसे आज़माने से पहले, Orchestrator को स्थानीय तौर पर चलाएं. पुष्टि करें कि Orchestrator आपके ऐप्लिकेशन में काम कर रहा है. इसके लिए, अपना APK अपलोड करने से पहले, अपनी मशीन पर एक टेस्ट चलाएं. ध्यान रखें कि Orchestrator के साथ टेस्टिंग करने में, इसके बिना टेस्टिंग करने की तुलना में थोड़ा ज़्यादा समय लगता है. इससे आपकी बिलिंग पर असर पड़ सकता है या आपकी जांचें टाइम आउट की सीमा से ज़्यादा हो सकती हैं.

Orchestrator का इस्तेमाल करने पर, आपको ये फ़ायदे मिलते हैं:

शेयर की गई कोई स्थिति नहीं है. हर टेस्ट, अपने इंस्ट्रुमेंटेशन इंस्टेंस में चलता है. इसलिए, टेस्ट के दौरान शेयर की गई स्थिति, सभी टेस्ट में एक जैसी नहीं होती.
कुछ ही क्रैश हुए हैं. अगर कोई टेस्ट क्रैश होता है, तो सिर्फ़ उस इंस्ट्रूमेंटेशन को बंद किया जाता है. हालांकि, आपके सुइट में मौजूद अन्य टेस्ट अब भी चल सकते हैं.

ध्यान रखें कि Orchestrator का इस्तेमाल करने पर, हर टेस्ट अपना इंस्ट्रूमेंटेशन इंस्टेंस चलाता है. इसका मतलब है कि हर टेस्ट केस के बाद, ऐप्लिकेशन प्रोसेस रीस्टार्ट हो जाती है. इससे, रन टाइम बढ़ सकता है. इसका असर कोटा के इस्तेमाल या बिल किए गए समय पर पड़ सकता है. साथ ही, इससे डिवाइसों के टाइम आउट होने की सीमाएं भी पार हो सकती हैं. अगर ऐप्लिकेशन के स्टार्टअप में लगने वाले समय को कम किया जाता है, तो यह ओवरहेड कम हो जाएगा.

Orchestrator के लिए अतिरिक्त विकल्प सेट करने के लिए, उन्हें environmentVariables फ़ील्ड के ज़रिए तय करें. उदाहरण के लिए, clearPackageData का इस्तेमाल करने के लिए, gcloud में इस विकल्प का इस्तेमाल करें:

--environment-variables clearPackageData=true

शार्डिंग की सुविधा चालू करना

टेस्ट शार्डिंग, टेस्ट के सेट को सब-ग्रुप (शार्ड) में बांटती है. ये शार्ड, अलग-अलग और आइसोलेशन में चलते हैं. Test Lab कई डिवाइसों का इस्तेमाल करके, हर शार्ड को एक साथ अपने-आप चलाता है. इससे टेस्ट का पूरा सेट कम समय में पूरा हो जाता है.

उदाहरण के लिए, अगर आपने N शार्ड बनाए हैं, तो चुने गए हर डिवाइस के लिए, Test Lab N एक जैसे डिवाइस बनाता है. साथ ही, हर डिवाइस पर टेस्ट का सबसेट चलाता है. इसका मतलब है कि शार्ड किए गए टेस्ट केस से, हर डिवाइस पर कई टेस्ट एग्ज़ीक्यूशन हो सकते हैं. हालांकि, नॉन-शार्ड किए गए टेस्ट केस से, हर डिवाइस पर एक टेस्ट एक्ज़ीक्यूशन होता है. Test Lab के कॉन्सेप्ट के बारे में जानने के लिए, मुख्य कॉन्सेप्ट देखें.

Firebase कंसोल में टेस्ट शार्डिंग की सुविधा चालू करने के लिए, यह तरीका अपनाएं:

इंस्ट्रुमेंटेशन टेस्ट सेटअप में जाकर,ज़्यादा विकल्प पर क्लिक करें.
शार्डिंग सेक्शन में जाकर, शार्ड की वह संख्या डालें जिसे आपको चलाना है.

टेस्ट शार्ड के लिए बिलिंग

Test Lab, AndroidJUnitRunner के बिल्ट-इन शार्डिंग मेकेनिज़्म का इस्तेमाल करके, आपके शार्ड लागू करता है. खाली शार्ड (ऐसे शार्ड जिनमें टेस्ट केस असाइन नहीं किए गए हैं) के लिए शुल्क से बचने के लिए, बनाए गए शार्ड की संख्या, टेस्ट केस की कुल संख्या से कम होनी चाहिए. हर टेस्ट केस को पूरा होने में कितना समय लगता है, इसके आधार पर हर शार्ड को आम तौर पर 2 से 10 टेस्ट केस असाइन करना सही होता है.

चेतावनी: शार्डिंग टेस्ट की लागत ज़्यादा हो सकती है. टेस्ट शार्डिंग की मदद से, सभी टेस्ट को पूरा होने में लगने वाला समय कम हो जाता है. हालांकि, हर शार्ड पर ऐप्लिकेशन को शुरू करने में लगने वाला समय बढ़ने से, हर डिवाइस पर टेस्ट पूरा होने में लगने वाला समय बढ़ सकता है. हर शार्ड के लिए शुल्क, प्रति मिनट के हिसाब से कैलकुलेट किया जाता है. इसलिए, आपके कुल शुल्क में बढ़ोतरी हो सकती है. इसके अलावा, टेस्ट के एक्ज़ीक्यूशन के लिए, शार्ड को आपके रोज़ के कोटे में गिना जाता है.

बिलिंग के बारे में ज़्यादा जानने के लिए, इस्तेमाल, कोटा, और बिलिंग लेख पढ़ें.