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

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

गेम लूप टेस्ट के बारे में जानकारी

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

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

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

पहला चरण: टेस्ट लैब की कस्टम यूआरएल स्कीम को रजिस्टर करें

  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>

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

दूसरा चरण: विकल्प के तौर पर अपना ऐप्लिकेशन कॉन्फ़िगर करें

एक से ज़्यादा लूप चलाना

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

अगर आपको अपने ऐप्लिकेशन का ऐक्सेस देना है, तो 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).
        }
    }
}

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

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

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

अपनी पसंद के मुताबिक जांच के नतीजे लिखना

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

  • नतीजे वाली सभी फ़ाइलें अपलोड की जाती हैं. भले ही, उनकी फ़ाइल टाइप, साइज़ या संख्या कुछ भी हो.

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

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

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

तीसरा चरण: अपने ऐप्लिकेशन पर साइन करना

  1. पक्का करें कि ऐप्लिकेशन में मौजूद सभी आर्टफ़ैक्ट साइन किए गए हों. उदाहरण के लिए, Xcode की मदद से ऐसा किया जा सकता है. इसके लिए, प्रॉविज़निंग प्रोफ़ाइल और आइडेंटिटी जैसी साइनिंग सेटिंग तय करनी होंगी. ज़्यादा जानकारी के लिए, देखें: Apple Codesign

चौथा चरण: ऐप्लिकेशन अपलोड करने के लिए, उसे पैकेज करना

अपने ऐप्लिकेशन के लिए आईपीए फ़ाइल जनरेट करें (आपको बाद में इसका पता लगाना होगा).

  1. दिखाई देने वाले ड्रॉप-डाउन मेन्यू में, प्रॉडक्ट > संग्रहित करें पर क्लिक करें. सबसे हाल ही का संग्रह चुनें. इसके बाद, ऐप्लिकेशन डिस्ट्रिब्यूट करें पर क्लिक करें.

  2. इसके बाद खुलने वाली विंडो में, डेवलपमेंट > अगला पर क्लिक करें.

  3. ज़रूरी नहीं: तेज़ी से बिल्ड पाने के लिए, बिटकोड से फिर से बनाएं विकल्प से चुने हुए का निशान हटाएं. इसके बाद, आगे बढ़ें पर क्लिक करें. टेस्ट लैब टेस्ट करने के लिए, आपके ऐप्लिकेशन को पतला करने या फिर से बनाने की ज़रूरत नहीं होती, ताकि आप इस विकल्प को सुरक्षित तरीके से बंद कर सकें.

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

पांचवां चरण: ऐप्लिकेशन के हस्ताक्षर की पुष्टि करना

  1. .ipa फ़ाइल को अनज़िप करके ऐप्लिकेशन हस्ताक्षर की पुष्टि करें. इसके बाद, codesign --verify --deep --verbose /path/to/MyApp.app चलाएं. इसमें अनज़िप किए गए फ़ोल्डर में मौजूद ऐप्लिकेशन का नाम "MyApp" होगा. यह हर प्रोजेक्ट के लिए अलग-अलग होता है. अनुमानित आउटपुट MyApp.app: valid on disk है.

छठा चरण: ऐप्लिकेशन की जांच स्थानीय तौर पर करना

टेस्ट लैब के साथ टेस्ट करने से पहले, उसे स्थानीय तौर पर चलाकर देखा जा सकता है कि यह काम करता है या नहीं. स्थानीय तौर पर टेस्ट करने के लिए, अपने गेमिंग ऐप्लिकेशन को सिम्युलेटर में लोड करें और चलाएं:

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

अगले चरण

Firebase कंसोल या gcloud सीएलआई का इस्तेमाल करके टेस्ट करें.