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

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

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

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

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

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

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

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

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

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

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

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

  • अगर 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 वैल्यू के आधार पर, लूप के काम करने के तरीके को बदलने का विकल्प है.

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

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

  • com.google.test.loops.player_experience: गेम खेलते समय, असली उपयोगकर्ता के अनुभव को फिर से दिखाने के लिए इस्तेमाल किए जाने वाले लूप. इन लूप के साथ टेस्ट करने का मकसद, उन समस्याओं का पता लगाना है जो गेम खेलते समय किसी असली उपयोगकर्ता को आ सकती हैं.
  • com.google.test.loops.gpu_compatibility: जीपीयू से जुड़ी समस्याओं की जांच करने के लिए, For लूप का इस्तेमाल किया जाता है. इन लूप के साथ टेस्टिंग करने का मकसद, जीपीयू कोड को एक्ज़ीक्यूट करना है. ऐसा हो सकता है कि यह कोड, प्रोडक्शन में ठीक से काम न करे. इससे हार्डवेयर और ड्राइवर से जुड़ी समस्याओं का पता चलता है.
  • com.google.test.loops.compatibility: For loops का इस्तेमाल, साथ काम करने से जुड़ी कई तरह की समस्याओं की जांच करने के लिए किया जाता है. इनमें इनपुट/आउटपुट और 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", LABEL_NAME को लूप 1, 3, 4, और 5 पर लागू करता है.

    2. टेस्ट लूप मैनेजर ऐप्लिकेशन में, लेबल फ़ील्ड में एक या उससे ज़्यादा लेबल डालें.

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

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

ऐप्लिकेशन के लिए लाइसेंस की प्रोसेस से जुड़ी सहायता

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

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

Test Lab में गेम लूप टेस्ट में ये समस्याएं होती हैं:

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