התכונה "חלוקה חכמה לפלחים" ב-Developer Device Platform הרצה במכשיר מחלקת את בדיקות האינסטרומנטציה של Android ואת בדיקות ה-XCTest של iOS לפלחים מקבילים, על סמך זמני ביצוע בדיקה היסטוריים שמאוחסנים ב-Cloud Storage. בניגוד לחלוקה אחידה, שבה מקרי הבדיקה מחולקים לפי מספר, בלי קשר למשך הזמן של כל בדיקה, בחלוקה חכמה מקרי הבדיקה מחולקים לפי משך הזמן הצפוי, כך שהבדיקות המקבילות מסתיימות בערך באותו זמן.
במסמך הזה מוסבר איך אלגוריתם הפיצול החכם מחשב את מספר הפיצולים ומקצה בדיקות, מתואר הסכימה של רשומת התזמון ב-YAML שמאוחסנת בקטגוריה של Cloud Storage, וניתנות תשובות לשאלות נפוצות לגבי התקורה של תזמור בדיקות ל-Android וחלון הנתונים המתגלגל של 30 יום. כדי להשתמש ב-Google Cloud CLI, קראו את ההוראות להרצת בדיקות Android instrumentation ו-iOS XCTest בשורת הפקודה.
איך פועל אלגוריתם הפיצול החכם
חלוקה לפלחים לא שווה למספר הבדיקות שאפשר להריץ בו-זמנית. יכול להיות שמספר המכשירים הזמינים קטן ממגבלת הפיצולים בזמן הבקשה. יכול להיות שמספר המכשירים בפועל שיוקצו למשתמש בו-זמנית יהיה נמוך ממספר השארדים שהוא ציין.
כששולחים סשן עם --sharding-option=smart ב-CLI של gcloud או מגדירים את smartSharding ב-API בארכיטקטורת REST, פלטפורמת Developer Device Platform מריצה תהליך עבודה של שישה שלבים שכולל יצירת סשן, ביצוע בדיקה והשלמה:
- קוראים נתונים היסטוריים של תזמון ומתאימים את ההקשר של המכשיר. לפני תזמון הפיצולים, סוכן השירות של "הרצה במכשיר" קורא את קובץ ה-YAML של הפיצול החכם מ-Cloud Storage. היא מחפשת ברשימה
recordsערךshardingContextשתואם לערכיםdeviceModelו-osVersionשל משימת היעד (לא תלוי-רישיות). אם אין התאמה מדויקת לשילוב הזה של המכשיר ומערכת ההפעלה, פלטפורמת Developer Device Platform חוזרת לרשומה הראשונה שלrecordsשזמינה בקובץ. אם קובץ ה-YAML עדיין לא קיים, הסשן ממשיך כהפעלה במצב התחלתי (cold start) עם היסטוריית תזמון ריקה. - מסננים את הדגימות לחלון זמן דינמי של 30 יום ומחשבים את משכי הזמן הצפויים. ברשומת ההקשר שנבחרה, Developer Device Platform שומרת רק דגימות תזמון שהערך של
recordTimeשלהן הוא ב-30 הימים האחרונים, ומחשבת את משך הזמן הממוצע האריתמטי של כל מקרה בדיקה. אם תזמור בדיקות ל-Android מופעל עם--orchestrator-version, Developer Device Platform מחשבת גם את הממוצע של 30 יום של דגימות התקורה שלANDROID_TEST_ORCHESTRATORומוסיפה את התקורה הממוצעת הזו למשך הזמן הצפוי של כל מקרה בדיקה. - מגלים בדיקות שאפשר להריץ ומקצים אומדנים חלופיים. במארח של ה-worker, פלטפורמת Developer Device Platform בודקת באופן סטטי את חבילת הבדיקה – קוראת קובצי DEX ב-APK של הבדיקה ב-Android, או סמלי
.xctestומסנני.xctestrunשעברו הידור ב-iOS – מחילה מסנני--test-targetsומוציאה בדיקות שהמערכת מתעלמת מהן או מדכאת אותן (כמו@Ignoreאו@Suppress). כל יחידת בדיקה שאפשר להריץ מקבלת משך זמן צפוי על סמך שלוש רמות:- מקרה בדיקה מתועד: משתמש במשך הזמן הממוצע ההיסטורי של 30 יום (בתוספת התקורה הממוצעת של התזמור כשמופעל תזמור בדיקות ל-Android).
ב-Android, מחלקות JUnit עם פרמטרים (כמו מחלקות שמשתמשות ב-
@RunWith(Parameterized.class), ב-JUnitParamsRunnerאו ב-TestParameterInjector) מתוזמנות כיחידה אחת ברמת המחלקה, ומשך הזמן הצפוי שלהן הוא הסכום של כל משכי הזמן המתועדים של השיטות באותה מחלקה. - מקרה בדיקה שלא תועד בחבילה קיימת: משתמש במשך הזמן הממוצע הצפוי של כל מקרי הבדיקה המתועדים שאינם אפס ברשומה התואמת.
- הפעלה קרה (אין היסטוריה מתועדת): המערכת משתמשת בהערכה של 30 שניות כברירת מחדל לכל יחידת בדיקה.
- מקרה בדיקה מתועד: משתמש במשך הזמן הממוצע ההיסטורי של 30 יום (בתוספת התקורה הממוצעת של התזמור כשמופעל תזמור בדיקות ל-Android).
ב-Android, מחלקות JUnit עם פרמטרים (כמו מחלקות שמשתמשות ב-
חישוב מספר השארדים פלטפורמת Developer Device Platform מסכמת את משכי הזמן הצפויים של כל יחידות הבדיקה שאפשר להריץ, ומחלקת אותם בערך של
--smart-sharding-target-durationשהגדרתם (תקף מ-2mעד1h). לאחר מכן היא מעגלת את התוצאה כלפי מעלה למספר השלם הקרוב ביותר של שאשאים:optimal_shards = max(1, ceil(total_expected_duration / target_duration))לאחר מכן, Developer Device Platform מגדירה את מספר השארדים הסופי בין
1לבין המגבלה הנמוכה ביותר מבין המגבלות הבאות:- המספר הכולל של יחידות בדיקה שאפשר להריץ (כדי למנוע פיצולים ריקים).
- הערך של
--smart-sharding-max-shard-count, אם הוא גדול מ-0. - מגבלת הפלטפורמה (
20פיצולים למכשירים פיזיים או200פיצולים למכשירים וירטואליים של Android).
הקצאת בדיקות באמצעות סידור בקונטיינרים (bin packing) לפי זמן העיבוד הארוך ביותר. Developer Device Platform ממיינת את כל יחידות הבדיקה שאפשר להריץ בסדר יורד של משך הזמן הצפוי (מהאיטי ביותר למהיר ביותר) ומאתחלת ערימת מינימום של שאילתות ריקות שממוינות לפי משך הזמן המצטבר. הוא לוקח יחידת בדיקה אחת בכל פעם, מקצה את הבדיקה האיטית ביותר שנותרה למקטע עם משך הזמן המצטבר הקצר ביותר, ומעדכן את הסך הכול של המקטע הזה. אם מתזמנים קודם בדיקות ארוכות ואיטיות, הן מבודדות לשארדים נפרדים, ובדיקות קצרות יותר ממלאות את הפערים שנותרו כדי לשמור על איזון במשך הזמן הכולל של השארדים.
מתעדים את זמני המעבר ומעדכנים את Cloud Storage. אחרי שכל השארדים מסתיימים, Developer Device Platform אוספת את משכי הזמן שנמדדו מ-
startTimeעדendTimeשל מקרי הבדיקה שעברו, מסירה את כל הדגימות שנוצרו לפני יותר מ-30 יום בכל ההקשרים של המכשירים בקובץ ה-YAML, מסירה את כל רשומות ההקשרים שלא נותרו בהן דגימות תקינות וכותבת את קובץ ה-YAML המעודכן בחזרה ב-Cloud Storage באמצעות ניסיונות חוזרים של בקרת בו-זמניות אופטימית עם התאמה לפי דור.
מבנה קובץ YAML של חלוקה חכמה לפלחים
כשמריצים סשן באמצעות ה-CLI של gcloud, הערך --smart-sharding-record-name מציין את שם הקובץ הבסיסי (לא כולל הסיומת YAML) של רשומת התזמון שמאוחסנת בקטגוריה של Cloud Storage בפרויקט Google Cloud :
gs://BUCKET_NAME/automation/smart-sharding/RECORD_NAME.yaml
מחליפים את ה-placeholders הבאים:
-
BUCKET_NAME: השם של הקטגוריה ב-Cloud Storage שצוין באמצעות--bucket-name, או<var>PROJECT_ID</var>-devicerunכברירת מחדל (כאשרPROJECT_IDהוא מזהה הפרויקט ב- Google Cloud). -
RECORD_NAME: מזהה הרשומה שמועבר אל--smart-sharding-record-nameבלי סיומת הקובץ YAML (לדוגמה,checkout-suiteממופה אלautomation/smart-sharding/checkout-suite.yaml).
רשומת תזמון לדוגמה ב-YAML
הדוגמה הבאה מציגה קובץ YAML של חלוקה חכמה לפלחים (checkout-suite.yaml) שמכיל רשומות תזמון לשני הקשרי מכשירים – מכשיר Android שפועל עם תזמור בדיקות ל-Android ומכשיר iOS:
records:
- shardingContext:
deviceModel: shiba
osVersion: '34'
testCaseTimingRecords:
- testCaseName: com.example.shop.CheckoutTest#testCompletePurchase
timingSamples:
- duration: 42.180s
recordTime: '2026-11-08T14:20:11Z'
- duration: 44.050s
recordTime: '2026-11-09T16:45:03Z'
- testCaseName: com.example.shop.CartTest#testApplyPromoCode
timingSamples:
- duration: 8.600s
recordTime: '2026-11-08T14:20:11Z'
- duration: 9.120s
recordTime: '2026-11-09T16:45:03Z'
conditionalOverheads:
- condition: ANDROID_TEST_ORCHESTRATOR
timingSamples:
- duration: 2.850s
recordTime: '2026-11-08T14:20:11Z'
- duration: 3.150s
recordTime: '2026-11-09T16:45:03Z'
- shardingContext:
deviceModel: iphonese3
osVersion: '18.4'
testCaseTimingRecords:
- testCaseName: ShopTests.CheckoutTests#testApplePaySheet
timingSamples:
- duration: 19.340s
recordTime: '2026-11-09T17:10:29Z'
הפניה לשדה YAML
קובץ ה-YAML של חלוקה חכמה ל-shards מבצע סריאליזציה של הסכימה SuiteTiming באמצעות שמות שדות ב-camelCase. בטבלה הבאה מתוארים כל השדות בקובץ:
| שדה | סוג | תיאור |
|---|---|---|
metadata |
מפה (string עד string) |
מטא-נתונים אופציונליים של מפתח/ערך ברמת החבילה, שנשמרים בכל עדכוני הצבירה. |
records |
רשימת אובייקטים | רשומות תזמון לכל מכשיר (SuiteTimingWithContext), מחולקות לפי דגם החומרה וגרסת מערכת ההפעלה. |
records[].shardingContext |
אובייקט | מאפיינים של חומרה ומערכת הפעלה שכוללים קבוצה של מדידות תזמון. |
records[].shardingContext.deviceModel |
string |
מזהה הדגם של המכשיר שבו תועדו זמני הטעינה (לדוגמה, shiba ב-Android או iphonese3 ב-iOS). |
records[].shardingContext.osVersion |
string |
גרסת מערכת ההפעלה או ה-SDK של המכשיר (לדוגמה, רמת API של Android '34' או גרסת iOS '18.4'). |
records[].testCaseTimingRecords |
רשימת אובייקטים | משך הזמן של הרצות היסטוריות של מקרי בדיקה ספציפיים שעברו בהצלחה בהקשר הזה. |
records[].testCaseTimingRecords[].testCaseName |
string |
מזהה בדיקה מלא בפורמט package.ClassName#methodName (או package.ClassName אם המטא-נתונים של השיטה חסרים). |
records[].testCaseTimingRecords[].timingSamples |
רשימת אובייקטים | רשימה של משכי הזמן שנמדדו למקרה הבדיקה ב-30 הימים האחרונים, שנוספה אחרי הרצות מוצלחות. |
timingSamples[].duration |
מחרוזת משך זמן | משך הזמן שנמדד, בפורמט של שניות עם דיוק אופציונלי של שברים (לדוגמה, 10s או 42.180s). |
timingSamples[].recordTime |
מחרוזת של חותמת זמן | חותמת זמן לפי שעון UTC בפורמט RFC 3339 שמציינת מתי Developer Device Platform תיעדה את הדגימה (לדוגמה, '2026-11-09T16:45:03Z'). |
records[].conditionalOverheads |
רשימת אובייקטים | תקורה אופציונלית של ביצוע שנמדדה במצבי runner ספציפיים, בהיקף של shardingContext. השדה הזה מושמט אם אין עלויות תקורה מותנות. |
records[].conditionalOverheads[].condition |
string |
מזהה של תנאי הביצוע. ערך נתמך: ANDROID_TEST_ORCHESTRATOR. |
records[].conditionalOverheads[].timingSamples |
רשימת אובייקטים | רשימה מתגלגלת של 30 יום של דגימות תקורה לכל מעבר שתועדו משארדים שעומדים בדרישות. |
הסבר על זמני התקורה של ANDROID_TEST_ORCHESTRATOR
כשמריצים בדיקות אינסטרומנטציה של Android באמצעות --orchestrator-version, קובץ ה-YAML של חלוקה חכמה לפלחים כולל רשומת conditionalOverheads עם condition: ANDROID_TEST_ORCHESTRATOR. בניגוד ל-testCaseTimingRecords, דגימות התקורה האלה לא מצורפות לשיטת בדיקה ספציפית או למאגר נתונים ממוספר.
מה מייצגת דגימה אחת של משך זמן התקורה
כשהכלי תזמור בדיקות ל-Android מופעל, הוא מריץ כל שיטת בדיקה בתהליך Instrumentation מבודד משלה. חותמות הזמן של הבדיקות הנפרדות startTime ו-endTime מתעדות רק את הזמן שנדרש בתוך כל שיטת בדיקה – הן לא כוללות את הפער בין הבדיקות שנדרש כדי לעצור את תהליך האפליקציה הקודם, לנקות את נתוני החבילה (clearPackageData) ולהתחיל תהליך Instrumentation חדש לבדיקה הבאה.
כדי למדוד את עלות המעבר בין הבדיקות, פלטפורמת Developer Device Platform בודקת כל שאילתה שעוברת ומריצה שני מקרי בדיקה או יותר (N > 1) ומחשבת:
- משך ההרצה הכולל של המקטע: הזמן שחלף מהבדיקה המוקדמת ביותר
startTimeבמקטע ועד לבדיקה האחרונהendTimeבמקטע. - משך הזמן הכולל של מקרי הבדיקה: הסכום של
(endTime - startTime)בכלNמקרי הבדיקה באותו שאשאד. תקורה ממוצעת לכל מעבר: מכיוון שב-
Nבדיקות רציפות ישN - 1מעברים בין בדיקות, פלטפורמת Developer Device Platform מחסירה את משכי הזמן הכוללים של הבדיקות מטווח השארד ומחלקת ב-N - 1:overhead_sample = max(0, total_span - total_test_duration) / (N - 1)
כל מקטע של בדיקה מרובה שעובר בהצלחה במשימה מוסיף אחד (TimingSample) ל-ANDROID_TEST_ORCHESTRATOR. לדוגמה, אם סשן פועל בשלושה חלקים וכל חלק עובר עם לפחות שני מקרי בדיקה, הסשן הזה מוסיף שלוש דגימות תקורה עם ה-recordTime של הסשן. במקטעים שמריצים רק מקרה בדיקה אחד (N = 1) אין מעברים בין בדיקות, והם לא פולטים דגימת תקורה.
למה התקורה לא מקושרת למקרה בדיקה או למאגר נתונים (shard)
ב-Developer Device Platform, דגימות של ANDROID_TEST_ORCHESTRATOR נשמרות ברמת shardingContext (deviceModel ו-osVersion) ולא לכל בדיקה או לכל פיצול, משתי סיבות:
- התקורה תלויה במכשיר ובמערכת ההפעלה, ולא בלוגיקה של הבדיקה. הפעלת התהליך, אתחול ה-binder וניקוי נתוני החבילה נמשכים בערך אותו זמן, בלי קשר לשיטת JUnit שמופעלת לאחר מכן, ואילו קבוצות השארדים משתנות באופן דינמי בכל פעם שזמני הבדיקה או מספר השארדים משתנים.
- הפרדת התקורה שומרת על זמני בדיקה נקיים של תרחיש הבסיס. העובדה שהתקורה של בידוד התהליכים לא נכללת ב-
testCaseTimingRecordsמאפשרת להפעיל או להשבית את--orchestrator-versionבהרצות שחולקות את אותה רשומת YAML, בלי לעוות את משכי הזמן הבסיסיים של ביצוע הבדיקות.
איך פלטפורמת Developer Device Platform משתמשת בתקורה במהלך הקצאת המקטעים
כשמגדירים את --orchestrator-version בסשן חדש, Developer Device Platform מחשבת את הממוצע של דגימות ANDROID_TEST_ORCHESTRATOR תקינות (avg_overhead) ב-30 ימים ומוסיפה אותו למשך הממוצע של כל מקרה בדיקה ב-30 ימים לפני חישוב מספר המקטעים או אריזת המקטעים:
expected_test_duration = avg_test_duration + avg_overhead
אם לא הוגדר --orchestrator-version בסשן, הערך של avg_overhead הוא 0s וכל רשומות ANDROID_TEST_ORCHESTRATOR הקיימות בקובץ ה-YAML לא נכללות בהרצה הזו.
הוספת avg_overhead לכל מקרה בדיקה משפיעה על חלוקת הנתונים לשלושה חלקים:
- מספר מדויק של פיצולים לחבילות עם הרבה בדיקות מהירות. נניח שיש לכם חבילה של 60 בדיקות אינסטרומנטציה בסגנון יחידה, שכל אחת מהן פועלת ב-
1s, עם תקורה ממוצעת של מעבר בין תזמורים של3sומשך זמן יעד של פיצול של2m(120s). בלי התקורה, משך הזמן הכולל הצפוי נראה כמו60s, כך שכל 60 הבדיקות נארזות ב-shard אחד (1) שלמעשה לוקח כמעט ארבע דקות לסיום (60sשל ביצוע הבדיקה פלוס59 * 3s = 177sשל מעברי orchestrator). אם מוסיפים את התקורה של3sלכל בדיקה (משך זמן צפוי של4sלכל בדיקה, או240sבסך הכול), פלטפורמת Developer Device Platform מקצה2פיצולים (ceil(240s / 120s)) כך שכל פיצול מסתיים קרוב ליעד של שתי דקות. - אריזה מאוזנת של מקטעים כשמספרי הבדיקות שונים. במהלך סידור בקונטיינרים (bin packing) לפי זמן העיבוד הארוך ביותר, על שאשא שמוקצה לה בדיקת ממשק משתמש אחת של
40sחלה עלות צפויה של43s(40s + 3s), ואילו על שאשא שמוקצות לה 10 בדיקות של4sחלה עלות צפויה של70s(10 * (4s + 3s)). הכללת התקורה לכל בדיקה מונעת משאשות עם הרבה בדיקות קצרות לצבור דקות של זמן אחזור לא נספר של הפעלה מחדש של התהליך. - הערכות ריאליות לבדיקות שנוספו לאחרונה. בדיקות שלא תועדו בחבילה קיימת יורשות את משך הזמן הממוצע הצפוי של בדיקות ידועות, שכבר כולל את
avg_overhead, ולכן בדיקות חדשות מביאות בחשבון באופן אוטומטי את התקורה של התזמור בהרצה הראשונה שלהן.
הסבר על חלון הנתונים של 30 הימים ועל ההתנהגות של ההרצה הראשונית
כדי להתחיל לבצע אופטימיזציה של הרצות הבדיקה, לא צריך 30 ימים של נתונים היסטוריים. אפילו דגימה אחת שתתועד תפעיל את חישוב השארדים לפי משך הזמן ואת הסידור בקונטיינרים בסשן הבא. במקום זאת, 30 ימים הם חלון המבט לאחור והשמירה המתמשכת שבהם Developer Device Platform משתמשת כשהיא קוראת ומעדכנת את רשומת התזמון של YAML.
למה בפיצול חכם משתמשים בחלון זמן דינמי של 30 יום
בכל פעם ש-Developer Device Platform קוראת או מעדכנת קובץ YAML של חלוקה חכמה ל-shards, היא מסננת את כל ה-TimingSample שה-recordTime שלהם ישן יותר מ-30 ימים.
חלון הזמן הזה של 30 יום מאזן בין שני יעדים של צוות מהנדסי התוכנה:
- התאמה לשינויים בבסיס הקוד והגבלת גודל הקובץ. התכונות של האפליקציה, תהליכי ממשק המשתמש והטמעות הבדיקה משתנים עם הזמן. הסרה אוטומטית של דגימות שנוצרו לפני יותר מ-30 יום מונעת מתזמונים מיושנים (למשל, תזמונים מלפני עיצוב מחדש של המסך או שכתוב של שכבת הרשת) להטות את ההקצאות הנוכחיות של המקטעים. הסרת רשומות שפג תוקפן (והסרת הקשרי מכשירים שאין להם יותר דגימות תקינות) גם שומרת על קובץ YAML קומפקטי וקטן בהרבה מהמגבלה של 32MB.
- הפחתת השונות בין הרצות שונות תוך תמיכה בחבילות שבועיות. הרצת בדיקה בודדת יכולה להיות מושפעת מרעש חולף שנובע מאיסוף אשפה, משירותי מערכת שפועלים ברקע או מתזמון של אמולטור. ממוצע הדגימות בחלון של 30 יום מחליק קפיצות חד-פעמיות, תוך שמירה על היסטוריה מספקת כדי שצינורות עיבוד נתונים של שילוב רציף (CI) ליליים, שבועיים או בקצב של ספרינט ישמרו רשומות תזמון חמות בין הרצות.
למה לצפות בשבוע הראשון והשני
אם תפעילו היום חלוקה חכמה לפלחים בחבילת מקרים לבדיקה קיימת, זמני הביצוע יתקצרו במהירות, במקום לחכות שבועות עד שהם ישתפרו:
- הפעלה ראשונה (הפעלה במצב התחלתי). קובץ ה-YAML עדיין לא קיים ב-Cloud Storage, ולכן Developer Device Platform מקצה לכל יחידת בדיקה שניתן להריץ את ההערכה שמוגדרת כברירת מחדל – 30 שניות. הוא מחשב את מספר המקטעים בתור
ceil(num_tests * 30s / target_duration)(מוגבל על ידי מספר המקטעים המקסימלי ומגבלות הפלטפורמה) ומחלק את הבדיקות בין המקטעים – בדומה לחלוקה אחידה למקטעים. בהפעלה הראשונה:- אם הבדיקות נמשכות בממוצע הרבה פחות מ-30 שניות, יכול להיות שבהרצה הראשונה יוקצו יותר פיצולים מהנדרש (עד
--smart-sharding-max-shard-count). - אם חבילת הבדיקות מכילה כמה בדיקות של ממשק המשתמש שנמשכות כמה דקות, יכול להיות ששתי בדיקות איטיות יגיעו לאותו פיצול במקרה, והפיצול הזה יהפוך לצוואר הבקבוק של זמן ההשלמה בפועל.
- כשההרצה הראשונה מסתיימת, פלטפורמת Developer Device Platform יוצרת את קובץ ה-YAML ב-Cloud Storage עם משך הזמן שנמדד לבדיקות שעברו.
- אם הבדיקות נמשכות בממוצע הרבה פחות מ-30 שניות, יכול להיות שבהרצה הראשונה יוקצו יותר פיצולים מהנדרש (עד
- הפעלה שנייה (מיד אחרי שההפעלה הראשונה מסתיימת). התכונה "חלוקה חכמה לפלחים" כבר פעילה. פלטפורמת Developer Device Platform קוראת את משכי הזמן שתועדו בהרצה הראשונה, מחשבת מחדש את מספר המקטעים לפי זמן הביצוע בפועל של חבילת הבדיקות, ומבודדת קודם את הבדיקות האיטיות ביותר למקטעים נפרדים. בדרך כלל, ההפחתה העיקרית במשך הסשן לפי שעון הקיר ובמספר השארדים מתחילה בהרצה השנייה – אפילו באותו יום שבו מפעילים את חלוקת השארדים החכמה.
- שאר השבוע הראשון והשבוע השני. במהלך כמה הרצות נוספות, איזון השארדים ממשיך להשתפר בשלושה מקרים ספציפיים:
- החלקה של שונות בהרצה בודדת. בכל הרצה נוספת, מתווסף עוד
TimingSample, והתנודות הזמניות מההרצה הראשונה מתאזנות. כך מצטמצם מספר השארדים שמתעכבים ומסיימים קצת אחרי--smart-sharding-target-duration. - השלמת בדיקות מהרצות שנכשלו בהתחלה. כדי למנוע מצב שבו קריסות מהירות או זמן קצוב לתפוגה של בדיקות ישבשו את הממוצעים ההיסטוריים, פלטפורמת Developer Device Platform מתעדת את התזמונים רק של בדיקות שעברו (וב-Android, רק של פיצולים שהסטטוס הכולל של חבילת הבדיקות שלהם הוא
PASSED). כל בדיקה שלא תועד בה תזמון בהרצה הראשונה משתמשת במשך הזמן הממוצע של חבילת הבדיקות בהרצה השנייה, ואז עוברת לתזמון שנמדד לה ברגע שהיא עוברת. - הוספת בדיקות חדשות או דגמי מכשירים חדשים. כל מקרה בדיקה חדש שנוסף במהלך השבועות הראשון והשני משתמש באופן אוטומטי במשך הזמן הממוצע הצפוי של חבילת הבדיקות, במקום לחזור לברירת המחדל של 30 שניות. אם מוסיפים לסשן מודל
--deviceשני עם אותו שם רשומה, בהפעלה הראשונה שלו נעשה שימוש בתזמונים של המכשיר הקיים כברירת מחדל ראשונית, ואז מתועדת רשומתshardingContextייעודית להפעלות הבאות.
- החלקה של שונות בהרצה בודדת. בכל הרצה נוספת, מתווסף עוד
שאלות נפוצות
השאלות הבאות עוסקות בתרחישים תפעוליים נפוצים כשמריצים חלוקה חכמה לפלחים בצינורות עיבוד נתונים של CI/CD.
המאמרים הבאים
- מידע על מריץ הבדיקות TestParameterInjector.
- מגדירים דגלים של חלוקה חכמה לפלחים בהרצת בדיקת אינסטרומנטציה של Android.
- אפשר להגדיר הרצות של בדיקות ב-iOS במאמר הרצת XCTest ב-iOS.
- בודקים את ההרשאות של סוכן השירות בקטגוריות בפרויקטים שונים, בקטע שיתוף הקטגוריות של Cloud Storage עם Developer Device Platform.
- בודקים את פריטי המידע שנוצרו לכל שאילתה
junit.xmlואת פריטי המידע שנוצרו ביומן בחיפוש תוצאות הבדיקה של Developer Device Platform.