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

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

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

यूज़र इंटरफ़ेस (यूआई) के ऑटोमेशन की जांच करने वाले फ़्रेमवर्क की मुख्य सुविधाओं में ये शामिल हैं:

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

डिवाइस की स्थिति ऐक्सेस की जा रही है

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

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

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

यूज़र इंटरफ़ेस (यूआई) Automator API

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

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

उदाहरण के लिए, नीचे दिया गया कोड दिखाता है कि आप टेस्ट स्क्रिप्ट कैसे लिख सकते हैं डिवाइस में 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);

यूज़र इंटरफ़ेस (यूआई) ऑटोमेटर सेट अप करें

यूआई ऑटोमेशन की मदद से, यूआई की जांच करने से पहले, जांच को कॉन्फ़िगर करना न भूलें सोर्स कोड की लोकेशन और प्रोजेक्ट डिपेंडेंसी, जैसा कि प्रोजेक्ट सेट अप करना AndroidX टेस्ट के लिए.

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

dependencies {
  ...
  androidTestImplementation('androidx.test.uiautomator:uiautomator:2.3.0-alpha03')
}

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

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

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

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

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

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

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

 $ uiautomatorviewer

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

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

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

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

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

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

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

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

यूज़र इंटरफ़ेस (यूआई) ऑटोमेटर टेस्ट क्लास बनाना

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

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

अपने यूज़र इंटरफ़ेस (यूआई) Automator टेस्ट क्लास में इस प्रोग्रामिंग मॉडल को लागू करें:

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

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

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

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

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

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

UiObject2 को वापस पाने के लिए, findObject() तरीके का इस्तेमाल करें. यह तरीका बताता है कि ऐसा व्यू जो दिए गए सिलेक्टर की शर्तों से मेल खाता है. 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 दिखता है.

नेस्ट करने के लिए, hasChild() या hasDescendant() तरीके का इस्तेमाल किया जा सकता है से ज़्यादा BySelector इंस्टेंस. उदाहरण के लिए, नीचे दिया गया कोड का उदाहरण आपका टेस्ट, उस पहले 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() के ज़रिए मिला है.

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

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

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

इंस्ट्रुमेंटेशनTestCase में 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());
}

डिवाइस या एम्युलेटर पर यूज़र इंटरफ़ेस (यूआई) ऑटोमेटर टेस्ट चलाना

Android Studio या कमांड लाइन. AndroidJUnitRunner को डिफ़ॉल्ट के तौर पर सेट करना न भूलें इंस्ट्रुमेंटेशन रनर हों.

और उदाहरण

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

यूज़र इंटरफ़ेस (यूआई) ऑटोमेटर, सिस्टम के साथ-साथ स्क्रीन पर मौजूद हर चीज़ से इंटरैक्ट कर सकता है तत्व हैं, जैसा कि नीचे दिए गए कोड स्निपेट में दिखाया गया है:

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

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

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

• 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(device.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() तरीके का इस्तेमाल करके परेशान करने वाला मोड चालू करें ट्रांज़िशन की इंतज़ार करता है:

@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 की जांच में यूआई ऑटोमेशन का इस्तेमाल करने के बारे में ज़्यादा जानने के लिए, इन संसाधनों को देखें.

रेफ़रंस के लिए दस्तावेज़:

• यूज़र इंटरफ़ेस (यूआई) Automator API का रेफ़रंस

सैंपल

• बेसिक सैंपल: बेसिक यूज़र इंटरफ़ेस (यूआई) Automator सैंपल.