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

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

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

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

เนื่องจากแอปเกมแสดงผลในเฟรมเวิร์กและเอนจิน UI ที่แตกต่างกัน เช่น Unity, Unreal หรือโค้ด C++ ของ OpenGL/Vulkan เครื่องมือการทำงานอัตโนมัติมาตรฐานจึงไม่สามารถตรวจสอบหรือโต้ตอบกับองค์ประกอบ UI ได้ การทดสอบเกมลูปช่วยให้คุณผสานรวม การทดสอบเครื่องมือดั้งเดิมกับ 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 ที่เฉพาะเจาะจง

หมายเหตุ: เกมลูปต้องใช้ตัวกรอง 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 Console หรืออินเทอร์เฟซบรรทัดคำสั่ง (CLI) gcloud หรือในอุปกรณ์ในเครื่องโดยใช้ Test Loop Manager

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

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

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

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

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

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

ใช้คอนโซล Firebase

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

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

ใช้บรรทัดคำสั่ง (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 หลายรายการในแอปมีประโยชน์ โดย 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 หน้าจอการเลือกจะปรากฏขึ้น เพื่อให้คุณเลือก Loop ที่ต้องการเรียกใช้ หากเลือกหลายลูป ระบบจะเปิดใช้แต่ละลูปตามลำดับหลังจากลูปก่อนหน้า เสร็จสมบูรณ์
หากคุณกำลังทดสอบด้วย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

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

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

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

หากคุณเรียกใช้การทดสอบด้วย 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 เนื่องจากข้อผิดพลาดเกี่ยวกับสิทธิ์ของไฟล์