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

UI Automator का इस्तेमाल करके ऑटोमेटेड टेस्ट लिखना (लेगसी गाइडेंस)

UI Automator, यूज़र इंटरफ़ेस (यूआई) की टेस्टिंग के लिए एक फ़्रेमवर्क है. यह सिस्टम और इंस्टॉल किए गए ऐप्लिकेशन में, अलग-अलग ऐप्लिकेशन के फ़ंक्शनल यूज़र इंटरफ़ेस (यूआई) की टेस्टिंग के लिए सही है. UI Automator API की मदद से, डिवाइस पर दिखने वाले एलिमेंट के साथ इंटरैक्ट किया जा सकता है. इससे कोई फ़र्क़ नहीं पड़ता कि फ़ोकस में कौनसी Activity है. इसलिए, इसकी मदद से टेस्ट डिवाइस में सेटिंग मेन्यू या ऐप्लिकेशन लॉन्चर खोलने जैसे ऑपरेशन किए जा सकते हैं. आपका टेस्ट, यूज़र इंटरफ़ेस (यूआई) कॉम्पोनेंट को ढूंढ सकता है. इसके लिए, कॉम्पोनेंट में दिखने वाले टेक्स्ट या उसके कॉन्टेंट के ब्यौरे जैसे डिस्क्रिप्टर का इस्तेमाल किया जा सकता है.

UI Automator टेस्टिंग फ़्रेमवर्क, इंस्ट्रुमेंटेशन पर आधारित एपीआई है. यह AndroidJUnitRunner टेस्ट रनर के साथ काम करता है. यह ओपेक बॉक्स-स्टाइल वाली अपने-आप होने वाली जांच लिखने के लिए सबसे सही है. इसमें टेस्ट कोड, टारगेट ऐप्लिकेशन के इंटरनल इंप्लीमेंटेशन की जानकारी पर निर्भर नहीं करता.

UI Automator टेस्टिंग फ़्रेमवर्क की मुख्य सुविधाएं ये हैं:

यह एपीआई, टारगेट डिवाइस की स्थिति की जानकारी पाने और उस पर कार्रवाइयां करने के लिए होता है. ज़्यादा जानकारी के लिए, डिवाइस की स्थिति को ऐक्सेस करना लेख पढ़ें.
ऐसे एपीआई जो क्रॉस-ऐप्लिकेशन यूज़र इंटरफ़ेस (यूआई) टेस्टिंग के साथ काम करते हैं. ज़्यादा जानकारी के लिए, UI Automator API देखें.

डिवाइस की स्थिति को ऐक्सेस करना

UI Automator टेस्टिंग फ़्रेमवर्क, UiDevice क्लास उपलब्ध कराता है. इससे उस डिवाइस को ऐक्सेस किया जा सकता है जिस पर टारगेट ऐप्लिकेशन चल रहा है. साथ ही, उस डिवाइस पर कार्रवाइयां की जा सकती हैं. डिवाइस की प्रॉपर्टी ऐक्सेस करने के लिए, इसके तरीकों को कॉल किया जा सकता है. जैसे, मौजूदा ओरिएंटेशन या डिसप्ले का साइज़. UiDevice क्लास की मदद से, ये कार्रवाइयां भी की जा सकती हैं:

डिवाइस को घुमाएं.
हार्डवेयर बटन दबाएं, जैसे कि "आवाज़ बढ़ाओ" बटन.
'वापस जाएं', 'होम' या 'मेन्यू' बटन दबाएं.
नोटिफ़िकेशन शेड खोलें.
मौजूदा विंडो का स्क्रीनशॉट लें.

उदाहरण के लिए, होम बटन दबाने की कार्रवाई को सिम्युलेट करने के लिए, UiDevice.pressHome() तरीके को कॉल करें.

UI Automator API

UI Automator API की मदद से, मज़बूत टेस्ट लिखे जा सकते हैं. इसके लिए, आपको टारगेट किए जा रहे ऐप्लिकेशन के लागू करने से जुड़ी जानकारी के बारे में जानने की ज़रूरत नहीं होती. इन एपीआई का इस्तेमाल करके, एक से ज़्यादा ऐप्लिकेशन में यूज़र इंटरफ़ेस (यूआई) कॉम्पोनेंट को कैप्चर और उनमें बदलाव किया जा सकता है:

UiObject2: इससे यूज़र इंटरफ़ेस (यूआई) के उस एलिमेंट के बारे में पता चलता है जो डिवाइस पर दिखता है.
BySelector: इससे यूज़र इंटरफ़ेस (यूआई) एलिमेंट को मैच करने की शर्तें तय की जाती हैं.
By: BySelector को कम शब्दों में बनाता है.
Configurator: इससे आपको UI Automator टेस्ट चलाने के लिए मुख्य पैरामीटर सेट करने की सुविधा मिलती है.

उदाहरण के लिए, यहाँ दिए गए कोड में दिखाया गया है कि डिवाइस में Gmail ऐप्लिकेशन खोलने वाली टेस्ट स्क्रिप्ट कैसे लिखी जा सकती है:

Kotlin

device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())
device.pressHome()

val gmail: UiObject2 = device.findObject(By.text("Gmail"))
// Perform a click and wait until the app is opened.
val opened: Boolean = gmail.clickAndWait(Until.newWindow(), 3000)
assertThat(opened).isTrue()

Java

device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation());
device.pressHome();

UiObject2 gmail = device.findObject(By.text("Gmail"));
// Perform a click and wait until the app is opened.
Boolean opened = gmail.clickAndWait(Until.newWindow(), 3000);
assertTrue(opened);

UI Automator सेट अप करना

UI Automator की मदद से यूज़र इंटरफ़ेस (यूआई) टेस्ट बनाने से पहले, पक्का करें कि आपने टेस्ट के सोर्स कोड की जगह और प्रोजेक्ट की डिपेंडेंसी कॉन्फ़िगर कर ली हों. इसके लिए, AndroidX Test के लिए प्रोजेक्ट सेट अप करना लेख पढ़ें.

आपको अपने Android ऐप्लिकेशन मॉड्यूल की build.gradle फ़ाइल में, UI Automator लाइब्रेरी के लिए डिपेंडेंसी रेफ़रंस सेट करना होगा:

Kotlin

dependencies { ... androidTestImplementation("androidx.test.uiautomator:uiautomator:2.3.0") }

Groovy

dependencies { ... androidTestImplementation "androidx.test.uiautomator:uiautomator:2.3.0" }

UI Automator की टेस्टिंग को ऑप्टिमाइज़ करने के लिए, आपको सबसे पहले टारगेट ऐप्लिकेशन के यूज़र इंटरफ़ेस (यूआई) कॉम्पोनेंट की जांच करनी चाहिए. साथ ही, यह पक्का करना चाहिए कि उन्हें ऐक्सेस किया जा सकता हो. ऑप्टिमाइज़ेशन से जुड़ी इन सलाह के बारे में, अगले दो सेक्शन में बताया गया है.

किसी डिवाइस पर यूज़र इंटरफ़ेस (यूआई) की जांच करना

टेस्ट डिज़ाइन करने से पहले, डिवाइस पर दिखने वाले यूज़र इंटरफ़ेस (यूआई) कॉम्पोनेंट की जांच करें. यह पक्का करने के लिए कि आपके UI Automator टेस्ट इन कॉम्पोनेंट को ऐक्सेस कर सकें, जांच करें कि इन कॉम्पोनेंट में दिखने वाले टेक्स्ट लेबल, android:contentDescription वैल्यू या दोनों मौजूद हों.

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

uiautomatorviewer टूल लॉन्च करने के लिए:

किसी फ़िज़िकल डिवाइस पर टारगेट ऐप्लिकेशन लॉन्च करें.
डिवाइस को अपनी डेवलपमेंट मशीन से कनेक्ट करें.
कोई टर्मिनल विंडो खोलें और <android-sdk>/tools/ डायरेक्ट्री पर जाएं.
इस निर्देश की मदद से टूल चलाएं:

 $ uiautomatorviewer

अपने ऐप्लिकेशन के लिए यूज़र इंटरफ़ेस (यूआई) प्रॉपर्टी देखने के लिए:

uiautomatorviewer इंटरफ़ेस में, डिवाइस का स्क्रीनशॉट बटन पर क्लिक करें.
बाईं ओर मौजूद पैनल में स्नैपशॉट पर कर्सर घुमाकर, uiautomatorviewer टूल से पहचाने गए यूज़र इंटरफ़ेस (यूआई) कॉम्पोनेंट देखें. प्रॉपर्टी, नीचे दिए गए दाएं पैनल में दिखती हैं. साथ ही, लेआउट का क्रम ऊपर दिए गए दाएं पैनल में दिखता है.
इसके अलावा, एनएएफ़ नोड टॉगल करें बटन पर क्लिक करके, ऐसे यूज़र इंटरफ़ेस (यूआई) कॉम्पोनेंट देखें जिन्हें यूज़र इंटरफ़ेस (यूआई) ऑटोमेटर ऐक्सेस नहीं कर सकता. इन कॉम्पोनेंट के लिए, सिर्फ़ सीमित जानकारी उपलब्ध हो सकती है.

Android की ओर से उपलब्ध कराए गए यूज़र इंटरफ़ेस (यूआई) के कॉम्पोनेंट के बारे में जानने के लिए, यूज़र इंटरफ़ेस देखें.

पक्का करें कि आपकी गतिविधि को ऐक्सेस किया जा सकता हो

यूआई ऑटोमेटर टेस्ट फ़्रेमवर्क, उन ऐप्लिकेशन पर बेहतर तरीके से काम करता है जिनमें Android की सुलभता सुविधाएं लागू की गई हैं. View टाइप के यूज़र इंटरफ़ेस एलिमेंट या SDK टूल से View की सबक्लास का इस्तेमाल करने पर, आपको ऐक्सेसिबिलिटी की सुविधा लागू करने की ज़रूरत नहीं होती. ऐसा इसलिए, क्योंकि इन क्लास में यह सुविधा पहले से मौजूद होती है.

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

ExploreByTouchHelper को एक्सटेंड करने वाली एक कॉन्क्रीट क्लास बनाएं.
setAccessibilityDelegate() को कॉल करके, अपनी नई क्लास के इंस्टेंस को किसी कस्टम यूज़र इंटरफ़ेस (यूआई) एलिमेंट से जोड़ें.

कस्टम व्यू एलिमेंट में सुलभता सुविधाएं जोड़ने के बारे में ज़्यादा जानकारी के लिए, सुलभ कस्टम व्यू बनाना लेख पढ़ें. Android पर ऐक्सेसिबिलिटी के लिए, सबसे सही तरीकों के बारे में ज़्यादा जानने के लिए, ऐप्लिकेशन को ज़्यादा सुलभ बनाना लेख पढ़ें.

UI Automator टेस्ट क्लास बनाना

UI Automator टेस्ट क्लास को JUnit 4 टेस्ट क्लास की तरह ही लिखा जाना चाहिए. JUnit 4 टेस्ट क्लास बनाने और JUnit 4 assertions और एनोटेशन का इस्तेमाल करने के बारे में ज़्यादा जानने के लिए, इंस्ट्रुमेंटेड यूनिट टेस्ट क्लास बनाना लेख पढ़ें.

अपनी टेस्ट क्लास की परिभाषा की शुरुआत में, @RunWith(AndroidJUnit4.class) एनोटेशन जोड़ें. आपको AndroidX Test में उपलब्ध AndroidJUnitRunner क्लास को डिफ़ॉल्ट टेस्ट रनर के तौर पर भी सेट करना होगा. इस चरण के बारे में ज़्यादा जानकारी, डिवाइस या एम्युलेटर पर यूज़र इंटरफ़ेस (यूआई) ऑटोमेटर टेस्ट चलाना लेख में दी गई है.

अपनी UI Automator टेस्ट क्लास में, इस प्रोग्रामिंग मॉडल को लागू करें:

जिस डिवाइस पर आपको जांच करनी है उसे ऐक्सेस करने के लिए, UiDevice ऑब्जेक्ट पाएं. इसके लिए, getInstance() मैथड को कॉल करें और उसे Instrumentation ऑब्जेक्ट को आर्ग्युमेंट के तौर पर पास करें.
UiObject2 ऑब्जेक्ट पाएं, ताकि डिवाइस पर दिखने वाले यूज़र इंटरफ़ेस (यूआई) कॉम्पोनेंट को ऐक्सेस किया जा सके. उदाहरण के लिए, फ़ोरग्राउंड में मौजूद मौजूदा व्यू. इसके लिए, findObject() मेथड को कॉल करें.
यूज़र इंटरफ़ेस (यूआई) के उस कॉम्पोनेंट पर उपयोगकर्ता के किसी इंटरैक्शन को सिम्युलेट करें. इसके लिए, UiObject2 मेथड को कॉल करें. उदाहरण के लिए, स्क्रोल करने के लिए scrollUntil() को कॉल करें और टेक्स्ट फ़ील्ड में बदलाव करने के लिए setText() को कॉल करें. ज़्यादा जटिल उपयोगकर्ता इंटरैक्शन की जांच करने के लिए, चरण 2 और 3 में दिए गए एपीआई को ज़रूरत के हिसाब से बार-बार कॉल किया जा सकता है. इन इंटरैक्शन में कई यूज़र इंटरफ़ेस कॉम्पोनेंट या उपयोगकर्ता कार्रवाइयों के क्रम शामिल होते हैं.
जांच करें कि उपयोगकर्ता के इन इंटरैक्शन के बाद, यूज़र इंटरफ़ेस (यूआई) में उम्मीद के मुताबिक स्थिति या व्यवहार दिख रहा है या नहीं.

इन चरणों के बारे में ज़्यादा जानकारी, यहां दिए गए सेक्शन में दी गई है.

यूज़र इंटरफ़ेस (यूआई) कॉम्पोनेंट ऐक्सेस करना

UiDevice ऑब्जेक्ट, डिवाइस की स्थिति को ऐक्सेस और उसमें बदलाव करने का मुख्य तरीका है. अपने टेस्ट में, UiDevice के तरीकों का इस्तेमाल करके, अलग-अलग प्रॉपर्टी की स्थिति की जांच की जा सकती है. जैसे, मौजूदा ओरिएंटेशन या डिसप्ले का साइज़. आपका टेस्ट, डिवाइस-लेवल की कार्रवाइयां करने के लिए UiDevice ऑब्जेक्ट का इस्तेमाल कर सकता है. जैसे, डिवाइस को किसी खास रोटेशन में ले जाना, डी-पैड हार्डवेयर बटन दबाना, और होम और मेन्यू बटन दबाना.

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

नीचे दिए गए कोड स्निपेट में बताया गया है कि आपका टेस्ट, UiDevice का इंस्टेंस कैसे पा सकता है और होम बटन दबाने की प्रोसेस को कैसे सिम्युलेट कर सकता है:

Kotlin

import org.junit.Before
import androidx.test.runner.AndroidJUnit4
import androidx.test.uiautomator.UiDevice
import androidx.test.uiautomator.By
import androidx.test.uiautomator.Until
...

private const val BASIC_SAMPLE_PACKAGE = "com.example.android.testing.uiautomator.BasicSample"
private const val LAUNCH_TIMEOUT = 5000L
private const val STRING_TO_BE_TYPED = "UiAutomator"

@RunWith(AndroidJUnit4::class)
@SdkSuppress(minSdkVersion = 18)
class ChangeTextBehaviorTest2 {

private lateinit var device: UiDevice

@Before
fun startMainActivityFromHomeScreen() {
  // Initialize UiDevice instance
  device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())

  // Start from the home screen
  device.pressHome()

  // Wait for launcher
  val launcherPackage: String = device.launcherPackageName
  assertThat(launcherPackage, notNullValue())
  device.wait(
    Until.hasObject(By.pkg(launcherPackage).depth(0)),
    LAUNCH_TIMEOUT
  )

  // Launch the app
  val context = ApplicationProvider.getApplicationContext<Context>()
  val intent = context.packageManager.getLaunchIntentForPackage(
  BASIC_SAMPLE_PACKAGE).apply {
    // Clear out any previous instances
    addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK)
  }
  context.startActivity(intent)

  // Wait for the app to appear
  device.wait(
    Until.hasObject(By.pkg(BASIC_SAMPLE_PACKAGE).depth(0)),
    LAUNCH_TIMEOUT
    )
  }
}

Java

import org.junit.Before;
import androidx.test.runner.AndroidJUnit4;
import androidx.test.uiautomator.UiDevice;
import androidx.test.uiautomator.By;
import androidx.test.uiautomator.Until;
...

@RunWith(AndroidJUnit4.class)
@SdkSuppress(minSdkVersion = 18)
public class ChangeTextBehaviorTest {

  private static final String BASIC_SAMPLE_PACKAGE
  = "com.example.android.testing.uiautomator.BasicSample";
  private static final int LAUNCH_TIMEOUT = 5000;
  private static final String STRING_TO_BE_TYPED = "UiAutomator";
  private UiDevice device;

  @Before
  public void startMainActivityFromHomeScreen() {
    // Initialize UiDevice instance
    device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation());

    // Start from the home screen
    device.pressHome();

    // Wait for launcher
    final String launcherPackage = device.getLauncherPackageName();
    assertThat(launcherPackage, notNullValue());
    device.wait(Until.hasObject(By.pkg(launcherPackage).depth(0)),
    LAUNCH_TIMEOUT);

    // Launch the app
    Context context = ApplicationProvider.getApplicationContext();
    final Intent intent = context.getPackageManager()
    .getLaunchIntentForPackage(BASIC_SAMPLE_PACKAGE);
    // Clear out any previous instances
    intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);
    context.startActivity(intent);

    // Wait for the app to appear
    device.wait(Until.hasObject(By.pkg(BASIC_SAMPLE_PACKAGE).depth(0)),
    LAUNCH_TIMEOUT);
    }
}

उदाहरण में, @SdkSuppress(minSdkVersion = 18) स्टेटमेंट से यह पक्का करने में मदद मिलती है कि टेस्ट सिर्फ़ Android 4.3 (एपीआई लेवल 18) या इसके बाद के वर्शन वाले डिवाइसों पर चलेंगे. ऐसा इसलिए, क्योंकि UI Automator फ़्रेमवर्क के लिए यह ज़रूरी है.

findObject() तरीके का इस्तेमाल करके, UiObject2 को वापस पाएं. यह UiObject2, व्यू को दिखाता है, जो दिए गए सिलेक्टर की शर्तों से मेल खाता है. ज़रूरत के मुताबिक, UiObject2 उन इंस्टेंस का फिर से इस्तेमाल किया जा सकता है जिन्हें आपने ऐप्लिकेशन की टेस्टिंग के दूसरे हिस्सों में बनाया है. ध्यान दें कि UI Automator टेस्ट फ़्रेमवर्क, मौजूदा डिसप्ले में हर बार मैच ढूंढता है. ऐसा तब होता है, जब आपका टेस्ट, यूज़र इंटरफ़ेस (यूआई) एलिमेंट पर क्लिक करने या किसी प्रॉपर्टी के बारे में क्वेरी करने के लिए, UiObject2 इंस्टेंस का इस्तेमाल करता है.

यहां दिए गए स्निपेट में बताया गया है कि आपका टेस्ट, ऐप्लिकेशन में 'रद्द करें' बटन और 'ठीक है' बटन को दिखाने वाले UiObject2 इंस्टेंस कैसे बना सकता है.

Kotlin

val okButton: UiObject2 = device.findObject(
    By.text("OK").clazz("android.widget.Button")
)

// Simulate a user-click on the OK button, if found.
if (okButton != null) {
    okButton.click()
}

Java

UiObject2 okButton = device.findObject(
    By.text("OK").clazz("android.widget.Button")
);

// Simulate a user-click on the OK button, if found.
if (okButton != null) {
    okButton.click();
}

कोई सिलेक्टर तय करना

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

अगर एक से ज़्यादा मैचिंग एलिमेंट मिलते हैं, तो लेआउट हैरारकी में मौजूद पहले मैचिंग एलिमेंट को टारगेट UiObject2 के तौर पर दिखाया जाता है. BySelector बनाते समय, अपनी खोज को बेहतर बनाने के लिए एक साथ कई प्रॉपर्टी जोड़ी जा सकती हैं. अगर मेल खाने वाला कोई यूज़र इंटरफ़ेस (यूआई) एलिमेंट नहीं मिलता है, तो null दिखता है.

एक से ज़्यादा BySelector इंस्टेंस को नेस्ट करने के लिए, hasChild() या hasDescendant() तरीके का इस्तेमाल किया जा सकता है. उदाहरण के लिए, यहां दिए गए कोड के उदाहरण में दिखाया गया है कि आपका टेस्ट, टेक्स्ट प्रॉपर्टी वाले चाइल्ड यूज़र इंटरफ़ेस (यूआई) एलिमेंट वाले पहले ListView को ढूंढने के लिए, खोज को कैसे तय कर सकता है.

Kotlin

val listView: UiObject2 = device.findObject(
    By.clazz("android.widget.ListView")
        .hasChild(
            By.text("Apps")
        )
)

Java

UiObject2 listView = device.findObject(
    By.clazz("android.widget.ListView")
        .hasChild(
            By.text("Apps")
        )
);

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

कार्रवाइयां पूरी करें

जब आपके टेस्ट को UiObject2 ऑब्जेक्ट मिल जाता है, तब UiObject2 क्लास में मौजूद तरीकों को कॉल किया जा सकता है. इससे, उस ऑब्जेक्ट से दिखाए गए यूज़र इंटरफ़ेस (यूआई) कॉम्पोनेंट पर उपयोगकर्ता के इंटरैक्शन किए जा सकते हैं. इन कार्रवाइयों को इस तरह से तय किया जा सकता है:

click() : यूज़र इंटरफ़ेस (यूआई) एलिमेंट के दिखने वाले बाउंड के बीच में क्लिक करता है.
drag() : इस ऑब्जेक्ट को किसी भी कोऑर्डिनेट पर ले जाता है.
setText() : इससे बदलाव किए जा सकने वाले फ़ील्ड में टेक्स्ट सेट किया जाता है. हालांकि, इससे पहले फ़ील्ड का कॉन्टेंट मिटा दिया जाता है. इसके उलट, clear() तरीके से, बदलाव किए जा सकने वाले फ़ील्ड में मौजूद टेक्स्ट मिट जाता है.
swipe() : इससे स्वाइप करने की कार्रवाई, तय की गई दिशा में होती है.
scrollUntil(): यह तय की गई दिशा में स्क्रोल करता है. यह तब तक स्क्रोल करता है, जब तक Condition या EventCondition की शर्त पूरी नहीं हो जाती.

यूआई ऑटोमेटर टेस्टिंग फ़्रेमवर्क की मदद से, शेल कमांड का इस्तेमाल किए बिना Intent भेजा जा सकता है या Activity लॉन्च की जा सकती है. इसके लिए, getContext() के ज़रिए Context ऑब्जेक्ट पाना होता है.

यहां दिए गए स्निपेट में बताया गया है कि आपका टेस्ट, Intent का इस्तेमाल करके, टेस्ट किए जा रहे ऐप्लिकेशन को कैसे लॉन्च कर सकता है. यह तरीका तब काम आता है, जब आपको सिर्फ़ कैलकुलेटर ऐप्लिकेशन की टेस्टिंग करनी हो और आपको लॉन्चर से कोई मतलब न हो.

Kotlin

fun setUp() {
...

  // Launch a simple calculator app
  val context = getInstrumentation().context
  val intent = context.packageManager.getLaunchIntentForPackage(CALC_PACKAGE).apply {
    addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK)
  }
  // Clear out any previous instances
  context.startActivity(intent)
  device.wait(Until.hasObject(By.pkg(CALC_PACKAGE).depth(0)), TIMEOUT)
}

Java

public void setUp() {
...

  // Launch a simple calculator app
  Context context = getInstrumentation().getContext();
  Intent intent = context.getPackageManager()
  .getLaunchIntentForPackage(CALC_PACKAGE);
  intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK);

  // Clear out any previous instances
  context.startActivity(intent);
  device.wait(Until.hasObject(By.pkg(CALC_PACKAGE).depth(0)), TIMEOUT);
}

नतीजों की पुष्टि करना

InstrumentationTestCase, TestCase को बढ़ाता है. इसलिए, ऐप्लिकेशन में यूज़र इंटरफ़ेस (यूआई) कॉम्पोनेंट से उम्मीद के मुताबिक नतीजे मिलते हैं या नहीं, यह जांचने के लिए स्टैंडर्ड JUnit Assert तरीकों का इस्तेमाल किया जा सकता है.

इस स्निपेट में दिखाया गया है कि आपका टेस्ट, कैलकुलेटर ऐप्लिकेशन में कई बटन कैसे ढूंढ सकता है. साथ ही, यह भी दिखाया गया है कि उन पर क्रम से क्लिक कैसे किया जा सकता है. इसके बाद, यह पुष्टि कैसे की जा सकती है कि सही नतीजा दिख रहा है.

Kotlin

private const val CALC_PACKAGE = "com.myexample.calc"

fun testTwoPlusThreeEqualsFive() {
  // Enter an equation: 2 + 3 = ?
  device.findObject(By.res(CALC_PACKAGE, "two")).click()
  device.findObject(By.res(CALC_PACKAGE, "plus")).click()
  device.findObject(By.res(CALC_PACKAGE, "three")).click()
  device.findObject(By.res(CALC_PACKAGE, "equals")).click()

  // Verify the result = 5
  val result: UiObject2 = device.findObject(By.res(CALC_PACKAGE, "result"))
  assertEquals("5", result.text)
}

Java

private static final String CALC_PACKAGE = "com.myexample.calc";

public void testTwoPlusThreeEqualsFive() {
  // Enter an equation: 2 + 3 = ?
  device.findObject(By.res(CALC_PACKAGE, "two")).click();
  device.findObject(By.res(CALC_PACKAGE, "plus")).click();
  device.findObject(By.res(CALC_PACKAGE, "three")).click();
  device.findObject(By.res(CALC_PACKAGE, "equals")).click();

  // Verify the result = 5
  UiObject2 result = device.findObject(By.res(CALC_PACKAGE, "result"));
  assertEquals("5", result.getText());
}

किसी डिवाइस या एम्युलेटर पर UI Automator टेस्ट चलाना

यूआई ऑटोमेटर टेस्ट, Android Studio या कमांड-लाइन से चलाए जा सकते हैं. पक्का करें कि आपने अपने प्रोजेक्ट में AndroidJUnitRunner को डिफ़ॉल्ट इंस्ट्रुमेंटेशन रनर के तौर पर सेट किया हो.

और उदाहरण

सिस्टम यूज़र इंटरफ़ेस (यूआई) के साथ इंटरैक्ट करना

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

Kotlin

// Opens the System Settings.
device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())
device.executeShellCommand("am start -a android.settings.SETTINGS")

Java

// Opens the System Settings.
device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation());
device.executeShellCommand("am start -a android.settings.SETTINGS");

Kotlin

// Opens the notification shade.
device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())
device.openNotification()

Java

// Opens the notification shade.
device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation());
device.openNotification();

Kotlin

// Opens the Quick Settings shade.
device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())
device.openQuickSettings()

Java

// Opens the Quick Settings shade.
device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation());
device.openQuickSettings();

Kotlin

// Get the system clock.
device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())
UiObject2 clock = device.findObject(By.res("com.android.systemui:id/clock"))
print(clock.getText())

Java

// Get the system clock.
device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation());
UiObject2 clock = device.findObject(By.res("com.android.systemui:id/clock"));
print(clock.getText());

ट्रांज़िशन के लिए इंतज़ार करना

परेशान न करें मोड को बंद करो — **पहली इमेज.** UI Automator, टेस्ट डिवाइस पर 'परेशान न करें' मोड बंद कर देता है.

स्क्रीन ट्रांज़िशन में समय लग सकता है और इसकी अवधि का अनुमान लगाना मुश्किल होता है. इसलिए, आपको कार्रवाइयां करने के बाद, UI Automator को इंतज़ार करने के लिए कहना चाहिए. UI Automator, इसके लिए कई तरीके उपलब्ध कराता है:

UiDevice.performActionAndWait(Runnable action, EventCondition<U> condition, long timeout): उदाहरण के लिए, किसी बटन पर क्लिक करने और नई विंडो दिखने तक इंतज़ार करने के लिए, device.performActionAndWait(() -> button.click(), Until.newWindow(), timeout) को कॉल करें
UiDevice.wait(Condition<Object, U> condition, long timeout): उदाहरण के लिए, डिवाइस पर कोई UiObject2 होने तक इंतज़ार करने के लिए, device.wait(Until.hasObject(By.text("my_text")), timeout); को कॉल करें
UiObject2.wait(@NonNull Condition<Object, U> condition, long timeout): उदाहरण के लिए, किसी चेकबॉक्स के चुने जाने तक इंतज़ार करने के लिए, checkbox.wait(Until.checked(true), timeout); को कॉल करें
UiObject2.clickAndWait(@NonNull EventCondition<U> condition, long timeout): उदाहरण के लिए, किसी बटन पर क्लिक करने और नई विंडो दिखने तक इंतज़ार करने के लिए, button.clickAndWait(Until.newWindow(), timeout); को कॉल करें
UiObject2.scrollUntil(@NonNull Direction direction, @NonNull Condition<Object, U> condition): उदाहरण के लिए, जब तक कोई नया ऑब्जेक्ट नहीं दिखता, तब तक नीचे की ओर स्क्रोल करने के लिए, object.scrollUntil(Direction.DOWN, Until.hasObject(By.text('new_obj'))); को कॉल करें
UiObject2.scrollUntil(@NonNull Direction direction, @NonNull EventCondition<U> condition): उदाहरण के लिए, सबसे नीचे तक स्क्रोल करने के लिए, object.scrollUntil(Direction.DOWN, Until.scrollFinished(Direction.DOWN)); को कॉल करें

नीचे दिए गए कोड स्निपेट में, यूज़र इंटरफ़ेस (यूआई) ऑटोमेटर का इस्तेमाल करके, सिस्टम सेटिंग में 'परेशान न करें' मोड को बंद करने का तरीका दिखाया गया है. इसके लिए, performActionAndWait() तरीके का इस्तेमाल किया गया है, जो ट्रांज़िशन के लिए इंतज़ार करता है:

Kotlin

@Test
@SdkSuppress(minSdkVersion = 21)
@Throws(Exception::class)
fun turnOffDoNotDisturb() {
    device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation())
    device.performActionAndWait({
        try {
            device.executeShellCommand("am start -a android.settings.SETTINGS")
        } catch (e: IOException) {
            throw RuntimeException(e)
        }
    }, Until.newWindow(), 1000)
    // Check system settings has been opened.
    Assert.assertTrue(device.hasObject(By.pkg("com.android.settings")))

    // Scroll the settings to the top and find Notifications button
    var scrollableObj: UiObject2 = device.findObject(By.scrollable(true))
    scrollableObj.scrollUntil(Direction.UP, Until.scrollFinished(Direction.UP))
    val notificationsButton = scrollableObj.findObject(By.text("Notifications"))

    // Click the Notifications button and wait until a new window is opened.
    device.performActionAndWait({ notificationsButton.click() }, Until.newWindow(), 1000)
    scrollableObj = device.findObject(By.scrollable(true))
    // Scroll down until it finds a Do Not Disturb button.
    val doNotDisturb = scrollableObj.scrollUntil(
        Direction.DOWN,
        Until.findObject(By.textContains("Do Not Disturb"))
    )
    device.performActionAndWait({ doNotDisturb.click() }, Until.newWindow(), 1000)
    // Turn off the Do Not Disturb.
    val turnOnDoNotDisturb = device.findObject(By.text("Turn on now"))
    turnOnDoNotDisturb?.click()
    Assert.assertTrue(device.wait(Until.hasObject(By.text("Turn off now")), 1000))
}

Java

@Test
@SdkSuppress(minSdkVersion = 21)
public void turnOffDoNotDisturb() throws Exception{
    device = UiDevice.getInstance(InstrumentationRegistry.getInstrumentation());
    device.performActionAndWait(() -> {
        try {
            device.executeShellCommand("am start -a android.settings.SETTINGS");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }, Until.newWindow(), 1000);
    // Check system settings has been opened.
    assertTrue(device.hasObject(By.pkg("com.android.settings")));

    // Scroll the settings to the top and find Notifications button
    UiObject2 scrollableObj = device.findObject(By.scrollable(true));
    scrollableObj.scrollUntil(Direction.UP, Until.scrollFinished(Direction.UP));
    UiObject2 notificationsButton = scrollableObj.findObject(By.text("Notifications"));

    // Click the Notifications button and wait until a new window is opened.
    device.performActionAndWait(() -> notificationsButton.click(), Until.newWindow(), 1000);
    scrollableObj = device.findObject(By.scrollable(true));
    // Scroll down until it finds a Do Not Disturb button.
    UiObject2 doNotDisturb = scrollableObj.scrollUntil(Direction.DOWN,
            Until.findObject(By.textContains("Do Not Disturb")));
    device.performActionAndWait(()-> doNotDisturb.click(), Until.newWindow(), 1000);
    // Turn off the Do Not Disturb.
    UiObject2 turnOnDoNotDisturb = device.findObject(By.text("Turn on now"));
    if(turnOnDoNotDisturb != null) {
        turnOnDoNotDisturb.click();
    }
    assertTrue(device.wait(Until.hasObject(By.text("Turn off now")), 1000));
}

अन्य संसाधन

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

रेफ़रंस दस्तावेज़:

UI Automator API का रेफ़रंस

सैंपल

BasicSample: यह UI Automator का बुनियादी सैंपल है.