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

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

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

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

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

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

• अपने गेम को सबसे अच्छी क्वालिटी वाली सेटिंग पर चलाएं, ताकि यह पता चल सके कि किन डिवाइसों पर यह गेम काम कर सकता है.

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

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

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

1. Xcode में, कोई प्रोजेक्ट टारगेट चुनें.

2. जानकारी टैब पर क्लिक करें. इसके बाद, नया यूआरएल टाइप जोड़ें.

3. यूआरएल स्कीम फ़ील्ड में, 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:) तरीके को बदलें:

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
}

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

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

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).
}

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 beta CLI की मदद से टेस्ट चलाया जा सकता है. अगर आपने अब तक ऐसा नहीं किया है, तो अपने ऐप्लिकेशन के लिए एक IPA फ़ाइल जनरेट करें. आपको बाद में इसे ढूंढना होगा.

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

1. Firebase कंसोल में, DevOps और यूज़र ऐक्टिविटी > Test Lab पर जाएं.

2. Run Your First Test > Run an iOS Game Loop पर क्लिक करें.

3. ऐप्लिकेशन अपलोड करें सेक्शन में, ब्राउज़ करें पर क्लिक करें. इसके बाद, अपने ऐप्लिकेशन की IPA फ़ाइल चुनें. अगर आपने अब तक IPA फ़ाइल नहीं बनाई है, तो अपने ऐप्लिकेशन के लिए IPA फ़ाइल जनरेट करें.

4. (ज़रूरी नहीं) अगर आपको एक बार में कई लूप (यानी कि स्थितियां) चलाने हैं या चलाने के लिए खास लूप चुनने हैं, तो स्थितियां फ़ील्ड में लूप नंबर डालें.

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

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

gcloud beta सीएलआई की मदद से टेस्ट करना

1. अगर आपने अब तक ऐसा नहीं किया है, तो अपने लोकल gcloud SDK टूल के एनवायरमेंट को कॉन्फ़िगर करें. इसके बाद, gcloud बीटा कॉम्पोनेंट इंस्टॉल करें.

2. gcloud beta firebase test ios run कमांड चलाएं और रन को कॉन्फ़िगर करने के लिए, ��न फ़्लैग का इस्तेमाल करें:

उदाहरण के लिए, यहां दिया गया निर्देश, 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 फ़्लैग में लूप नंबर डालकर, यह तय किया जा सकता है कि आपको कौनसा लूप चलाना है. ध्यान दें कि टेस्ट को स्थानीय तौर पर चलाते समय, एक बार में सिर्फ़ एक लूप चलाया जा सकता है. उदाहरण के लिए, अगर आपको लूप 1, 2, और 5 चलाने हैं, तो आपको हर लूप के लिए अलग-अलग कमांड चलाना होगा:

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 को कॉल करके, टेस्ट को तेज़ी से पूरा किया जा सकता है या उसे जल्दी खत्म किया जा सकता है. उदाहरण के लिए:

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

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

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

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

2. अपने ऐप्लिकेशन के कोड में क��ीं ��ी (उदाहरण के लिए, ��पके ��प्लिकेशन डेलिगेट में), यह जोड़ें:

   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];
       }
   }