Google ใช้เทคโนโลยี AI เพื่อแปลเนื้อหาเป็นภาษาที่คุณต้องการ การแปลโดย AI อาจมีข้อผิดพลาด

เริ่มต้นใช้งานการทดสอบ Game Loop

การทดสอบเกมอัตโนมัติอาจทำได้ยากหากแอปเกมสร้างขึ้นบนเฟรมเวิร์ก UI ที่แตกต่างกัน การทดสอบ Game Loop ช่วยให้คุณผสานรวมการทดสอบเนทีฟกับ Test Lab และเรียกใช้การทดสอบเหล่านั้นในอุปกรณ์ที่เลือกได้อย่างง่ายดาย การทดสอบ Game Loop จะเรียกใช้การทดสอบผ่านแอปเกมของคุณขณะจำลองการดำเนินการของผู้เล่นจริง คู่มือนี้จะแสดงวิธีเรียกใช้การทดสอบ Game Loop จากนั้นดูและจัดการผลการทดสอบ ในคอนโซล Firebase

การทดสอบ Game Loop คืออะไร

เนื่องจากแอปเกมแสดงผลในเฟรมเวิร์กและเอนจิน UI ที่แตกต่างกัน เช่น Unity, Unreal หรือโค้ด C++ ของ OpenGL/Vulkan เครื่องมือการทำงานอัตโนมัติมาตรฐานจึงตรวจสอบหรือโต้ตอบกับองค์ประกอบ UI ไม่ได้ การทดสอบ Game Loop ช่วยให้คุณผสานรวม การทดสอบเอนจินเนทีฟกับ Test Lab ได้ด้วยการเปิดเกมด้วย Intent ที่มีหมายเลขสถานการณ์ ที่เฉพาะเจาะจง หมายเลขสถานการณ์นี้จะแจ้งให้แอปเรียกใช้ตรรกะที่เขียนสคริปต์ไว้ล่วงหน้า การจำลอง AI หรือการตรวจสอบประสิทธิภาพภายในเกมเอนจินโดยตรง

เมื่อเปิดตัวแล้ว Test Lab จะไม่โต้ตอบกับ UI ของเกมอีก แต่ Test Lab จะทำหน้าที่เป็นตัวกลางและสภาพแวดล้อมในการทดสอบ โดยจะเปิดตัวสถานการณ์ที่ เฉพาะเจาะจง ตรวจสอบการขัดข้องและหมดเวลา รวมถึงรวบรวมบันทึกผลลัพธ์ที่กำหนดเอง เมื่อแอปเรียกใช้ลูปเสร็จ

Game Loop แตกต่างจากการทดสอบเครื่องมืออย่างไร

การทดสอบการวัดคุม (เช่น Espresso หรือ UI Automator) อาศัยเฟรมเวิร์กภายนอกเพื่อขับเคลื่อนการโต้ตอบ UI, คลิกปุ่ม และยืนยันสถานะแอปพลิเคชันในลำดับชั้นการแสดงผลของ Android จากภายนอกแอป
การทดสอบ Game Loop มอบหมายตรรกะการทดสอบให้กับแอป โดยแอปจะเรียกใช้ ลูปหรือการจำลองการทดสอบภายในของตัวเองโดยไม่มีการโต้ตอบ UI ภายนอก ขณะที่ Test Lab จะทริกเกอร์สถานการณ์และรวบรวมเอาต์พุตการทดสอบ

ตัวอย่าง

สมมติว่าคุณต้องการตรวจสอบว่าเกมยังคงรักษาอัตราเฟรมอย่างน้อย 60 เฟรมต่อวินาทีในอุปกรณ์จริงต่างๆ คุณสามารถใช้สถานการณ์ 1 ภายในโค้ดเกมเพื่อโหลดระดับที่ซับซ้อนที่สุดในเชิงภาพและให้ผู้เล่น AI หรือสคริปต์อัตโนมัติเล่นผ่านระดับนั้นเป็นเวลา 2 นาที

เมื่อ Test Lab ทริกเกอร์สถานการณ์ 1 เกมจะเริ่มเล่น AI ตรวจสอบเวลาในการแสดงผลเฟรมและการใช้งานหน่วยความจำ สตรีมเมตริกเหล่านั้นไปยังไฟล์บันทึกเอาต์พุตที่กำหนดเอง (logFile) และเรียกใช้ finish() เมื่อเสร็จสมบูรณ์ Test Lab จากนั้นจะบันทึกไฟล์บันทึกและทำให้ไฟล์ดังกล่าวพร้อมใช้งานสำหรับคุณใน Cloud Storage และคอนโซล Firebase

Use Case

คุณสามารถใช้การทดสอบที่มีลูปเดียวหรือหลายลูปได้ ทั้งนี้ขึ้นอยู่กับเกมเอนจินของคุณ ลูปคือการเรียกใช้การทดสอบในแอปเกมแบบเต็มหรือบางส่วน โดยคุณสามารถใช้ Game Loop เพื่อทำสิ่งต่อไปนี้

เรียกใช้ระดับของเกมในลักษณะเดียวกับที่ผู้ใช้ปลายทางจะเล่น คุณสามารถเขียนสคริปต์อินพุตของผู้ใช้ ปล่อยให้ผู้ใช้ไม่ได้ใช้งาน หรือแทนที่ผู้ใช้ด้วย AI หากเหมาะสมกับเกม (เช่น หากคุณมีแอปเกมรถแข่งและใช้ AI อยู่แล้ว คุณสามารถให้ AI เป็นผู้ขับแทนอินพุตของผู้ใช้ได้)
เรียกใช้เกมด้วยการตั้งค่าคุณภาพสูงสุดเพื่อดูว่าอุปกรณ์รองรับหรือไม่
เรียกใช้การทดสอบทางเทคนิค (คอมไพล์เชเดอร์หลายรายการ เรียกใช้เชเดอร์เหล่านั้น ตรวจสอบว่าเอาต์พุตเป็นไปตามที่คาดไว้ และอื่นๆ)

คุณสามารถเรียกใช้การทดสอบ Game Loop ในอุปกรณ์ทดสอบเครื่องเดียว อุปกรณ์ทดสอบหลายเครื่อง หรือ ใน Test Lab อย่างไรก็ตาม เราไม่แนะนำให้เรียกใช้การทดสอบ Game Loop ในอุปกรณ์เสมือนเนื่องจากอุปกรณ์เสมือนมีอัตราเฟรมกราฟิกต่ำกว่าอุปกรณ์จริง

ก่อนเริ่มต้น

หากต้องการใช้การทดสอบ คุณต้องกำหนดค่าแอปสำหรับการทดสอบ Game Loop ก่อน

ในไฟล์ Manifest ของแอป ให้เพิ่มตัวกรอง Intent ใหม่ลงใน กิจกรรม
```
<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>
```
ซึ่งจะช่วยให้ Test Lab เปิดเกมได้โดยการทริกเกอร์ด้วย Intent ที่เฉพาะเจาะจง

หมายเหตุ: Game Loop ต้องใช้ตัวกรอง Intent ที่แยกต่างหากและเฉพาะเจาะจงซึ่งไม่ได้ใช้ เพื่อวัตถุประสงค์อื่น กิจกรรมของคุณอาจมีตัวกรอง Intent อื่นๆ ดูข้อมูลเพิ่มเติมเกี่ยวกับตัวกรอง Intent ได้ที่หน้าอ้างอิง <intent-filter>
เพิ่มโค้ดต่อไปนี้ในโค้ด (เราแนะนำให้เพิ่มภายในประกาศเมธอด onCreate)
Kotlin
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
ซึ่งจะช่วยให้กิจกรรมตรวจสอบ Intent ที่เปิดตัวกิจกรรมได้ นอกจากนี้ คุณยังเพิ่มโค้ดนี้ในภายหลังได้หากต้องการ (เช่น หลังจากโหลดเอนจินเกมในตอนแรก)
แนะนำ: เพิ่มโค้ดต่อไปนี้เมื่อสิ้นสุดการทดสอบ
Kotlin
yourActivity.finish()
MainActivity.kt
Java
yourActivity.finish();
MainActivity.java
ซึ่งจะปิดแอปเมื่อการทดสอบ Game Loop เสร็จสมบูรณ์ การทดสอบอาศัยเฟรมเวิร์ก UI ของแอปเพื่อเริ่มลูปถัดไป และการปิดแอปจะบอกเฟรมเวิร์กว่าการทดสอบเสร็จแล้ว

สร้างและเรียกใช้การทดสอบ Game Loop

หลังจากกำหนดค่าแอปสำหรับการทดสอบ Game Loop แล้ว คุณจะสร้างการทดสอบและเรียกใช้การทดสอบในแอปเกมได้ทันที โดยคุณสามารถเลือกเรียกใช้การทดสอบใน Test Lab ได้โดยใช้Firebase คอนโซล หรือgcloud อินเทอร์เฟซบรรทัดคำสั่ง (CLI) หรือในอุปกรณ์ในเครื่องโดยใช้ Test Loop Manager

เรียกใช้ในอุปกรณ์ในเครื่อง

Test Lab**Test Loop Manager** ของ Test Lab's เป็นแอปโอเพนซอร์สที่ช่วยให้คุณ ผสานรวมการทดสอบ Game Loop และเรียกใช้การทดสอบเหล่านั้นในอุปกรณ์ในเครื่องได้ นอกจากนี้ยังช่วยให้ทีมประกันคุณภาพเรียกใช้ Game Loop เดียวกันในอุปกรณ์ของทีมได้ด้วย

วิธีเรียกใช้การทดสอบในอุปกรณ์ในเครื่องโดยใช้ Test Loop Manager

ดาวน์โหลด Test Loop Manager ในโทรศัพท์หรือแท็บเล็ต แล้วติดตั้งโดยเรียกใช้คำสั่งต่อไปนี้
```
adb install testloopmanager.apk
```
เปิดแอป Test Loop Apps ในโทรศัพท์หรือแท็บเล็ต แอปจะแสดงรายการแอปในอุปกรณ์ที่เรียกใช้ด้วย Game Loop ได้ หากไม่เห็นแอปเกมที่นี่ ให้ตรวจสอบว่า ตัวกรอง Intent ตรงกับตัวกรองที่อธิบายไว้ในขั้นตอนแรกของ ส่วนก่อนเริ่มต้น
เลือกแอปเกม จากนั้นเลือกจำนวนลูปที่ต้องการเรียกใช้ หมายเหตุ: ในขั้นตอนนี้ คุณสามารถเลือกเรียกใช้ลูปบางส่วนแทนที่จะเรียกใช้เพียงลูปเดียว ดูข้อมูลเพิ่มเติมเกี่ยวกับการเรียกใช้หลายลูปพร้อมกันได้ที่ ฟีเจอร์เสริม
คลิกเรียกใช้การทดสอบ การทดสอบจะเริ่มทำงานทันที

เรียกใช้ใน Test Lab

คุณสามารถเรียกใช้การทดสอบ Game Loop ใน Test Lab ได้โดยใช้ Firebase คอนโซล หรือ gcloud CLI ก่อนเริ่มต้น ให้เปิดFirebase คอนโซล และสร้างโปรเจ็กต์ หากยังไม่ได้สร้าง

ใช้คอนโซล Firebase

ในคอนโซล Firebase ให้คลิก Test Lab จากแผงด้านซ้าย
คลิกเรียกใช้การทดสอบครั้งแรก (หรือเรียกใช้การทดสอบ หากโปรเจ็กต์เคยเรียกใช้การทดสอบ)
เลือก Game Loop เป็นประเภทการทดสอบ แล้วคลิกดำเนินการต่อ
คลิกเรียกดู แล้วเรียกดูไฟล์ .apk ของแอป หมายเหตุ: ในขั้นตอนนี้ คุณสามารถเลือกเรียกใช้ลูปบางส่วนแทนที่จะเรียกใช้เพียงลูปเดียว ดูข้อมูลเพิ่มเติมเกี่ยวกับการเรียกใช้หลายลูปพร้อมกันได้ที่ ฟีเจอร์เสริม
คลิกดำเนินการต่อ
เลือกอุปกรณ์จริงที่จะใช้ทดสอบแอป
คลิกเริ่มการทดสอบ

ดูข้อมูลเพิ่มเติมเกี่ยวกับการเริ่มต้นใช้งานคอนโซล Firebase ได้ที่ หัวข้อเริ่มการทดสอบด้วยคอนโซล Firebase.

ใช้บรรทัดคำสั่ง (CLI) ของ gcloud

ดาวน์โหลดและติดตั้ง Google Cloud SDK
ลงชื่อเข้าใช้ gcloud CLI ด้วยบัญชี Google โดยใช้คำสั่งต่อไปนี้

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

ฟีเจอร์เสริม

Test Lab มีฟีเจอร์เสริมหลายอย่างที่ช่วยให้คุณปรับแต่งการทดสอบ เพิ่มเติมได้ ซึ่งรวมถึงความสามารถในการเขียนข้อมูลเอาต์พุต การรองรับ Game Loop หลายรายการ และป้ายกำกับสำหรับลูปที่เกี่ยวข้อง

เขียนข้อมูลเอาต์พุต

เมื่อ Test Lab เปิดเกม ระบบจะระบุ URL ที่ชี้ไปยังไฟล์ผลลัพธ์ในเครื่อง ในอุปกรณ์ทดสอบ ซึ่งเข้าถึงได้โดยใช้ launchIntent.getData() เกมสามารถเขียนผลการทดสอบ เมตริกประสิทธิภาพ และบันทึก (logFile) ไปยังตำแหน่งนี้โดยตรงระหว่างการเรียกใช้การทดสอบ

คุณสามารถเขียน เนื้อหาที่กำหนดเอง ลงใน logFile ได้ เช่น ข้อความธรรมดา ข้อมูล CSV, เวลาในการแสดงผลเฟรม หรือรายงานการวินิจฉัยที่กำหนดเอง เนื้อหาที่คุณเขียนไม่มีข้อจำกัดหรือข้อกำหนดด้านการจัดรูปแบบ โดยระบบจะบันทึกไฟล์เมื่อการทดสอบเสร็จสิ้นและอัปโหลดไฟล์ไปยัง Bucket ของ Cloud Storage พร้อมกับอาร์ติแฟกต์การทดสอบอื่นๆ

Test Lab ปฏิบัติตามแนวทางปฏิบัติแนะนำที่กำหนดไว้สำหรับการแชร์ไฟล์ระหว่างแอป ตามที่อธิบายไว้ใน การแชร์ไฟล์ ในเมธอด onCreate() ของกิจกรรม ซึ่งเป็นตำแหน่งที่ Intent อยู่ คุณสามารถดึงและตรวจสอบไฟล์เอาต์พุตข้อมูลได้โดยเรียกใช้โค้ดต่อไปนี้

Kotlin

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

หากต้องการเขียนลงในไฟล์จากฝั่ง C++ ของแอปเกม คุณสามารถส่งตัวบอกไฟล์แทนเส้นทางไฟล์ได้

Kotlin

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

C++

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

ตัวอย่างไฟล์เอาต์พุต

แม้ว่า Test Lab จะไม่กำหนดรูปแบบที่เฉพาะเจาะจงสำหรับ logFile แต่การจัดโครงสร้างเอาต์พุตเป็น JSON ที่ตรงกับสคีมาด้านล่างจะช่วยให้ Firebase คอนโซล (https://console.firebase.google.com/project/_/testlab) แยกวิเคราะห์และแสดงเมตริกสรุปสำหรับการทดสอบ Game Loop ได้

รายละเอียดสำคัญเกี่ยวกับตัวอย่างนี้

ผู้ที่ให้ข้อมูล: คุณ (นักพัฒนาการทดสอบ) มีหน้าที่รับผิดชอบในการคำนวณและเขียนเมตริกทั้งหมดลงในไฟล์นี้จากโค้ดเกม Test Lab จะไม่รวบรวมหรือสร้างจุดข้อมูลเหล่านี้ให้คุณโดยอัตโนมัติ
การเพิ่มช่องที่กำหนดเอง: พื้นที่ที่ทำเครื่องหมายเป็น /.../ บ่งบอกตำแหน่งที่คุณสามารถเพิ่ม คู่คีย์-ค่าที่กำหนดเองได้ (เช่น "rendered_vertices": 12000 หรือ "ai_error_count": 0) คุณสามารถเพิ่มพร็อพเพอร์ตี้ JSON ที่ถูกต้องลงในเอาต์พุตเมื่อ เขียนไฟล์จากแอป ตราบใดที่ชื่อช่องไม่ขัดแย้งกับช่องสคีมา เช่น name หรือ start_timestamp
ตำแหน่งที่จะค้นหาไฟล์เอาต์พุต: หลังจากที่การทดสอบเสร็จสมบูรณ์ ระบบจะจัดเก็บและดาวน์โหลดไฟล์เอาต์พุตดิบได้ใน Bucket ผลลัพธ์ของ Cloud Storage (GCS) ของโปรเจ็กต์ภายในไดเรกทอรีอาร์ติแฟกต์การเรียกใช้การทดสอบ นอกจากนี้ คุณยังดูและตรวจสอบเอาต์พุตที่แยกวิเคราะห์แล้วได้ใน หน้า Test Lab ของคอนโซล Firebase

ตัวอย่างไฟล์เอาต์พุต JSON ที่มีโครงสร้างมีดังนี้

{
  "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
}

Game Loop หลายรายการ

คุณอาจพบว่าการเรียกใช้ Game Loop หลายรายการในแอปมีประโยชน์ ลูปคือการเรียกใช้แอปเกมแบบสมบูรณ์ตั้งแต่ต้นจนจบ ตัวอย่างเช่น หากเกมมีหลายระดับ คุณอาจต้องการให้มี Game Loop 1 รายการเพื่อเปิดตัวแต่ละระดับแทนที่จะมีลูปเดียวที่วนซ้ำผ่านทุกระดับ ด้วยวิธีนี้ หากแอปขัดข้องในระดับ 32 คุณจะเปิดตัว Game Loop นั้นได้โดยตรงเพื่อสร้างข้อขัดข้องซ้ำและทดสอบการแก้ไขข้อบกพร่อง

วิธีเปิดใช้แอปให้เรียกใช้หลายลูปพร้อมกัน

หากคุณเรียกใช้การทดสอบด้วย Test Loop Manager ให้ทำดังนี้
1. เพิ่มบรรทัดต่อไปนี้ลงในไฟล์ Manifest ของแอปภายในองค์ประกอบ <application>
```
<meta-data
  android:name="com.google.test.loops"
  android:value="5" />
```
  Intent ในการเปิดตัวนี้มีลูปเป้าหมายเป็นพารามิเตอร์จำนวนเต็ม ในช่อง android:value คุณสามารถระบุจำนวนเต็มตั้งแต่ 1 ถึง 1024 (จำนวนลูปสูงสุดที่อนุญาตสำหรับการทดสอบเดียว) โปรดทราบว่าลูปจะจัดทำดัชนีโดยเริ่มจาก 1 ไม่ใช่ 0
2. ในแอป Test Loop Manager หน้าจอการเลือกจะปรากฏขึ้น ซึ่งช่วยให้คุณเลือกลูปที่ต้องการเรียกใช้ได้ หากเลือกลูปหลายรายการ ระบบจะเปิดตัวแต่ละลูปตามลำดับหลังจากลูปก่อนหน้าเสร็จสมบูรณ์
หากคุณเรียกใช้การทดสอบด้วยคอนโซล Firebase ให้ป้อนรายการหรือ ช่วงของหมายเลขลูปในช่องสถานการณ์
หากคุณเรียกใช้การทดสอบด้วย gcloud CLI ให้ระบุรายการหมายเลขลูปโดยใช้แฟล็ก --scenario-numbers เช่น --scenario-numbers=1,3,5 จะเรียกใช้ลูป 1, 3 และ 5
หากคุณเขียน C++ และต้องการเปลี่ยนลักษณะการทำงานของลูป ให้ส่งข้อมูลเพิ่มเติมต่อไปนี้ไปยังโค้ด C++ เนทีฟ
Kotlin
val launchIntent = intent val scenario = launchIntent.getIntExtra("scenario", 0)
MainActivity.kt
Java
Intent launchIntent = getIntent(); int scenario = launchIntent.getIntExtra("scenario", 0);
MainActivity.java
ตอนนี้คุณสามารถเปลี่ยนลักษณะการทำงานของลูปตามค่า int ที่ได้

ติดป้ายกำกับ Game Loop

เมื่อติดป้ายกำกับสถานการณ์อย่างน้อย 1 รายการให้กับ Game Loop คุณและทีม QA จะเปิดตัวชุด Game Loop ที่เกี่ยวข้อง (เช่น "Game Loop ทั้งหมดที่เข้ากันได้") และทดสอบ Game Loop เหล่านั้นในเมทริกซ์เดียวได้อย่างง่ายดาย คุณสามารถสร้างป้ายกำกับของคุณเองหรือ ใช้ป้ายกำกับที่กำหนดไว้ล่วงหน้าซึ่ง Test Lab มีให้

com.google.test.loops.player_experience: สำหรับลูปที่ใช้เพื่อสร้างประสบการณ์ของผู้ใช้จริงเมื่อเล่นเกม เป้าหมายของการทดสอบด้วยลูปเหล่านี้คือการค้นหาปัญหาที่ผู้ใช้จริงจะพบขณะเล่นเกม
com.google.test.loops.gpu_compatibility: สำหรับลูปที่ใช้เพื่อทดสอบปัญหาที่เกี่ยวข้องกับ GPU เป้าหมายของการทดสอบด้วยลูปเหล่านี้คือการเรียกใช้โค้ด GPU ที่อาจทำงานไม่ถูกต้องในเวอร์ชันที่เผยแพร่จริง เพื่อแสดงปัญหาเกี่ยวกับฮาร์ดแวร์และไดรเวอร์
com.google.test.loops.compatibility: สำหรับลูปที่ใช้เพื่อทดสอบปัญหาความเข้ากันได้ที่หลากหลาย รวมถึงปัญหา I/O และปัญหา OpenSSL
com.google.test.loops.performance: สำหรับลูปที่ใช้เพื่อทดสอบประสิทธิภาพของอุปกรณ์ ตัวอย่างเช่น เกมอาจทำงานด้วยการตั้งค่ากราฟิกที่ซับซ้อนที่สุดเพื่อดูว่าอุปกรณ์ใหม่ทำงานอย่างไร

วิธีเปิดใช้แอปให้เรียกใช้ลูปที่มีป้ายกำกับเดียวกัน

หากคุณเรียกใช้การทดสอบด้วย Test Loop Manager ให้ทำดังนี้
1. เพิ่มบรรทัดข้อมูลเมตาต่อไปนี้ในไฟล์ Manifest ของแอป แล้วแทนที่ 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. ในแอป Test Loop Manager ให้ป้อนป้ายกำกับอย่างน้อย 1 รายการในช่องป้ายกำกับ
หากคุณเรียกใช้การทดสอบด้วยคอนโซล Firebase ให้ป้อน ป้ายกำกับอย่างน้อย 1 รายการในช่องป้ายกำกับ
หากคุณเรียกใช้การทดสอบด้วย gcloud CLI ให้ระบุป้ายกำกับสถานการณ์อย่างน้อย 1 รายการโดยใช้แฟล็ก --scenario-labels (เช่น --scenario-labels=performance,gpu)

การรองรับการอนุญาตให้ใช้สิทธิแอป

Test Lab รองรับแอปที่ใช้ บริการการอนุญาตให้ใช้สิทธิแอป ที่ Google Play เสนอ หากต้องการตรวจสอบการอนุญาตให้ใช้สิทธิเมื่อทดสอบ แอปด้วย Test Lab ให้สำเร็จ คุณต้องเผยแพร่แอปไปยังช่องเวอร์ชันที่เผยแพร่จริง ใน Play Store หากต้องการทดสอบแอปในช่องอัลฟ่าหรือเบต้าโดยใช้ Test Lab ให้นำการตรวจสอบการอนุญาตให้ใช้สิทธิออกก่อนอัปโหลดแอปไปยัง Test Lab

ปัญหาที่ทราบ

การทดสอบ Game Loop ใน Test Lab มีปัญหาที่ทราบดังต่อไปนี้

การขัดข้องบางอย่างไม่รองรับการติดตามการเรียกใช้ฟังก์ชันย้อนกลับ ตัวอย่างเช่น บิลด์ที่เผยแพร่บางรายการอาจระงับเอาต์พุตของกระบวนการ debuggerd โดยใช้ prctl(PR_SET_DUMPABLE, 0) ดูข้อมูลเพิ่มเติมได้ที่ debuggerd
ปัจจุบันระบบยังไม่รองรับ API ระดับ 19 เนื่องจากข้อผิดพลาดเกี่ยวกับสิทธิ์ของไฟล์