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

iOS के लिए, गेम लूप के टेस्ट शुरू करें

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

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

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

लूप, आपके गेमिंग ऐप्लिकेशन पर टेस्ट का पूरा या कुछ हिस्सा होता है. Test Lab में, किसी सिम्युलेटर पर या डिवाइसों के किसी सेट पर, गेम लूप टेस्ट को लोकल तौर पर चलाया जा सकता है. गेम लूप टेस्ट का इस्तेमाल इन कामों के लिए किया जा सकता है:

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

पहला चरण: Test Lab की कस्टम यूआरएल स्कीम को रजिस्टर करना

सबसे पहले, आपको अपने ऐप्लिकेशन में Firebase Test Lab का कस्टम यूआरएल स्कीम रजिस्टर करना होगा:

Xcode में, कोई प्रोजेक्ट टारगेट चुनें.
जानकारी टैब पर क्लिक करें. इसके बाद, नया यूआरएल टाइप जोड़ें.
यूआरएल स्कीम फ़ील्ड में, firebase-game-loop डालें. कस्टम यूआरएल स्कीम को रजिस्टर करने के लिए, इसे अपने प्रोजेक्ट की Info.plist कॉन्फ़िगरेशन फ़ाइल में जोड़ें. ऐसा करने के लिए, <dict> टैग में कहीं भी जाएं:
```
<key>CFBundleURLTypes</key>
 <array>
     <dict>
         <key>CFBundleURLName</key>
         <string></string>
         <key>CFBundleTypeRole</key>
         <string>Editor</string>
         <key>CFBundleURLSchemes</key>
         <array>
             <string>firebase-game-loop</string>
         </array>
     </dict>
 </array>
```

अब आपके ऐप्लिकेशन को Test Lab का इस्तेमाल करके टेस्ट करने के लिए कॉन्फ़िगर कर दिया गया है.

दूसरा चरण (ज़रूरी नहीं): एक से ज़्यादा लूप चलाने के लिए, अपने ऐप्लिकेशन को कॉन्फ़िगर करना

अगर आपके ऐप्लिकेशन में कई कस्टम यूआरएल स्कीम रजिस्टर हैं और आपको अपने टेस्ट में कई लूप (जिन्हें परिदृश्य भी कहा जाता है) चलाने हैं, तो आपको यह बताना होगा कि आपको लॉन्च के समय अपने ऐप्लिकेशन में कौनसे लूप चलाने हैं.

अगर आपको अपने ऐप्लिकेशन का ऐक्सेस दूसरों को देना है, तो application(_:open:options:) तरीके को बदलें:

Swift

func application(_app: UIApplication,
                 open url: URL
                 options: [UIApplication.OpenURLOptionsKey : Any] = [:]) -> Bool {
    let components = URLComponents(url: url, resolvingAgainstBaseURL: true)!
    if components.scheme == "firebase-game-loop" {
        // ...Enter Game Loop Test logic to override application(_:open:options:).
    }
    return true
}

Objective-C

- (BOOL)application:(UIApplication *)app
            openURL:(NSURL *)url
            options:(NSDictionary &lt;UIApplicationOpenURLOptionsKey, id&gt; *)options {
  if ([url.scheme isEqualToString:(@"firebase-game-loop")]) {
      // ...Enter Game Loop Test logic to override application(_:open:options:).
  }
}

अपने टेस्ट में कई लूप चलाने पर, मौजूदा लूप को ऐप्लिकेशन लॉन्च करने के लिए इस्तेमाल किए गए यूआरएल में पैरामीटर के तौर पर पास किया जाता है. कस्टम यूआरएल स्कीमा को फ़ेच करने के लिए इस्तेमाल किए गए URLComponents ऑब्जेक्ट को पार्स करके, मौजूदा लूप नंबर भी पाया जा सकता है:

Swift

if components.scheme == "firebase-game-loop" {
    // Iterate over all parameters and find the one with the key "scenario".
    let scenarioNum = Int(components.queryItems!.first(where: { $0.name == "scenario" })!.value!)!
    // ...Write logic specific to the current loop (scenarioNum).
}

Objective-C

if ([url.scheme isEqualToString:(@"firebase-game-loop")]) {
    // Launch the app as part of a game loop.
    NSURLComponents *components = [NSURLComponents componentsWithURL:url
                                             resolvingAgainstBaseURL:YES];
    for (NSURLQueryItem *item in [components queryItems]) {
        if ([item.name isEqualToString:@"scenario"]) {
            NSInteger scenarioNum = [item.value integerValue];
            // ...Write logic specific to the current loop (scenarioNum).
        }
    }
}

तीसरा चरण: टेस्ट बनाना और चलाना

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

अपने ऐप्लिकेशन के लिए IPA जनरेट करना

Xcode में, टारगेट किए गए ऐप्लिकेशन के लिए कोई प्रॉविज़निंग प्रोफ़ाइल चुनें.
ध्यान दें: Test Lab, आपके ऐप्लिकेशन पर अपनी प्रावधान प्रोफ़ाइल और सर्टिफ़िकेट का इस्तेमाल करके फिर से साइन करता है.
इसके बाद, दिखने वाले ड्रॉप-डाउन मेन्यू में, प्रॉडक्ट > संग्रह करें पर क्लिक करें. सबसे हाल ही का संग्रह चुनें. इसके बाद, ऐप्लिकेशन उपलब्ध कराएं पर क्लिक करें.
इसके बाद, खुलने वाली विंडो में डेवलपमेंट > अगला पर क्लिक करें.
ज़रूरी नहीं: तेज़ी से बिल्ड पाने के लिए, बिटकोड से फिर से बनाएं विकल्प से चुने हुए का निशान हटाएं. इसके बाद, आगे बढ़ें पर क्लिक करें. Test Lab को जांच करने के लिए, ऐप्लिकेशन को छोटा करने या फिर से बनाने की ज़रूरत नहीं होती. इसलिए, आपके पास इस विकल्प को सुरक्षित तरीके से बंद करने का विकल्प होता है.
एक्सपोर्ट करें पर क्लिक करें. इसके बाद, वह डायरेक्ट्री डालें जिसमें आपको अपने ऐप्लिकेशन की IPA फ़ाइल डाउनलोड करनी है.

Firebase कंसोल में टेस्ट चलाना

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

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

gcloud के बीटा वर्शन वाले CLI की मदद से टेस्ट करना

अगर आपने अब तक ऐसा नहीं किया है, तो अपने लोकल gcloud SDK एनवायरमेंट को कॉन्फ़िगर करें. इसके बाद, gcloud बीटा कॉम्पोनेंट को ज़रूर इंस्टॉल करें.
gcloud beta firebase test ios run कमांड चलाएं और रन को कॉन्फ़िगर करने के लिए, इन फ़्लैग का इस्तेमाल करें:

गेम लूप टेस्ट के लिए फ़्लैग
`--type`	ज़रूरी है: इससे पता चलता है कि आपको किस तरह का iOS टेस्ट चलाना है. जांच के टाइप के तौर पर, `xctest` (डिफ़ॉल्ट) या `game-loop` डाला जा सकता है.
`--app`	ज़रूरी है: आपके ऐप्लिकेशन की आईपीए फ़ाइल का ऐब्सलूट पाथ (Google Cloud Storage या फ़ाइल सिस्टम). यह फ़्लैग सिर्फ़ तब मान्य होता है, जब गेम लूप टेस्ट चलाए जा रहे हों.
`--scenario-numbers`	वे लूप (यानी कि स्थितियां) जिन्हें आप अपने ऐप्लिकेशन में चलाना चाहते हैं. आप एक लूप, एक सूची या लूप या लूप की एक सीमा डाल सकते हैं. डिफ़ॉल्ट लूप 1 है. उदाहरण के लिए, `--scenario-numbers=1-3,5` लूप 1, 2, 3, और 5 चलाता है.
`--device-model`	वह डिवाइस जिस पर आपको टेस्ट कराना है (पता करें कि उपलब्ध डिवाइसों का इस्तेमाल किन डिवाइसों पर किया जा सकता है).
`--timeout`	वह ज़्यादा से ज़्यादा अवधि जिस दौरान आपको अपना टेस्ट चलाना है. कुल समय को सेकंड में दिखाने के लिए, कोई पूर्णांक डाला जा सकता है. इसके अलावा, कुल समय को लंबी समयावधि की इकाई के तौर पर दिखाने के लिए, कोई पूर्णांक और गिनती डाली जा सकती है. उदाहरण के लिए: `--timeout=200`, 200 सेकंड तक चलने के बाद आपके टेस्ट को बंद कर देता है. `--timeout=1h`, एक घंटे तक चलने के बाद आपके टेस्ट को बंद कर देता है.

उदाहरण के लिए, यह कमांड गेम लूप टेस्ट चलाता है, जो iPhone 8 Plus पर लूप 1, 4, 6, 7, और 8 को चलाता है:

gcloud beta firebase test ios run
 --type game-loop --app path/to/my/App.ipa --scenario-numbers 1,4,6-8
 --device-model=iphone8plus

gcloud सीएलआई के बारे में ज़्यादा जानकारी के लिए रेफ़रंस दस्तावेज़ देखें.

स्थानीय तौर पर टेस्ट चलाना

स्थानीय तौर पर टेस्ट चलाने के लिए, अपने गेमिंग ऐप्लिकेशन को सिम्युलेटर में लोड करें और चलाएं:

xcrun simctl openurl SIMULATOR_UDID firebase-game-loop://

instruments -s devices कमांड चलाकर, अपने सिम्युलेटर का यूडीआईडी पाया जा सकता है.
अगर सिर्फ़ एक सिम्युलेटर चल रहा है, तो SIMULATOR_UDID के बजाय खास स्ट्रिंग "booted" डालें.

अगर आपके टेस्ट में एक से ज़्यादा लूप हैं, तो scenario फ़्लैग में लूप नंबर डालकर यह तय किया जा सकता है कि आपको कौनसा लूप चलाना है. ध्यान दें कि स्थानीय तौर पर जांच करते समय, एक बार में सिर्फ़ एक लूप चलाया जा सकता है. उदाहरण के लिए, अगर आपको पहला, दूसरा, और पांचवां लूप चलाना है, तो आपको हर लूप के लिए एक अलग निर्देश चलाना होगा:

xcrun simctl openurl SIMULATOR_UDID firebase-game-loop://?scenario=1
xcrun simctl openurl SIMULATOR_UDID firebase-game-loop://?scenario=2
xcrun simctl openurl SIMULATOR_UDID firebase-game-loop://?scenario=5

टेस्ट को जल्दी खत्म करना

डिफ़ॉल्ट रूप से, गेम लूप टेस्ट तब तक चलता रहता है, जब तक कि टाइम आउट की अवधि पांच मिनट नहीं हो जाती. भले ही, सभी लूप लागू कर दिए गए हों. समय खत्म होने पर, टेस्ट खत्म हो जाता है और उन लूप को रद्द कर दिया जाता है जिन्हें मंज़ूरी मिलना बाकी है. अपने ऐप्लिकेशन के AppDelegate में Test Lab की कस्टम यूआरएल स्कीमfirebase-game-loop-complete को कॉल करके, टेस्ट को जल्दी पूरा किया जा सकता है या टेस्ट को जल्दी खत्म किया जा सकता है. उदाहरण के लिए:

Swift

/// End the loop by calling our custom url scheme.
func finishLoop() {
    let url = URL(string: "firebase-game-loop-complete://")!
    UIApplication.shared.open(url)
}

Objective-C

- (void)finishLoop {
  UIApplication *app = [UIApplication sharedApplication];
  [app openURL:[NSURL URLWithString:@"firebase-game-loop-complete://"]
      options:@{}
completionHandler:^(BOOL success) {}];
}

गेम लूप की जांच, मौजूदा लूप को खत्म करके अगले लूप को लागू करती है. जब चलाने के लिए कोई और लूप नहीं रह जाता, तब जांच खत्म हो जाती है.

जांच के कस्टम नतीजे लिखना

अपने डिवाइस के फ़ाइल सिस्टम में, पसंद के मुताबिक टेस्ट के नतीजे लिखने के लिए, अपने गेम लूप टेस्ट को कॉन्फ़िगर किया जा सकता है. इस तरह, जब टेस्ट शुरू होता है, तो Test Lab नतीजों की फ़ाइलों को आपके टेस्टिंग डिवाइस पर GameLoopsResults डायरेक्ट्री में सेव करता है. यह डायरेक्ट्री आपको खुद बनानी होगी. टेस्ट खत्म होने के बाद, Test Lab सभी फ़ाइलों को GameLoopResults डायरेक्ट्री से आपके प्रोजेक्ट की बकेट में ले जाता है. टेस्ट सेट अप करते समय, इन बातों का ध्यान रखें:

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

कस्टम टेस्ट के नतीजे लिखने के लिए, अपना टेस्ट सेट अप करने के लिए:

अपने ऐप्लिकेशन की Documents डायरेक्ट्री में, GameLoopResults नाम की एक डायरेक्ट्री बनाएं.

अपने ऐप्लिकेशन के कोड में कहीं भी (जैसे, आपके ऐप्लिकेशन डेलीगेट में), ये जोड़ें:

Swift

/// Write to a results file.
func writeResults() {
  let text = "Greetings from game loops!"
  let fileName = "results.txt"
  let fileManager = FileManager.default
  do {

  let docs = try fileManager.url(for: .documentDirectory,
                                 in: .userDomainMask,
                                 appropriateFor: nil,
                                 create: true)
  let resultsDir = docs.appendingPathComponent("GameLoopResults")
  try fileManager.createDirectory(
      at: resultsDir,
      withIntermediateDirectories: true,
      attributes: nil)
  let fileURL = resultsDir.appendingPathComponent(fileName)
  try text.write(to: fileURL, atomically: false, encoding: .utf8)
  } catch {
    // ...Handle error writing to file.
  }
}

Objective-C

/// Write to a results file.
- (void)writeResults:(NSString *)message {
    // Locate and create the results directory (if it doesn't exist already).
    NSFileManager *manager = [NSFileManager defaultManager];
    NSURL* url = [[manager URLsForDirectory:NSDocumentDirectory
                                  inDomains:NSUserDomainMask] lastObject];
    NSURL* resultsDir = [url URLByAppendingPathComponent:@"GameLoopResults"
                                             isDirectory:YES];
    [manager createDirectoryAtURL:resultsDir
      withIntermediateDirectories:NO
                       attributes:nil
                            error:nil];

    // Write the result message to a text file.
    NSURL* resultFile = [resultsDir URLByAppendingPathComponent:@"result.txt"];
    if ([manager fileExistsAtPath:[resultFile path]]) {
        // Append to the existing file
        NSFileHandle *handle = [NSFileHandle fileHandleForWritingToURL:resultFile
                                                                 error:nil];
        [handle seekToEndOfFile];
        [handle writeData:[message dataUsingEncoding:NSUTF8StringEncoding]];
        [handle closeFile];
    } else {
        // Create and write to the file.
        [message writeToURL:resultFile
                 atomically:NO
                   encoding:NSUTF8StringEncoding error:nil];
    }
}