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

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

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

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

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

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

  • इंस्ट्रुमेंटेशन टेस्ट (जैसे, Espresso या UI Automator) यूज़र इंटरफ़ेस (यूआई) इंटरैक्शन, बटन पर क्लिक करने, और Android व्यू हैरारकी (व्यू और व्यू ग्रुप के लेआउट का क्रम) में ऐप्लिकेशन की स्थिति की पुष्टि करने के लिए, बाहरी फ़्रेमवर्क पर निर्भर करते हैं. ये सभी काम आपके ऐप्लिकेशन के बाहर से किए जाते हैं.
  • गेम लूप टेस्ट में, टेस्ट लॉजिक को आपके ऐप्लिकेशन को सौंपा जाता है. आपका ऐप्लिकेशन, बाहरी यूज़र इंटरफ़ेस (यूआई) इंटरैक्शन के बिना, अपना इंटरनल टेस्टिंग लूप या सिम्युलेशन चलाता है. वहीं, 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 Labका Test Loop Manager एक ओपन सोर्स ऐप्लिकेशन है. यह गेम लूप टेस्ट को इंटिग्रेट करने और उन्हें अपने लोकल डिवाइसों पर चलाने में आपकी मदद करता है. इससे आपकी क्वालिटी अश्योरेंस टीम को भी अपने डिवाइसों पर एक जैसे गेम लूप चलाने की अनुमति मिलती है.

टेस्ट लूप मैनेजर का इस्तेमाल करके, किसी लोकल डिवाइस पर टेस्ट चलाने के लिए:

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

Test Lab में दौड़ें

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

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

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

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

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

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

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

    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 पर क्रैश होता है, तो क्रैश को फिर से बनाने और गड़बड़ियों को ठीक करने के लिए, सीधे उस गेम लूप को लॉन्च किया जा सकता है.

अपने ऐप्लिकेशन में एक साथ कई लूप चलाने की सुविधा चालू करने के लिए:

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

    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 CLI की मदद से टेस्ट चलाया जा रहा है, तो --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: जीपीयू से जुड़ी समस्याओं की जांच करने के लिए इस्तेमाल किए गए लूप. इन लूप के साथ टेस्टिंग करने का मकसद, ऐसे GPU कोड को एक्ज़ीक्यूट करना है जो प्रोडक्शन में ठीक से काम नहीं कर सकता. इससे हार्डवेयर और ड्राइवर से जुड़ी समस्याओं का पता चलता है.
  • com.google.test.loops.compatibility: इनका इस्तेमाल, कई तरह की संगतता से जुड़ी समस्याओं को टेस्ट करने के लिए किया जाता है. इनमें I/O से जुड़ी समस्याएं और OpenSSL से जुड़ी समस्याएं शामिल हैं.
  • com.google.test.loops.performance: डिवाइस की परफ़ॉर्मेंस की जांच करने के लिए इस्तेमाल किए गए लूप. उदाहरण के लिए, किसी नए डिवाइस की परफ़ॉर्मेंस देखने के लिए, गेम को सबसे जटिल ग्राफ़िक्स सेटिंग पर चलाया जा सकता है.

अपने ऐप्लिकेशन में एक ही लेबल के साथ लूप चलाने की सुविधा चालू करने के लिए:

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

    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", लूप 1, 3, 4, और 5 पर लागू होता है.LABEL_NAME

    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 में गेम लूप टेस्ट से जुड़ी ये समस्याएं हैं:

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