गेम लूप के टेस्ट शुरू करें

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

गेम लूप टेस्ट क्या है?

गेमिंग ऐप्लिकेशन, Unity, Unreal या OpenGL/Vulkan C++ कोड जैसे अलग-अलग यूज़र इंटरफ़ेस (यूआई) फ़्रेमवर्क और इंजन पर रेंडर होते हैं. इसलिए, स्टैंडर्ड ऑटोमेशन टूल, यूज़र इंटरफ़ेस (यूआई) एलिमेंट की जांच नहीं कर सकते या उनसे इंटरैक्ट नहीं कर सकते. एक गेम लूप टेस्ट की मदद से, अपने नेटिव इंजन टेस्ट को के साथ इंटिग्रेट किया जा सकता है. इसके लिए, आपको खास तौर पर किसी सिनेरियो नंबर वाला इंटेंट इस्तेमाल करके, अपना गेम लॉन्च करना होगा.Test Lab इस सिनेरियो नंबर से, आपका ऐप्लिकेशन पहले से स्क्रिप्ट किए गए लॉजिक, एआई सिम्युलेशन या परफ़ॉर्मेंस की जांच सीधे आपके गेम इंजन में चलाता है.

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

गेम लूप, इंस्ट्रूमेंटेशन टेस्ट से कैसे अलग होते हैं

  • इंस्ट्रूमेंटेशन टेस्ट (जैसे, Espresso या UI Automator) यूज़र इंटरफ़ेस (यूआई) इंटरैक्शन, बटन पर क्लिक करने, और आपके ऐप्लिकेशन से बाहर Android View के व्यू हैरारकी (व्यू और व्यू ग्रुप के लेआउट का क्रम) में ऐप्लिकेशन की स्थिति की पुष्टि करने के लिए, बाहरी फ़्रेमवर्क पर निर्भर करते हैं.
  • गेम लूप टेस्ट, टेस्ट लॉजिक को आपके ऐप्लिकेशन को सौंपते हैं. आपका ऐप्लिकेशन, बाहरी यूज़र इंटरफ़ेस (यूआई) इंटरैक्शन के बिना, अपना इंटरनल टेस्टिंग लूप या सिम्युलेशन चलाता है. वहीं, Test Lab आपके सिनेरियो को ट्रिगर करता है और टेस्ट का आउटपुट इकट्ठा करता है.

उदाहरण

मान लें कि आपको यह पुष्टि करनी है कि आपका गेम, अलग-अलग डिवाइसों पर कम से कम 60 फ़्रेम प्रति सेकंड की दर से चलता है. इसके लिए, अपने गेम कोड में सिनेरियो 1 लागू करें, ताकि सबसे ज़्यादा विज़ुअल तौर पर जटिल लेवल लोड हो सके. साथ ही, एआई प्लेयर या ऑटोमेटेड स्क्रिप्ट को दो मिनट तक गेम खेलने दें.

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

इस्तेमाल के उदाहरण

अपने गेम इंजन के आधार पर, एक या एक से ज़्यादा लूप वाले टेस्ट लागू किए जा सकते हैं. लूप, आपके गेमिंग ऐप्लिकेशन पर टेस्ट का पूरा या आंशिक रन-थ्रू होता है. गेम लूप का इस्तेमाल इन कामों के लिए किया जा सकता है:

  • अपने गेम का कोई लेवल, उसी तरह से चलाएं जिस तरह से कोई असली उपयोगकर्ता उसे खेलता है. उपयोगकर्ता के इनपुट को स्क्रिप्ट किया जा सकता है, उपयोगकर्ता को निष्क्रिय रखा जा सकता है या अगर आपके गेम में ऐसा करना सही है, तो उपयोगकर्ता की जगह एआई प्लेयर का इस्तेमाल किया जा सकता है. उदाहरण के लिए, अगर आपके पास रेस कार गेमिंग ऐप्लिकेशन है और उसमें पहले से ही एआई प्लेयर लागू है, तो उपयोगकर्ता के इनपुट के लिए एआई ड्राइवर का इस्तेमाल किया जा सकता है.
  • यह देखने के लिए कि डिवाइस, आपके गेम को सबसे अच्छी क्वालिटी सेटिंग पर चला सकते हैं या नहीं.
  • कोई तकनीकी टेस्ट चलाने के लिए. जैसे, कई शेडर कंपाइल करना, उन्हें एक्ज़ीक्यूट करना, यह देखना कि आउटपुट उम्मीद के मुताबिक है या नहीं वगैरह.

गेम लूप टेस्ट, किसी एक टेस्ट डिवाइस, टेस्ट डिवाइसों के सेट या Test Lab पर चलाया जा सकता है. हालांकि, हमारा सुझाव है कि वर्चुअल डिवाइसों पर गेम लूप टेस्ट न चलाएं, क्योंकि इनमें असली डिवाइसों की तुलना में ग्राफ़िक्स फ़्रेम रेट कम होता है.

शुरू करने से पहले

कोई टेस्ट लागू करने के लिए, सबसे पहले आपको गेम लूप टेस्ट के लिए अपने ऐप्लिकेशन को कॉन्फ़िगर करना होगा.

  1. अपने ऐप्लिकेशन के मेनिफ़ेस्ट में, अपनी गतिविधि में एक नया इंटेंट फ़िल्टर जोड़ें:

    <activity android:name=".MyActivity">
   <intent-filter>
       <action android:name="com.google.intent.action.TEST_LOOP"/>
       <category android:name="android.intent.category.DEFAULT"/>
       <data android:mimeType="application/javascript"/>
   </intent-filter>
   <intent-filter>
      ... (other intent filters here)
   </intent-filter>
</activity>

    इससे Test Lab किसी खास इंटेंट को ट्रिगर करके आपका गेम लॉन्च कर सकता है.

  2. अपने कोड में (हमारा सुझाव है कि onCreate तरीके के एलान में), यह जोड़ें:

    Kotlin 

    val launchIntent = intent
if (launchIntent.action == "com.google.intent.action.TEST_LOOP") {
    val scenario = launchIntent.getIntExtra("scenario", 0)
    // Code to handle your game loop here
}

    Java 

    Intent launchIntent = getIntent();
if(launchIntent.getAction().equals("com.google.intent.action.TEST_LOOP")) {
    int scenario = launchIntent.getIntExtra("scenario", 0);
    // Code to handle your game loop here
}

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

  3. सुझाव: टेस्ट के आखिर में, यह जोड़ें:

    Kotlin 

    yourActivity.finish()

    Java 

    yourActivity.finish();

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

गेम लूप टेस्ट बनाना और उसे चलाना

गेम लूप टेस्ट के लिए अपने ऐप्लिकेशन को कॉन्फ़िगर करने के बाद, तुरंत कोई टेस्ट बनाया जा सकता है और उसे अपने गेमिंग ऐप्लिकेशन में चलाया जा सकता है. Test Lab में टेस्ट चलाने के लिए, Firebase कंसोल या gcloud कमांड लाइन इंटरफ़ेस (सीएलआई) का इस्तेमाल किया जा सकता है. इसके अलावा, Test Loop Manager का इस्तेमाल करके, स्थानीय डिवाइस पर भी टेस्ट चलाया जा सकता है.Test LabFirebase

स्थानीय डिवाइस पर चलाना

Test Lab का Test Loop Manager एक ओपन सोर्स ऐप्लिकेशन है. इसकी मदद से, गेम लूप टेस्ट को इंटिग्रेट किया जा सकता है और उन्हें स्थानीय डिवाइसों पर चलाया जा सकता है. इससे आपकी क्वालिटी अश्योरेंस टीम, अपने डिवाइसों पर भी वही गेम लूप चला सकती है.

Test Loop Manager का इस्तेमाल करके, स्थानीय डिवाइस पर टेस्ट चलाने के लिए:

  1. किसी फ़ोन या टैबलेट पर Test Loop Manager डाउनलोड करें और इसे इंस्टॉल करने के लिए, यह कमांड चलाएं: 
    adb install testloopmanager.apk
  2. अपने डिवाइस पर, फ़ोन या टैबलेट पर Test Loop Apps ऐप्लिकेशन खोलें. यह ऐप्लिकेशन, आपके डिवाइस पर मौजूद उन ऐप्लिकेशन की सूची दिखाता है जिन्हें गेम लूप के साथ चलाया जा सकता है. अगर आपको यहां अपना गेमिंग ऐप्लिकेशन नहीं दिखता है, तो पक्का करें कि आपका इंटेंट फ़िल्टर, 'शुरू करने से पहले' सेक्शन के पहले चरण में बताए गए इंटेंट फ़िल्टर से मैच करता हो.
  3. अपना गेमिंग ऐप्लिकेशन चुनें. इसके बाद, जितने लूप चलाने हैं उनकी संख्या चुनें. ध्यान दें: इस चरण में, सिर्फ़ एक लूप के बजाय, लूप का सबसेट चलाने का विकल्प चुना जा सकता है. एक साथ कई लूप चलाने के बारे में ज़्यादा जानने के लिए, वैकल्पिक सुविधाएं लेख पढ़ें.
  4. टेस्ट चलाएं पर क्लिक करें. आपका टेस्ट तुरंत चलने लगता है.

Test Lab में चलाना

Test Lab में गेम लूप टेस्ट चलाने के लिए, Test Lab का इस्तेमाल किया जा सकता है. इसके लिए, Firebase कंसोल या gcloud सीएलआई का इस्तेमाल करें. शुरू करने से पहले, अगर आपने अब तक ऐसा नहीं किया है, तो Firebase कंसोल खोलें और कोई प्रोजेक्ट बनाएं.

Firebase कंसोल का इस्तेमाल करना

  1. Firebase कंसोल में, बाएं पैनल में मौजूद Test Lab पर क्लिक करें.
  2. अपना पहला टेस्ट चलाएं पर क्लिक करें. अगर आपके प्रोजेक्ट ने पहले भी कोई टेस्ट चलाया है, तो टेस्ट चलाएं पर क्लिक करें.
  3. टेस्ट के टाइप के तौर पर गेम लूप चुनें. इसके बाद, जारी रखें पर क्लिक करें.
  4. **ब्राउज़ करें** पर क्लिक करें. इसके बाद, अपने ऐप्लिकेशन की .apk फ़ाइल पर जाएं. ध्यान दें: इस चरण में, सिर्फ़ एक लूप के बजाय, लूप का सबसेट चलाने का विकल्प चुना जा सकता है. एक साथ कई लूप चलाने के बारे में ज़्यादा जानने के लिए, वैकल्पिक सुविधाएं लेख पढ़ें.
  5. जारी रखें पर क्लिक करें.
  6. अपने ऐप्लिकेशन की जांच करने के लिए, असली डिवाइस चुनें.
  7. टेस्ट शुरू करें पर क्लिक करें.

Firebase कंसोल का इस्तेमाल शुरू करने के बारे में ज़्यादा जानने के लिए, Firebase कंसोल की मदद से टेस्ट करना लेख पढ़ें.

gcloud कमांड-लाइन (सीएलआई) का इस्तेमाल करना

  1. अगर आपने अब तक Google Cloud SDK डाउनलोड और इंस्टॉल नहीं किया है, तो उसे डाउनलोड और इंस्टॉल करें

  2. अपने Google खाते का इस्तेमाल करके, gcloud सीएलआई में साइन इन करें:

    gcloud auth login

  3. gcloud में अपना Firebase प्रोजेक्ट सेट करें. यहां PROJECT_ID आपके Firebase प्रोजेक्ट की आईडी है:

    gcloud config set project PROJECT_ID

  4. अपना पहला टेस्ट चलाएं:

    gcloud firebase test android run \
 --type=game-loop --app=<var>path-to-apk</var> \
 --device model=herolte,version=23

gcloud सीएलआई का इस्तेमाल शुरू करने के बारे में ज़्यादा जानने के लिए, gcloud कमांड लाइन से टेस्ट करना लेख पढ़ें.

वैकल्पिक सुविधाएं

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

आउटपुट डेटा लिखना

जब Test Lab आपका गेम लॉन्च करता है, तो यह टेस्ट के लिए डिवाइस पर मौजूद स्थानीय नतीजों की फ़ाइल की ओर इशारा करने वाला यूआरएल तय करता है. इसे launchIntent.getData() का इस्तेमाल करके ऐक्सेस किया जा सकता है. आपका गेम, टेस्ट रन के दौरान, टेस्ट के नतीजे, परफ़ॉर्मेंस मेट्रिक, और लॉग (logFile) सीधे इस जगह पर लिख सकता है.

logFile में कोई भी कॉन्टेंट लिखा जा सकता है. जैसे, सादा टेक्स्ट, CSV डेटा, फ़्रेम रेंडर होने में लगने वाला समय या कस्टम डाइग्नोस्टिक रिपोर्ट. लिखे जाने वाले कॉन्टेंट के लिए कोई पाबंदी या फ़ॉर्मैटिंग की ज़रूरत नहीं होती. जब आपका टेस्ट पूरा हो जाता है, तो यह फ़ाइल को कैप्चर करता है और उसे आपके अन्य टेस्ट आर्टफ़ैक्ट के साथ, Cloud Storage के बकेट में अपलोड कर देता है.

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

Kotlin 

val launchIntent = intent
val logFile = launchIntent.data
logFile?.let {
    Log.i(TAG, "Log file ${it.encodedPath}")
    // ...
}

Java 

Intent launchIntent = getIntent();
Uri logFile = launchIntent.getData();
if (logFile != null) {
    Log.i(TAG, "Log file " + logFile.getEncodedPath());
    // ...
}

अगर आपको अपने गेम ऐप्लिकेशन के C++ साइड से फ़ाइल में लिखना है, तो फ़ाइल पाथ के बजाय, फ़ाइल डिस्क्रिप्टर पास किया जा सकता है:

Kotlin 

val launchIntent = intent
val logFile = launchIntent.data
var fd = -1
logFile?.let {
    Log.i(TAG, "Log file ${it.encodedPath}")
    fd = try {
        contentResolver
            .openAssetFileDescriptor(logFile, "w")!!
            .parcelFileDescriptor
            .fd
    } catch (e: FileNotFoundException) {
        e.printStackTrace()
        -1
    } catch (e: NullPointerException) {
        e.printStackTrace()
        -1
    }
}

// C++ code invoked here.
// native_function(fd);

Java 

Intent launchIntent = getIntent();
Uri logFile = launchIntent.getData();
int fd = -1;
if (logFile != null) {
    Log.i(TAG, "Log file " + logFile.getEncodedPath());
    try {
        fd = getContentResolver()
                .openAssetFileDescriptor(logFile, "w")
                .getParcelFileDescriptor()
                .getFd();
    } catch (FileNotFoundException e) {
        e.printStackTrace();
        fd = -1;
    } catch (NullPointerException e) {
        e.printStackTrace();
        fd = -1;
    }
}

// C++ code invoked here.
// native_function(fd);

C++

#include <unistd.h>
JNIEXPORT void JNICALL
Java_my_package_name_MyActivity_native_function(JNIEnv *env, jclass type, jint log_file_descriptor) {
// The file descriptor needs to be duplicated.
int my_file_descriptor = dup(log_file_descriptor);
}

आउटपुट फ़ाइल का उदाहरण

हालांकि, Test Lab को आपकी logFile के लिए किसी खास फ़ॉर्मैट की ज़रूरत नहीं होती. फिर भी, अपने आउटपुट को नीचे दिए गए स्कीमा से मैच करने वाले JSON के तौर पर स्ट्रक्चर करने से, Firebase कंसोल (https://console.firebase.google.com/project/_/testlab) आपके गेम लूप टेस्ट के लिए, खास जानकारी वाली मेट्रिक को पार्स और डिसप्ले कर सकता है.

इस उदाहरण के बारे में अहम जानकारी:

  • डेटा कौन उपलब्ध कराता है: टेस्ट डेवलपर के तौर पर, आपके गेम कोड से इस फ़ाइल में सभी मेट्रिक की गणना करने और उन्हें लिखने की ज़िम्मेदारी आपकी है. Test Lab आपके लिए इन डेटा पॉइंट को अपने-आप इकट्ठा या जनरेट नहीं करता.
  • कस्टम फ़ील्ड जोड़ना: जिन जगहों पर /.../ का निशान लगा है, वहां की-वैल्यू पेयर के तौर पर, पसंद के मुताबिक कस्टम फ़ील्ड जोड़े जा सकते हैं. उदाहरण के लिए, "rendered_vertices": 12000 या "ai_error_count": 0. अपने ऐप्लिकेशन से फ़ाइल लिखते समय, आउटपुट में कोई भी मान्य JSON प्रॉपर्टी जोड़ी जा सकती है. हालांकि, फ़ील्ड के नाम, स्कीमा फ़ील्ड जैसे कि name या start_timestamp से मेल नहीं खाने चाहिए.
  • आउटपुट फ़ाइल कहां मिलेगी: आपका टेस्ट पूरा होने के बाद, रॉ आउटपुट फ़ाइल, आपके प्रोजेक्ट के Cloud Storage (GCS) के नतीजों के बकेट में, टेस्ट रन आर्टफ़ैक्ट डायरेक्ट्री में सेव हो जाती है. इसे डाउनलोड किया जा सकता है. पार्स किए गए आउटपुट को, Firebase कंसोल के Test Lab पेज पर भी देखा और उसकी जांच की जा सकती है.

यहां, स्ट्रक्चर्ड JSON आउटपुट फ़ाइल का एक उदाहरण दिया गया है:

{
  "name": "test name",
  "start_timestamp": 0, // Timestamp of the test start (in us).
                           Can be absolute or relative
  "driver_info": "...",
  "frame_stats": [
    {
      "timestamp": 1200000, // Timestamp at which this section was written
                               It contains value regarding the period
                               start_timestamp(0) -> this timestamp (1200000 us)
      "avg_frame_time": 15320, // Average time to render a frame in ns
      "nb_swap": 52, // Number of frame rendered
      "threads": [
        {
          "name": "physics",
          "Avg_time": 8030 // Average time spent in this thread per frame in us
        },
        {
          "name": "AI",
          "Avg_time": 2030 // Average time spent in this thread per frame in us
        }
      ],
      /.../ // Any custom field you want (vertices display on the screen, nb units …)
    },
    {
      // Next frame data here, same format as above
    }
  ],
  "loading_stats": [
    {
      "name": "assets_level_1",
      "total_time": 7850, // in us
      /.../
    },
    {
      "name": "victory_screen",
      "total_time": 554, // in us
      /.../
    }

  ],
  /.../, // You can add custom fields here
}

एक से ज़्यादा गेम लूप

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

अपने ऐप्लिकेशन को एक साथ कई लूप चलाने की अनुमति देने के लिए:

  • अगर Test Loop Manager की मदद से कोई टेस्ट चलाया जा रहा है, तो:

    1. अपने ऐप्लिकेशन के मेनिफ़ेस्ट में, <application> एलिमेंट में यह लाइन जोड़ें: 

      <meta-data
  android:name="com.google.test.loops"
  android:value="5" />

      इस लॉन्च इंटेंट में, टारगेट लूप, इंटिजर पैरामीटर के तौर पर शामिल होता है. android:value फ़ील्ड में, 1 से 1024 तक कोई इंटिजर तय किया जा सकता है. यह एक टेस्ट के लिए अनुमति वाले लूप की ज़्यादा से ज़्यादा संख्या है. ध्यान दें कि लूप की इंडेक्सिंग 1 से शुरू होती है, न कि 0 से.

    2. Test Loop Manager ऐप्लिकेशन में, एक स्क्रीन दिखती है. इसकी मदद से, यह चुना जा सकता है कि कौनसे लूप चलाने हैं. अगर एक से ज़्यादा लूप चुने जाते हैं, तो हर लूप, पिछले लूप के पूरा होने के बाद क्रम से लॉन्च होता है.

  • अगर Firebase कंसोल की मदद से कोई टेस्ट चलाया जा रहा है, तो लूप नंबर की सूची या रेंज सिनेरियो फ़ील्ड में डालें.

  • अगर gcloud सीएलआई की मदद से कोई टेस्ट चलाया जा रहा है, तो --scenario-numbers फ़्लैग का इस्तेमाल करके, लूप नंबर की सूची तय करें. उदाहरण के लिए, --scenario-numbers=1,3,5 से लूप 1, 3, और 5 चलते हैं.

  • अगर C++ में कोड लिखा जा रहा है और लूप के व्यवहार में बदलाव करना है, तो अपने नेटिव C++ कोड में यह एक्स्ट्रा पास करें:

    Kotlin 

    val launchIntent = intent
val scenario = launchIntent.getIntExtra("scenario", 0)

    Java 

    Intent launchIntent = getIntent();
int scenario = launchIntent.getIntExtra("scenario", 0);

    अब int वैल्यू के आधार पर, अपने लूप के व्यवहार में बदलाव किया जा सकता है.

गेम लूप को लेबल करना

अपने गेम लूप को एक या एक से ज़्यादा सिनेरियो लेबल से लेबल करने पर, आपकी और आपकी क्वालिटी अश्योरेंस टीम, मिलते-जुलते गेम लूप के सेट (जैसे, "सभी कंपैटिबिलिटी गेम लूप") को आसानी से लॉन्च कर सकती है और उन्हें एक मैट्रिक्स में टेस्ट कर सकती है. अपने लेबल बनाए जा सकते हैं या Test Lab के पहले से तय किए गए लेबल का इस्तेमाल किया जा सकता है:

  • com.google.test.loops.player_experience: इन लूप का इस्तेमाल, गेम खेलते समय असली उपयोगकर्ता के अनुभव को फिर से जनरेट करने के लिए किया जाता है. इन लूप की मदद से टेस्ट करने का मकसद, उन समस्याओं को ढूंढना है जिनका सामना असली उपयोगकर्ता को गेम खेलते समय करना पड़ सकता है.
  • com.google.test.loops.gpu_compatibility: इन लूप का इस्तेमाल, जीपीयू से जुड़ी समस्याओं की जांच करने के लिए किया जाता है. इन लूप की मदद से टेस्ट करने का मकसद, जीपीयू कोड को एक्ज़ीक्यूट करना है. हो सकता है कि यह कोड, प्रोडक्शन में ठीक से न चले. साथ ही, हार्डवेयर और ड्राइवर से जुड़ी समस्याओं को सामने लाना है.
  • com.google.test.loops.compatibility: इन लूप का इस्तेमाल, कंपैटिबिलिटी से जुड़ी कई समस्याओं की जांच करने के लिए किया जाता है. इनमें, इनपुट/आउटपुट से जुड़ी समस्याएं और OpenSSL से जुड़ी समस्याएं शामिल हैं.
  • com.google.test.loops.performance: इन लूप का इस्तेमाल, डिवाइस की परफ़ॉर्मेंस की जांच करने के लिए किया जाता है. उदाहरण के लिए, किसी नए डिवाइस के व्यवहार को देखने के लिए, गेम को सबसे जटिल ग्राफ़िक्स सेटिंग पर चलाया जा सकता है.

अपने ऐप्लिकेशन को एक ही लेबल वाले लूप चलाने की अनुमति देने के लिए:

  • अगर Test Loop Manager की मदद से कोई टेस्ट चलाया जा रहा है, तो:

    1. अपने ऐप्लिकेशन के मेनिफ़ेस्ट में, यह मेटा-डेटा लाइन जोड़ें और LABEL_NAME को अपनी पसंद के लेबल से बदलें:

      <meta-data
 android:name="com.google.test.loops.LABEL_NAME"
 android:value="1,3-5" />

      android:value फ़ील्ड में, 1 से 1024 तक की रेंज या इंटिजर का सेट तय किया जा सकता है. यह एक टेस्ट के लिए अनुमति वाले लूप की ज़्यादा से ज़्यादा संख्या है. इससे उन लूप के बारे में पता चलता है जिन्हें लेबल करना है. ध्यान दें कि लूप की इंडेक्सिंग 1 से शुरू होती है, न कि 0 से. उदाहरण के लिए, android:value="1,3-5" से LABEL_NAME लूप 1, 3, 4, और 5 पर लागू होता है.

    2. Test Loop Manager ऐप्लिकेशन में, लेबल फ़ील्ड में एक या एक से ज़्यादा लेबल डालें.

  • अगर Firebase कंसोल की मदद से कोई टेस्ट चलाया जा रहा है, तो एक या एक से ज़्यादा लेबल को लेबल फ़ील्ड में डालें.

  • अगर gcloud सीएलआई की मदद से कोई टेस्ट चलाया जा रहा है, तो एक या एक से ज़्यादा सिनेरियो लेबल तय करने के लिए --scenario-labels फ़्लैग का इस्तेमाल करें. उदाहरण के लिए, --scenario-labels=performance,gpu.

ऐप्लिकेशन के लिए लाइसेंस की प्रोसेस की सुविधा

Test Lab Google Play की ओर से उपलब्ध कराई जाने वाली ऐप्लिकेशन के लिए लाइसेंस की सुविधा का इस्तेमाल करने वाले ऐप्लिकेशन के साथ काम करता है. Test Lab की मदद से अपने ऐप्लिकेशन की जांच करते समय, लाइसेंस की जांच करने के लिए, आपको अपने ऐप्लिकेशन को Play Store के प्रोडक्शन चैनल पर पब्लिश करना होगा.Test Lab Test Lab की मदद से, अपने ऐप्लिकेशन को अल्फ़ा या बीटा चैनल में टेस्ट करने के लिए, Test Lab पर अपना ऐप्लिकेशन अपलोड करने से पहले, लाइसेंस की जांच करने की सुविधा हटाएं.Test Lab

ज्ञात समस्याएं

Test Lab में गेम लूप टेस्ट से जुड़ी ये समस्याएं सामने आई हैं:Test Lab

  • कुछ क्रैश के लिए, बैकट्रैक की सुविधा उपलब्ध नहीं है. उदाहरण के लिए, कुछ रिलीज़ बिल्ड, prctl(PR_SET_DUMPABLE, 0) का इस्तेमाल करके, debuggerd प्रोसेस के आउटपुट को दबा सकते हैं. ज़्यादा जानने के लिए, debuggerd देखें.
  • फ़िलहाल, एपीआई लेवल 19 के लिए सहायता उपलब्ध नहीं है. इसकी वजह, फ़ाइल की अनुमति से जुड़ी गड़बड़ियां हैं.