IOS के लिए गेम लूप परीक्षण शुरू करें

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

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

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

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

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

  • यह पता लगाने के लिए कि कौन से डिवाइस इसका समर्थन कर सकते हैं, अपने गेम को उच्चतम गुणवत्ता सेटिंग पर चलाएं।

  • एक तकनीकी परीक्षण चलाएँ, जैसे कई शेडर्स को संकलित करना, उन्हें निष्पादित करना और जाँचना कि आउटपुट अपेक्षा के अनुरूप है।

चरण 1: टेस्ट लैब की कस्टम यूआरएल योजना पंजीकृत करें

सबसे पहले, आपको अपने ऐप में फायरबेस टेस्ट लैब की कस्टम यूआरएल योजना पंजीकृत करनी होगी:

  1. Xcode में, एक प्रोजेक्ट लक्ष्य चुनें।

  2. जानकारी टैब पर क्लिक करें, फिर एक नया URL प्रकार जोड़ें।

  3. यूआरएल स्कीम फ़ील्ड में, firebase-game-loop दर्ज करें। आप कस्टम URL योजना को अपने प्रोजेक्ट की 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>
    

आपका ऐप अब टेस्ट लैब का उपयोग करके परीक्षण चलाने के लिए कॉन्फ़िगर किया गया है।

चरण 2 (वैकल्पिक): एकाधिक लूप चलाने के लिए अपने ऐप को कॉन्फ़िगर करें

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

अपने ऐप प्रतिनिधि में, 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 &lt;UIApplicationOpenURLOptionsKey, id&gt; *)options {
  if ([url.scheme isEqualToString:(@"firebase-game-loop")]) {
      // ...Enter Game Loop Test logic to override application(_:open:options:).
  }
}

जब आप अपने परीक्षण में एकाधिक लूप चलाते हैं, तो वर्तमान लूप को ऐप लॉन्च करने के लिए उपयोग किए गए यूआरएल के पैरामीटर के रूप में पास किया जाता है। आप कस्टम URL योजना लाने के लिए उपयोग किए गए 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).
        }
    }
}

चरण 3: एक परीक्षण बनाएं और चलाएं

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

फायरबेस कंसोल में एक परीक्षण चलाएँ

  1. यदि आपने पहले से नहीं किया है, तो फायरबेस कंसोल खोलें और एक प्रोजेक्ट बनाएं।

  2. फायरबेस कंसोल के टेस्ट लैब पेज पर, अपना पहला टेस्ट चलाएँ > iOS गेम लूप चलाएँ पर क्लिक करें।

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

  4. वैकल्पिक : यदि आप एक समय में एकाधिक लूप (उर्फ परिदृश्य) चलाना चाहते हैं या चलाने के लिए विशिष्ट लूप का चयन करना चाहते हैं, तो परिदृश्य फ़ील्ड में लूप संख्याएं दर्ज करें।

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

  5. डिवाइस अनुभाग में, एक या अधिक भौतिक डिवाइस चुनें जिन पर आप अपने ऐप का परीक्षण करना चाहते हैं, फिर परीक्षण प्रारंभ करें पर क्लिक करें।

Gcloud बीटा CLI के साथ एक परीक्षण चलाएँ

  1. यदि आपने पहले से ही अपने स्थानीय gcloud SDK वातावरण को कॉन्फ़िगर नहीं किया है, तो gcloud बीटा घटक स्थापित करना सुनिश्चित करें।

  2. gcloud beta firebase test ios run कमांड चलाएँ और रन को कॉन्फ़िगर करने के लिए निम्नलिखित फ़्लैग का उपयोग करें:

गेम लूप परीक्षणों के लिए झंडे
--type

आवश्यक : निर्दिष्ट करता है कि आप किस प्रकार का iOS परीक्षण चलाना चाहते हैं। आप परीक्षण प्रकार xctest (डिफ़ॉल्ट) या game-loop दर्ज कर सकते हैं।

--app

आवश्यक : आपके ऐप की आईपीए फ़ाइल के लिए पूर्ण पथ (Google क्लाउड स्टोरेज या फ़ाइल सिस्टम)। यह ध्वज केवल गेम लूप परीक्षण चलाते समय मान्य है।

--scenario-numbers

वे लूप (उर्फ परिदृश्य) जिन्हें आप अपने ऐप में चलाना चाहते हैं। आप एक लूप, एक सूची या लूप, या लूप की एक श्रृंखला दर्ज कर सकते हैं। डिफ़ॉल्ट लूप 1 है.

उदाहरण के लिए, --scenario-numbers=1-3,5 लूप 1, 2, 3 और 5 चलाता है।

--device-model

वह भौतिक उपकरण जिस पर आप अपना परीक्षण चलाना चाहते हैं (पता लगाएं कि आप किन उपलब्ध उपकरणों का उपयोग कर सकते हैं)।

--timeout

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

उदाहरण के लिए:

  • --timeout=200 आपके परीक्षण को 200 सेकंड तक चलने पर समाप्त करने के लिए बाध्य करता है।
  • --timeout=1h आपके परीक्षण को एक घंटे तक चलने पर समाप्त करने के लिए बाध्य करता है।

उदाहरण के लिए, निम्न कमांड एक गेम लूप टेस्ट चलाता है जो आईफोन 8 प्लस पर लूप 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

जीक्लाउड सीएलआई पर अधिक जानकारी के लिए संदर्भ दस्तावेज देखें।

स्थानीय स्तर पर एक परीक्षण चलाएँ

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

xcrun simctl openurl SIMULATOR_UDID firebase-game-loop://
  • आप instruments -s devices कमांड चलाकर अपने सिम्युलेटर का UDID पा सकते हैं।

  • यदि केवल एक सिम्युलेटर चल रहा है, तो 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-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) {}];
}

आपका गेम लूप परीक्षण वर्तमान लूप को समाप्त करता है और अगले लूप को निष्पादित करता है। जब चलाने के लिए कोई लूप नहीं रह जाता, तो परीक्षण समाप्त हो जाता है।

कस्टम परीक्षण परिणाम लिखें

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

  • सभी परिणाम फ़ाइलें फ़ाइल प्रकार, आकार या मात्रा की परवाह किए बिना अपलोड की जाती हैं।

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

कस्टम परीक्षण परिणाम लिखने के लिए अपना परीक्षण सेट अप करने के लिए:

  1. अपने ऐप की Documents निर्देशिका में, GameLoopResults नामक एक निर्देशिका बनाएं।

  2. अपने ऐप के कोड में कहीं से भी (उदाहरण के लिए, आपका ऐप प्रतिनिधि), निम्नलिखित जोड़ें:

    तीव्र

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

    उद्देश्य सी

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