Android इंस्ट्रूमेंटेशन टेस्ट

अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है किसी समस्या की शिकायत करें सोर्स देखें रात · 7.3 · 7.2 · 7.1 · 7.0 · 6.5

अगर आप बाज़ार में नए हैं, तो Android Auto की मदद से डेवलप किए जाने वाले Basel का ट्यूटोरियल.

पहला डायग्राम. साथ-साथ चलने वाले Android इंस्ट्रुमेंटेशन की जांच कर रहे हैं.

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

ज़रूरत के हिसाब से बार-बार इस्तेमाल करने और दोबारा जनरेट करने की क्षमता के लिए, Basel ने Android डिवाइस बनाया और उसे लॉन्च किया यह पक्का करता है कि टेस्ट हमेशा स्वच्छ स्थिति से चलें. हर टेस्ट को एक आइसोलेटेड एम्युलेटर इंस्टेंस मिलता है, जिससे टेस्ट साथ-साथ चलने के लिए मिलते हैं और उसे एक-दूसरे से कनेक्ट न कर सकें.

Android इंस्ट्रुमेंटेशन टेस्ट के बारे में ज़्यादा जानकारी के लिए, Android डेवलपर दस्तावेज़ में दिया गया है.

कृपया GitHub में समस्या को ट्रैक करने वाले टूल में समस्याओं की शिकायत करें.

यह कैसे काम करता है

जब आप android_instrumentation_test के टारगेट पर bazel test दौड़ते हैं पहली बार, Basel ने इन चरणों को पूरा किया:

1. टेस्ट APK, टेस्ट किए जा रहे APK, और उनकी ट्रांज़िटिव डिपेंडेंसी बनाता है
2. क्लीन एम्युलेटर स्टेट को बनाता है, चालू करता है, और कैश मेमोरी में सेव करता है
3. एम्युलेटर को शुरू करता है
4. APK इंस्टॉल करता है
5. Android Test Orchestrator का इस्तेमाल करके, जांच की जाती है.
6. एम्युलेटर को बंद करता है
7. नतीजों की रिपोर्ट करता है

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

ज़रूरी शर्तें

पक्का करें कि आपका एनवायरमेंट, यहां दी गई ज़रूरी शर्तों को पूरा करता हो:

• Linux. Ubuntu 16.04, और 18.04 को टेस्ट किया गया.

• Baze 0.12.0 या इसके बाद का वर्शन. bazel info release चलाकर वर्शन की पुष्टि करें.

bazel info release

इससे आउटपुट कुछ ऐसा मिलता है:

release 4.1.0

• KVM. Baज़ल के लिए एम्युलेटर का हार्डवेयर होना ज़रूरी है तेज़ी के साथ कनेक्ट करने के लिए किया जा सकता है. अपनी वेबसाइट पर काम करने के लिए, इंस्टॉल करने के निर्देश Ubuntu के लिए काम करते हैं.

यह पुष्टि करने के लिए कि केवीएम का कॉन्फ़िगरेशन सही है, इसे चलाएं:

apt-get install cpu-checker && kvm-ok

अगर यह नीचे दिया गया मैसेज प्रिंट करता है, तो इसका मतलब है कि आपका कॉन्फ़िगरेशन सही है:

INFO: /dev/kvm exists
KVM acceleration can be used

• Xvfb. बिना ग्राफ़िक यूज़र इंटरफ़ेस वाला टेस्ट (जैसे, सीआई सर्वर पर) करने के लिए, Basel को X वर्चुअल फ़्रेमबफ़र.

इसे इंस्टॉल करने के लिए, इसे चलाएं:

apt-get install xvfb

पुष्टि करें कि Xvfb सही तरीके से इंस्टॉल किया गया है और /usr/bin/Xvfb पर इंस्टॉल किया गया है चलाकर:

which Xvfb

इसका आउटपुट इस तरह का होता है:

/usr/bin/Xvfb

• 32-बिट लाइब्रेरी. टेस्ट इन्फ़्रास्ट्रक्चर में इस्तेमाल होने वाली कुछ बाइनरी 32-बिट, इसलिए 64-बिट मशीनों पर, यह सुनिश्चित करना चाहिए कि 32-बिट बाइनरी चलाई जा सकती हैं. इसके लिए Ubuntu के लिए, ये 32-बिट लाइब्रेरी इंस्टॉल करें:

sudo apt-get install libc6:i386 libncurses5:i386 libstdc++6:i386 lib32z1 libbz2-1.0:i386

शुरू करना

यहां android_instrumentation_test का सामान्य टारगेट डिपेंडेंसी ग्राफ़ दिया गया है:

दूसरा डायग्राम. android_instrumentation_test का टारगेट डिपेंडेंसी ग्राफ़.

फ़ाइल बनाएं

ग्राफ़ इस तरह की BUILD फ़ाइल में बदल जाता है:

android_instrumentation_test(
    name = "my_test",
    test_app = ":my_test_app",
    target_device = "@android_test_support//tools/android/emulated_devices/generic_phone:android_23_x86",
)

# Test app and library
android_binary(
    name = "my_test_app",
    instruments = ":my_app",
    manifest = "AndroidTestManifest.xml",
    deps = [":my_test_lib"],
    # ...
)

android_library(
    name = "my_test_lib",
    srcs = glob(["javatest/**/*.java"]),
    deps = [
        ":my_app_lib",
        "@maven//:androidx_test_core",
        "@maven//:androidx_test_runner",
        "@maven//:androidx_test_espresso_espresso_core",
    ],
    # ...
)

# Target app and library under test
android_binary(
    name = "my_app",
    manifest = "AndroidManifest.xml",
    deps = [":my_app_lib"],
    # ...
)

android_library(
    name = "my_app_lib",
    srcs = glob(["java/**/*.java"]),
    deps = [
        "@maven//:androidx_appcompat_appcompat",
        "@maven//:androidx_annotation_annotation",
    ]
    # ...
)

android_instrumentation_test नियम के मुख्य एट्रिब्यूट ये हैं:

• test_app: android_binary का टारगेट. इस टारगेट में टेस्ट कोड है और Espresso और UIAutomator जैसी डिपेंडेंसी. चुना गया android_binary टारगेट में एक instruments एट्रिब्यूट शामिल करना ज़रूरी है, जो किसी दूसरे android_binary, इस ऐप्लिकेशन की जांच की जा रही है.

• target_device: android_device का टारगेट. इस टारगेट में, की खास जानकारी, Android Emulator की खास जानकारी है. Basel ने इस ऐप्लिकेशन को बनाने, लॉन्च करने, और टेस्ट करना चाहिए. किसी Android फ़ोन को चुनने से जुड़ा सेक्शन डिवाइस पर देखें.

टेस्ट ऐप्लिकेशन के AndroidManifest.xml में <instrumentation> शामिल होना चाहिए टैग. इस टैग को टारगेट किए जाने वाले ऐप्लिकेशन के पैकेज के एट्रिब्यूट की जानकारी देनी होगी और इंस्ट्रुमेंटेशन टेस्ट रनर की क्लास का पूरी तरह क्वालिफ़ाइड नाम, androidx.test.runner.AndroidJUnitRunner.

यहां टेस्ट ऐप्लिकेशन के लिए AndroidTestManifest.xml का उदाहरण दिया गया है:

<?xml version="1.0" encoding="UTF-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
          xmlns:tools="http://schemas.android.com/tools"
          package="com.example.android.app.test"
    android:versionCode="1"
    android:versionName="1.0">

    <instrumentation
        android:name="androidx.test.runner.AndroidJUnitRunner"
        android:targetPackage="com.example.android.app" />

    <uses-sdk
        android:minSdkVersion="16"
        android:targetSdkVersion="27" />

    <application >
       <!-- ... -->
    </application>
</manifest>

वर्कस्पेस डिपेंडेंसी

इस नियम का इस्तेमाल करने के लिए, आपके प्रोजेक्ट को इन बाहरी सोर्स पर निर्भर होना होगा डेटा स्टोर करने की जगहें:

• @androidsdk: Android SDK टूल. इसे Android Studio से डाउनलोड करें.

• @android_test_support: टेस्ट रनर, एम्युलेटर लॉन्चर, और android_device टारगेट. आपको हाल ही की रिलीज़ यहां पढ़ें.

अपने WORKSPACE में ये लाइनें जोड़कर, इन डिपेंडेंसी को चालू करें फ़ाइल:

# Android SDK
android_sdk_repository(
    name = "androidsdk",
    path = "/path/to/sdk", # or set ANDROID_HOME
)

# Android Test Support
ATS_COMMIT = "$COMMIT_HASH"
http_archive(
    name = "android_test_support",
    strip_prefix = "android-test-%s" % ATS_COMMIT,
    urls = ["https://github.com/android/android-test/archive/%s.tar.gz" % ATS_COMMIT],
)
load("@android_test_support//:repo.bzl", "android_test_repositories")
android_test_repositories()

Maven डिपेंडेंसी

डेटा स्टोर करने की जगहों से, Maven आर्टफ़ैक्ट पर डिपेंडेंसी मैनेज करने के लिए, जैसे कि Google Maven या Maven Central, आपको Maven रिज़ॉल्वर का इस्तेमाल करना चाहिए, जैसे कि rules_jvm_external.

इस पेज के बाकी हिस्से में, rules_jvm_external के इस्तेमाल का तरीका बताया गया है. Maven रिपॉज़िटरी से डिपेंडेंसी को ठीक और फ़ेच करता है.

android_device टारगेट चुनना

android_instrumentation_test.target_device तय करता है कि किस Android डिवाइस को टेस्ट चालू रखें. ये android_device लक्ष्य इसमें निर्धारित किए गए हैं @android_test_support.

उदाहरण के लिए, यह चलाकर किसी खास टारगेट के सोर्स के बारे में क्वेरी की जा सकती है:

bazel query --output=build @android_test_support//tools/android/emulated_devices/generic_phone:android_23_x86

किस तरह का आउटपुट, इसके जैसा दिखता है:

# .../external/android_test_support/tools/android/emulated_devices/generic_phone/BUILD:43:1
android_device(
  name = "android_23_x86",
  visibility = ["//visibility:public"],
  tags = ["requires-kvm"],
  generator_name = "generic_phone",
  generator_function = "make_device",
  generator_location = "tools/android/emulated_devices/generic_phone/BUILD:43",
  vertical_resolution = 800,
  horizontal_resolution = 480,
  ram = 2048,
  screen_density = 240,
  cache = 32,
  vm_heap = 256,
  system_image = "@android_test_support//tools/android/emulated_devices/generic_phone:android_23_x86_images",
  default_properties = "@android_test_support//tools/android/emulated_devices/generic_phone:_android_23_x86_props",
)

डिवाइस लक्ष्य नाम इस टेम्प्लेट का उपयोग करते हैं:

@android_test_support//tools/android/emulated_devices/device_type:system_api_level_x86_qemu2

android_device को लॉन्च करने के लिए, चुने गए एपीआई के लिए system_image लेवल की जानकारी देना ज़रूरी है. सिस्टम इमेज डाउनलोड करने के लिए, Android SDK की tools/bin/sdkmanager. उदाहरण के लिए, generic_phone:android_23_x86, $sdk/tools/bin/sdkmanager "system-images;android-23;default;x86" दौड़ें.

यहां इस्तेमाल किए जा सकने वाले android_device टारगेट की पूरी सूची देखने के लिए @android_test_support, नीचे दिया गया निर्देश चलाएं:

bazel query 'filter("x86_qemu2$", kind(android_device, @android_test_support//tools/android/emulated_devices/...:*))'

फ़िलहाल, Basel को सिर्फ़ x86 पर आधारित एम्युलेटर के साथ इस्तेमाल किया जा सकता है. बेहतर परफ़ॉर्मेंस के लिए, QEMU टारगेट के बजाय QEMU2 android_device टारगेट.

चल रही जांच

परीक्षण चलाने के लिए, इन पंक्तियों को अपने प्रोजेक्ट के project root:/.bazelrc फ़ाइल.

# Configurations for testing with Bazel
# Select a configuration by running
# `bazel test //my:target --config={headless, gui, local_device}`

# Headless instrumentation tests (No GUI)
test:headless --test_arg=--enable_display=false

# Graphical instrumentation tests. Ensure that $DISPLAY is set.
test:gui --test_env=DISPLAY
test:gui --test_arg=--enable_display=true

# Testing with a local emulator or device. Ensure that `adb devices` lists the
# device.
# Run tests serially.
test:local_device --test_strategy=exclusive
# Use the local device broker type, as opposed to WRAPPED_EMULATOR.
test:local_device --test_arg=--device_broker_type=LOCAL_ADB_SERVER
# Uncomment and set $device_id if there is more than one connected device.
# test:local_device --test_arg=--device_serial_number=$device_id

इसके बाद, टेस्ट करने के लिए किसी एक कॉन्फ़िगरेशन का इस्तेमाल करें:

• bazel test //my/test:target --config=gui
• bazel test //my/test:target --config=headless
• bazel test //my/test:target --config=local_device

सिर्फ़ एक कॉन्फ़िगरेशन का इस्तेमाल करें. ऐसा न करने पर, जांच नहीं हो पाएगी.

बिना ग्राफ़िक यूज़र इंटरफ़ेस वाला टेस्ट

Xvfb की मदद से, ग्राफ़िक के बिना एम्युलेटर की मदद से जांच की जा सकती है इंटरफ़ेस, जिसे हेडलेस टेस्टिंग के नाम से भी जाना जाता है. ग्राफ़िकल इंटरफ़ेस को बंद करने के लिए परीक्षण चलाते समय, परीक्षण तर्क --enable_display=false को Baज़र में पास करें:

bazel test //my/test:target --test_arg=--enable_display=false

जीयूआई की जांच करना

अगर $DISPLAY एनवायरमेंट वैरिएबल सेट है, तो इसे चालू किया जा सकता है टेस्ट के दौरान, एम्युलेटर का ग्राफ़िकल इंटरफ़ेस. ऐसा करने के लिए, Baज़र के लिए, ये टेस्ट आर्ग्युमेंट:

bazel test //my/test:target --test_arg=--enable_display=true --test_env=DISPLAY

लोकल एम्युलेटर या डिवाइस से टेस्ट करना

बेज़ल, स्थानीय तौर पर लॉन्च किए गए एम्युलेटर या कनेक्ट किए गए एम्युलेटर पर भी टेस्ट करने की सुविधा देता है डिवाइस. फ़्लैग पास करें --test_strategy=exclusive और लोकल टेस्टिंग मोड चालू करने के लिए, --test_arg=--device_broker_type=LOCAL_ADB_SERVER. अगर कनेक्ट किए गए एक से ज़्यादा डिवाइस हैं, तो फ़्लैग को पास करें --test_arg=--device_serial_number=$device_id जहां $device_id इसका आईडी है adb devices में दिया गया डिवाइस/एम्युलेटर.

सैंपल प्रोजेक्ट

अगर आपको प्रोजेक्ट के कैननिकल सैंपल चाहिए, तो Android की जांच के लिए सैंपल का इस्तेमाल करें.

एस्प्रेसो सेट अप

अगर Espresso की मदद से यूज़र इंटरफ़ेस (यूआई) की जांच की जाती है (androidx.test.espresso), तो आप नीचे दिए गए स्निपेट का इस्तेमाल करके अपना बेज़ल वर्कस्पेस में, आम तौर पर इस्तेमाल होने वाले Espresso आर्टफ़ैक्ट और उनके डिपेंडेंसी:

androidx.test.espresso:espresso-core
androidx.test:rules
androidx.test:runner
javax.inject:javax.inject
org.hamcrest:java-hamcrest
junit:junit

इन डिपेंडेंसी को व्यवस्थित करने का एक तरीका है, शेयर किया गया //:test_deps बनाना आपकी project root/BUILD.bazel फ़ाइल में मौजूद लाइब्रेरी:

java_library(
    name = "test_deps",
    visibility = ["//visibility:public"],
    exports = [
        "@maven//:androidx_test_espresso_espresso_core",
        "@maven//:androidx_test_rules",
        "@maven//:androidx_test_runner",
        "@maven//:javax_inject_javax_inject"
        "@maven//:org_hamcrest_java_hamcrest",
        "@maven//:junit_junit",
    ],
)

इसके बाद, project root/WORKSPACE में ज़रूरी डिपेंडेंसी जोड़ें:

load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")

RULES_JVM_EXTERNAL_TAG = "2.8"
RULES_JVM_EXTERNAL_SHA = "79c9850690d7614ecdb72d68394f994fef7534b292c4867ce5e7dec0aa7bdfad"

http_archive(
    name = "rules_jvm_external",
    strip_prefix = "rules_jvm_external-%s" % RULES_JVM_EXTERNAL_TAG,
    sha256 = RULES_JVM_EXTERNAL_SHA,
    url = "https://github.com/bazelbuild/rules_jvm_external/archive/%s.zip" % RULES_JVM_EXTERNAL_TAG,
)

load("@rules_jvm_external//:defs.bzl", "maven_install")

maven_install(
    artifacts = [
        "junit:junit:4.12",
        "javax.inject:javax.inject:1",
        "org.hamcrest:java-hamcrest:2.0.0.0"
        "androidx.test.espresso:espresso-core:3.1.1",
        "androidx.test:rules:aar:1.1.1",
        "androidx.test:runner:aar:1.1.1",
    ],
    repositories = [
        "https://maven.google.com",
        "https://repo1.maven.org/maven2",
    ],
)

आखिर में, अपने टेस्ट android_binary टारगेट में, //:test_deps जोड़ें निर्भरता:

android_binary(
    name = "my_test_app",
    instruments = "//path/to:app",
    deps = [
        "//:test_deps",
        # ...
    ],
    # ...
)

सलाह

टेस्ट लॉग पढ़ना

जांच में सफल न होने पर लॉग प्रिंट करने के लिए --test_output=errors का इस्तेमाल करें या जांच के सभी आउटपुट को प्रिंट करने के लिए --test_output=all. अगर आपको किसी व्यक्तिगत टेस्ट लॉग, $PROJECT_ROOT/bazel-testlogs/path/to/InstrumentationTestTargetName.

उदाहरण के लिए, BasicSample कैननिकल प्रोजेक्ट के जांच लॉग इसमें हैं bazel-testlogs/ui/espresso/BasicSample/BasicSampleInstrumentationTest, दौड़ें:

tree bazel-testlogs/ui/espresso/BasicSample/BasicSampleInstrumentationTest

इसका नतीजा यह होता है कि:

$ tree bazel-testlogs/ui/espresso/BasicSample/BasicSampleInstrumentationTest
.
├── adb.409923.log
├── broker_logs
│   ├── aapt_binary.10.ok.txt
│   ├── aapt_binary.11.ok.txt
│   ├── adb.12.ok.txt
│   ├── adb.13.ok.txt
│   ├── adb.14.ok.txt
│   ├── adb.15.fail.txt
│   ├── adb.16.ok.txt
│   ├── adb.17.fail.txt
│   ├── adb.18.ok.txt
│   ├── adb.19.fail.txt
│   ├── adb.20.ok.txt
│   ├── adb.21.ok.txt
│   ├── adb.22.ok.txt
│   ├── adb.23.ok.txt
│   ├── adb.24.fail.txt
│   ├── adb.25.ok.txt
│   ├── adb.26.fail.txt
│   ├── adb.27.ok.txt
│   ├── adb.28.fail.txt
│   ├── adb.29.ok.txt
│   ├── adb.2.ok.txt
│   ├── adb.30.ok.txt
│   ├── adb.3.ok.txt
│   ├── adb.4.ok.txt
│   ├── adb.5.ok.txt
│   ├── adb.6.ok.txt
│   ├── adb.7.ok.txt
│   ├── adb.8.ok.txt
│   ├── adb.9.ok.txt
│   ├── android_23_x86.1.ok.txt
│   └── exec-1
│       ├── adb-2.txt
│       ├── emulator-2.txt
│       └── mksdcard-1.txt
├── device_logcat
│   └── logcat1635880625641751077.txt
├── emulator_itCqtc.log
├── outputs.zip
├── pipe.log.txt
├── telnet_pipe.log.txt
└── tmpuRh4cy
    ├── watchdog.err
    └── watchdog.out

4 directories, 41 files

एम्युलेटर लॉग को पढ़ा जा रहा है

android_device टारगेट के लिए एम्युलेटर लॉग, /tmp/ में सेव किए जाते हैं emulator_xxxxx.log नाम की डायरेक्ट्री, जहां xxxxx एक वर्णों का कोई भी क्रम, बिना किसी क्रम के जनरेट होता है.

नया एम्युलेटर लॉग ढूंढने के लिए, इस निर्देश का इस्तेमाल करें:

ls -1t /tmp/emulator_*.log | head -n 1

कई एपीआई लेवल पर जांच करना

अगर आपको एक से ज़्यादा एपीआई लेवल की जांच करनी है, तो आपके पास हर एपीआई लेवल के लिए टेस्ट टारगेट बनाने की समझ. उदाहरण के लिए:

API_LEVELS = [
    "19",
    "20",
    "21",
    "22",
]

[android_instrumentation_test(
    name = "my_test_%s" % API_LEVEL,
    test_app = ":my_test_app",
    target_device = "@android_test_support//tools/android/emulated_devices/generic_phone:android_%s_x86_qemu2" % API_LEVEL,
) for API_LEVEL in API_LEVELS]

पहले से मालूम समस्याएं

• Forked adb सर्वर प्रोसेस इस तारीख के बाद खत्म नहीं होती है टेस्ट
• जबकि APK बिल्डिंग सभी प्लैटफ़ॉर्म (Linux, macOS, Windows) पर काम करती है, टेस्ट कर रहे हैं यह सुविधा सिर्फ़ Linux पर काम करती है.
• --config=local_adb के साथ भी, उपयोगकर्ताओं को अब भी यह बताना होगा android_instrumentation_test.target_device.
• अगर किसी लोकल डिवाइस या एम्युलेटर का इस्तेमाल किया जा रहा है, तो Basel, APK के बाद के APK अनइंस्टॉल नहीं करता है का पता लगाना है. इस निर्देश की मदद से पैकेज हटाएं:

adb shell pm list
packages com.example.android.testing | cut -d ':' -f 2 | tr -d '\r' | xargs
-L1 -t adb uninstall