यूज़र इंटरफ़ेस (यूआई) ऑटोमेशन की मदद से, अपने-आप होने वाले टेस्ट में बदलाव करने की सुविधा

संग्रह की मदद से व्यवस्थित रहें अपनी प्राथमिकताओं के आधार पर, कॉन्टेंट को सेव करें और कैटगरी में बांटें.

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

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

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

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

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

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

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

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

UI Automator API

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

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

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

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()

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 की मदद से यूज़र इंटरफ़ेस (यूआई) टेस्ट बनाने से पहले, अपने टेस्ट के सोर्स कोड की जगह और प्रोजेक्ट की डिपेंडेंसी को कॉन्फ़िगर करना न भूलें. इसके बारे में AndroidX टेस्ट के लिए प्रोजेक्ट सेट अप करना में बताया गया है.

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

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

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

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

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

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

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

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

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

 $ uiautomatorviewer

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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
    )
  }
}

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 इंस्टेंस का फिर से इस्तेमाल किया जा सकता है. ध्यान दें कि जब भी आपका टेस्ट, यूज़र इंटरफ़ेस (यूआई) एलिमेंट पर क्लिक करने या किसी प्रॉपर्टी के बारे में क्वेरी करने के लिए, UiObject2 इंस्टेंस का इस्तेमाल करता है, तो यूआई ऑटोमेट टेस्ट फ़्रेमवर्क, मैच के लिए मौजूदा डिसप्ले को खोजता है.

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

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()
}

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 ढूंढने के लिए, खोज के लिए कैसे निर्देश दे सकता है.

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

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

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

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

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

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

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

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

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)
}

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 तरीकों का इस्तेमाल किया जा सकता है.

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

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)
}

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, स्क्रीन पर मौजूद हर चीज़ के साथ इंटरैक्ट कर सकता है. इसमें आपके ऐप्लिकेशन के बाहर के सिस्टम एलिमेंट भी शामिल हैं. इस बारे में यहां दिए गए कोड स्निपेट में बताया गया है:

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

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

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

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

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

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

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

// 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 को इंतज़ार करना चाहिए. यूज़र इंटरफ़ेस (यूआई) ऑटोमेट करने वाला टूल, इसके लिए कई तरीके उपलब्ध कराता है:

• 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)); को कॉल करें

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

@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))
}

@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 का बुनियादी सैंपल.