इस पेज का अनुवाद Cloud Translation API से किया गया है.

गेम लूप टेस्ट के साथ शुरुआत करें

जब गेमिंग ऐप अलग-अलग UI फ्रेमवर्क पर बनाए जाते हैं तो गेम टेस्टिंग को ऑटोमेट करना मुश्किल हो सकता है। गेम लूप परीक्षण आपको टेस्ट लैब के साथ अपने मूल परीक्षणों को एकीकृत करने और उन्हें आपके द्वारा चुने गए उपकरणों पर आसानी से चलाने की अनुमति देते हैं। एक गेम लूप टेस्ट एक वास्तविक खिलाड़ी के कार्यों का अनुकरण करते हुए आपके गेमिंग ऐप के माध्यम से आपका परीक्षण चलाता है। यह गाइड आपको गेम लूप टेस्ट चलाने का तरीका बताती है, फिर फायरबेस कंसोल में अपने टेस्ट के नतीजे देखें और प्रबंधित करें।

आपके गेम इंजन के आधार पर, आप एकल या एकाधिक लूप के साथ परीक्षण कार्यान्वित कर सकते हैं। एक लूप आपके गेमिंग ऐप पर आपके परीक्षण का पूर्ण या आंशिक रन-थ्रू है। गेम लूप का उपयोग इसके लिए किया जा सकता है:

अपने गेम का एक लेवल ठीक उसी तरह से चलाएँ जिस तरह कोई अंतिम उपयोगकर्ता इसे खेलता है। आप या तो उपयोगकर्ता के इनपुट को स्क्रिप्ट कर सकते हैं, उपयोगकर्ता को निष्क्रिय रहने दें, या उपयोगकर्ता को एआई से बदल सकते हैं यदि यह आपके गेम में समझ में आता है (जैसे, मान लें कि आपके पास रेस कार गेमिंग ऐप है और पहले से एआई लागू है। आप कर सकते हैं आसानी से एआई ड्राइवर को उपयोगकर्ता के इनपुट का प्रभारी बना सकते हैं)।
यह देखने के लिए कि क्या डिवाइस इसका समर्थन करते हैं, अपने गेम को उच्चतम गुणवत्ता सेटिंग पर चलाएं।
एक तकनीकी परीक्षण चलाएं (कई शेडर्स संकलित करें, उन्हें निष्पादित करें, जांचें कि आउटपुट अपेक्षित है, आदि)।

आप एक टेस्ट डिवाइस, टेस्ट डिवाइस के सेट या टेस्ट लैब पर गेम लूप टेस्ट चला सकते हैं। हालांकि, हम वर्चुअल उपकरणों पर गेम लूप परीक्षण चलाने की अनुशंसा नहीं करते हैं क्योंकि उनके पास भौतिक उपकरणों की तुलना में कम ग्राफिक्स फ्रेम दर होती है।

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

एक परीक्षण लागू करने के लिए, आपको पहले अपने ऐप को गेम लूप टेस्ट के लिए कॉन्फ़िगर करना होगा।

अपने ऐप मेनिफ़ेस्ट में, अपनी गतिविधि में एक नया इंटेंट फ़िल्टर जोड़ें:
```
<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>
```
यह टेस्ट लैब को आपके गेम को एक विशिष्ट उद्देश्य से ट्रिगर करके लॉन्च करने की अनुमति देता है।
नोट: गेम लूप के लिए एक अलग, समर्पित इंटेंट फ़िल्टर की आवश्यकता होती है जिसका उपयोग अन्य उद्देश्यों के लिए नहीं किया जाता है। आपकी गतिविधि में अन्य इंटेंट फ़िल्टर शामिल हो सकते हैं। इंटेंट फ़िल्टर के बारे में अधिक जानने के लिए, <इरादा-फ़िल्टर> संदर्भ पृष्ठ देखें।
अपने कोड में (हम onCreate मेथड डिक्लेरेशन के अंदर अनुशंसा करते हैं), निम्नलिखित जोड़ें:
Kotlin+KTX
```
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
}MainActivity.kt
```
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
}MainActivity.java
```
यह आपकी गतिविधि को इसे लॉन्च करने वाले इरादे की जांच करने की अनुमति देता है। आप चाहें तो इस कोड को बाद में भी जोड़ सकते हैं (उदाहरण के लिए, अपने गेम इंजन को शुरू में लोड करने के बाद)।
अनुशंसित: परीक्षण के अंत में, जोड़ें:
Kotlin+KTX
```
yourActivity.finish()MainActivity.kt
```
Java
```
yourActivity.finish();MainActivity.java
```
गेम लूप टेस्ट पूरा होने पर यह आपके ऐप को बंद कर देता है। परीक्षण अगले लूप को शुरू करने के लिए आपके ऐप के यूआई ढांचे पर निर्भर करता है, और आपके ऐप को बंद करने से यह पता चलता है कि परीक्षण समाप्त हो गया है।

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

गेम लूप टेस्ट के लिए अपने ऐप को कॉन्फ़िगर करने के बाद, आप तुरंत एक टेस्ट बना सकते हैं और इसे अपने गेमिंग ऐप में चला सकते हैं। आप या तो Firebase कंसोल या gcloud कमांड लाइन इंटरफ़ेस (CLI) , या टेस्ट लूप मैनेजर का उपयोग करके स्थानीय डिवाइस पर परीक्षण लैब में परीक्षण चलाना चुन सकते हैं।

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

टेस्ट लैब का टेस्ट लूप मैनेजर एक ओपन सोर्स ऐप है जो गेम लूप टेस्ट को एकीकृत करने और उन्हें आपके स्थानीय उपकरणों पर चलाने में आपकी मदद करता है। यह आपकी गुणवत्ता आश्वासन टीम को उनके उपकरणों पर समान गेम लूप चलाने की भी अनुमति देता है।

टेस्ट लूप मैनेजर का उपयोग करके स्थानीय डिवाइस पर टेस्ट चलाने के लिए:

फोन या टैबलेट पर टेस्ट लूप मैनेजर डाउनलोड करें और इसे चलाकर इंस्टॉल करें:
```
adb install testloopmanager.apk
```
अपने डिवाइस पर, अपने फोन या टैबलेट पर टेस्ट लूप ऐप खोलें। ऐप आपके डिवाइस पर उन ऐप्स की सूची प्रदर्शित करता है जिन्हें गेम लूप के साथ चलाया जा सकता है। यदि आप यहां अपना गेमिंग ऐप नहीं देखते हैं, तो सुनिश्चित करें कि आपका इरादा फ़िल्टर आपके शुरू करने से पहले अनुभाग के पहले चरण में वर्णित एक से मेल खाता है।
अपना गेमिंग ऐप चुनें, फिर जितने लूप आप चलाना चाहते हैं, उनकी संख्या चुनें। नोट: इस चरण पर, आप केवल एक लूप के बजाय लूप का सबसेट चलाना चुन सकते हैं। एक साथ कई लूप चलाने के बारे में अधिक जानकारी के लिए, वैकल्पिक विशेषताएँ देखें।
रन टेस्ट पर क्लिक करें। आपका परीक्षण तुरंत चलने लगता है।

टेस्ट लैब में चलाएं

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

फायरबेस कंसोल का प्रयोग करें

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

Firebase कंसोल के साथ आरंभ करने के बारे में अधिक जानकारी के लिए, Firebase कंसोल के साथ परीक्षण प्रारंभ करें देखें।

Gcloud कमांड-लाइन (CLI) का उपयोग करें

यदि आपने पहले से नहीं किया है, तो Google क्लाउड SDK को डाउनलोड और इंस्टॉल करें।
अपने Google खाते का उपयोग करके gcloud CLI में लॉग इन करें:
gcloud auth login
अपने Firebase प्रोजेक्ट को gcloud में सेट करें, जहाँ PROJECT_ID आपके Firebase प्रोजेक्ट की आईडी है:
```
gcloud config set project PROJECT_ID
```
अपना पहला परीक्षण चलाएँ:
```
gcloud firebase test android run \
 --type=game-loop --app=<var>path-to-apk</var> \
 --device model=herolte,version=23
```
नोट: इस चरण पर, आप केवल एक लूप के बजाय लूप का सबसेट चलाना चुन सकते हैं। एक साथ कई लूप चलाने के बारे में अधिक जानकारी के लिए, वैकल्पिक विशेषताएँ देखें।

Gcloud CLI के साथ आरंभ करने के बारे में अधिक जानकारी के लिए, gcloud कमांड लाइन से परीक्षण प्रारंभ करें देखें।

वैकल्पिक विशेषताएं

टेस्ट लैब कई वैकल्पिक सुविधाएँ प्रदान करता है जो आपको अपने परीक्षणों को और अधिक अनुकूलित करने देती हैं, जिसमें आउटपुट डेटा लिखने की क्षमता, कई गेम लूप के लिए समर्थन और संबंधित लूप के लिए लेबल शामिल हैं।

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

आपका गेम लूप टेस्ट launchIntent.getData() विधि में निर्दिष्ट फ़ाइल में आउटपुट लिख सकता है। परीक्षण चलाने के बाद, आप इस आउटपुट डेटा को फायरबेस कंसोल के टेस्ट लैब सेक्शन में एक्सेस कर सकते हैं ( गेम लूप टेस्ट आउटपुट फ़ाइल उदाहरण देखें)।

फ़ाइल साझा करना में वर्णित ऐप्स के बीच फ़ाइल साझा करने के लिए टेस्ट लैब सर्वोत्तम प्रथाओं का पालन करता है। आपकी गतिविधि की onCreate() पद्धति में, जहां आपका इरादा स्थित है, आप निम्न कोड चलाकर अपनी डेटा आउटपुट फ़ाइल की जांच कर सकते हैं:

Kotlin+KTX

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

Java

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

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

Kotlin+KTX

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);MainActivity.kt

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);MainActivity.java

सी ++

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

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

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

{
  "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. टेस्ट लूप मैनेजर ऐप में, एक चयन स्क्रीन दिखाई देती है जो आपको यह चुनने की अनुमति देती है कि आप कौन सा लूप चलाना चाहते हैं। यदि आप एकाधिक लूप चुनते हैं, तो पूर्ववर्ती लूप पूर्ण होने के बाद प्रत्येक लूप अनुक्रम में लॉन्च किया जाता है।
यदि आप फायरबेस कंसोल के साथ एक परीक्षण चला रहे हैं, तो परिदृश्य क्षेत्र में एक सूची या लूप नंबरों की एक श्रेणी दर्ज करें।
यदि आप gcloud CLI के साथ परीक्षण चला रहे हैं, तो --scenario-numbers फ़्लैग का उपयोग करके लूप संख्याओं की एक सूची निर्दिष्ट करें. उदाहरण के लिए, --scenario-numbers=1,3,5 लूप 1, 3 और 5 चलाता है।
यदि आप सी ++ लिख रहे हैं और अपने लूप के व्यवहार को बदलना चाहते हैं, तो निम्न अतिरिक्त को अपने मूल सी ++ कोड में पास करें:
Kotlin+KTX
```
val launchIntent = intent
val scenario = launchIntent.getIntExtra("scenario", 0)MainActivity.kt
```
Java
```
Intent launchIntent = getIntent();
int scenario = launchIntent.getIntExtra("scenario", 0);MainActivity.java
```
अब आप परिणामी int वैल्यू के आधार पर अपने लूप के व्यवहार को बदल सकते हैं।

गेम लूप्स को लेबल करें

जब आप अपने गेम लूप को एक या अधिक परिदृश्य लेबल के साथ लेबल करते हैं, तो आप और आपकी क्यूए टीम आसानी से संबंधित गेम लूप का एक सेट लॉन्च कर सकते हैं (उदाहरण के लिए, "सभी संगतता गेम लूप") और एक ही मैट्रिक्स में उनका परीक्षण कर सकते हैं। आप अपने खुद के लेबल बना सकते हैं या टेस्ट लैब द्वारा प्रस्तावित पूर्वनिर्धारित लेबल का उपयोग कर सकते हैं:

com.google.test.loops.player_experience : लूप के लिए गेम खेलते समय वास्तविक उपयोगकर्ता के अनुभव को पुन: उत्पन्न करने के लिए उपयोग किया जाता है। इन छोरों के साथ परीक्षण का लक्ष्य उन मुद्दों को ढूंढना है जो गेम खेलते समय वास्तविक उपयोगकर्ता का सामना करेंगे।
com.google.test.loops.gpu_compatibility : जीपीयू से संबंधित मुद्दों का परीक्षण करने के लिए उपयोग किए जाने वाले लूप के लिए। इन लूप के साथ परीक्षण का लक्ष्य जीपीयू कोड निष्पादित करना है जो हार्डवेयर और ड्राइवरों के साथ समस्याओं को उजागर करने के लिए उत्पादन में ठीक से नहीं चल सकता है।
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" LABEL_NAME को लूप 1, 3, 4 और 5 पर लागू करता है।
2. टेस्ट लूप मैनेजर ऐप में, लेबल फ़ील्ड में एक या अधिक लेबल दर्ज करें।
यदि आप फायरबेस कंसोल के साथ परीक्षण कर रहे हैं, तो लेबल फ़ील्ड में एक या अधिक लेबल दर्ज करें।
यदि आप gcloud CLI के साथ एक परीक्षण चला रहे हैं, तो --scenario-labels फ़्लैग (उदा., --scenario-labels=performance,gpu ) का उपयोग करके एक या अधिक परिदृश्य लेबल निर्दिष्ट करें।

ऐप लाइसेंसिंग समर्थन

टेस्ट लैब उन ऐप्स का समर्थन करता है जो Google Play द्वारा दी जाने वाली ऐप लाइसेंसिंग सेवा का उपयोग करते हैं। टेस्ट लैब के साथ अपने ऐप का परीक्षण करते समय लाइसेंसिंग की सफलतापूर्वक जांच करने के लिए, आपको अपने ऐप को प्ले स्टोर में प्रोडक्शन चैनल पर प्रकाशित करना होगा। टेस्ट लैब का उपयोग करके अल्फा या बीटा चैनल में अपने ऐप का परीक्षण करने के लिए, अपने ऐप को टेस्ट लैब में अपलोड करने से पहले लाइसेंसिंग चेक को हटा दें।

ज्ञात पहलु

टेस्ट लैब में गेम लूप टेस्ट में निम्नलिखित ज्ञात समस्याएँ हैं:

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