#!/usr/bin/env python3 """COMPUTATION lane — PlusPlusBattery (Jetpack Compose battery info viewer). This lane owns the app's ARITHMETIC: input -> recomputed output. Every test drives an INPUT (current multiplier, dual-cell toggle, temperature-unit swap) and asserts the EXACT recomputed VALUE the running app renders on a Dashboard card. Because the emulator reports FIXED battery values, exact-string equality is a valid oracle. The two engines exercised here (verified live against the original app): (1) Current multiplier: shown_current = 900000 * (Multiply ? 10^mag : 1/10^mag) Open the Calibrate dialog (content-desc "Calibrate"); pick Multiply/Divide (2 RadioButtons, Divide = the 2nd); pick the magnitude from the "10^0" spinner. Integer results drop the decimal ("900 mA", never "900.00 mA"). (2) Power = current(mA) * voltage(mV) * dualMultiplier / 1_000_000, unit "W", formatted "clean": integer -> no decimals, else 2dp. baseline 900000*5000*1/1e6 = 4500 -> "4500 W" Divide 10^3 (cur 900) 900*5000/1e6 = 4.5 -> "4.50 W" Divide 10^2 (cur 9000) 9000*5000/1e6 = 45 -> "45 W" Divide 10^4 (cur 90) 90*5000/1e6 = 0.45 -> "0.45 W" Divide 10^3 + Dual ON (*2) = 9.0 -> "9 W" (integer -> no dp) (3) Temperature C<->F: tap "Swap Unit" -> "25.0°C" becomes "77.0°F" (C*9/5+32). ALL expected strings below were confirmed by running this file against the original and reading the [PASS]/[FAIL] lines — never derived purely from the formula, because the integer-vs-decimal formatting is easy to get wrong. Each test opens its own entry via restart_app(); after any multiplier / dual-cell / unit change it RESTORES the default (Reset the multiplier, toggle dual off, swap the unit back) so later tests and other lanes see raw 900000 / 4500 / 25.0°C. A VLM screenshot, when a test has one, is captured while the changed value is STILL on the card — before the restore. """ import os import sys sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) from android_testgen_kit import * # noqa: F403,F401 import android_testgen_kit as _kit # for the private depth counter only RESULTS_DIR = sys.argv[2] if len(sys.argv) > 2 else os.path.dirname(os.path.abspath(__file__)) # ── Observed constants (each read off the running original) ────────────────────── CUR_DEFAULT = "900000 mA" # Battery Current, no multiplier CUR_MUL1 = "9000000 mA" # Multiply 10^1 CUR_DIV1 = "90000 mA" # Divide 10^1 CUR_DIV2 = "9000 mA" # Divide 10^2 CUR_DIV3 = "900 mA" # Divide 10^3 CUR_DIV4 = "90 mA" # Divide 10^4 CUR_DIV5 = "9 mA" # Divide 10^5 POW_DEFAULT = "4500 W" # baseline power POW_DIV2 = "45 W" # Divide 10^2 (current 9000) -> integer, no dp POW_DIV3 = "4.50 W" # Divide 10^3 (current 900) -> 2dp POW_DIV4 = "0.45 W" # Divide 10^4 (current 90) -> 2dp POW_DIV3_DUAL = "9 W" # Divide 10^3 + Dual ON (*2) -> integer, no dp POW_DUAL = "9000 W" # baseline + Dual ON (*2) -> integer, no dp TEMP_C = "25.0°C" TEMP_F = "77.0°F" DUAL_NO = "No" DUAL_YES = "Yes" CD_CALIBRATE = "Calibrate" CD_SWAP = "Swap Unit" CD_DUAL = "Toggle Dual Battery" CAL_TITLE = "Calibrate via Multiplier" CAL_CLOSE = "Close" CAL_RESET = "Reset" SPINNER_LABEL = "10^0" # the collapsed spinner's EditText text # ══════════════════════════════════════════════════════════════════════════════ # Small readers — read the recomputed value straight out of a FRESH dump. The # card value TextViews are identified by their unit suffix (" mA" / " W" / "°"). # ══════════════════════════════════════════════════════════════════════════════ def _dec_depth() -> int: """Pop one surface from the kit's depth counter WITHOUT a hardware BACK — for a dialog dismissed by its own Close/Reset affordance.""" _kit._DEPTH = max(0, _kit._DEPTH - 1) return _kit._DEPTH def cur_value(nodes=None) -> str: """The Battery Current label ("... mA"), or "" if absent this frame. The Full-Charge-Capacity card can also read "N mAh"; that suffix is " mAh", so it never collides with the current card's " mA".""" nodes = ui() if nodes is None else nodes for n in nodes: t = n.get("text", "") if t.endswith(" mA"): return t return "" def power_value(nodes=None) -> str: """The Battery Power label ("... W"), or "".""" nodes = ui() if nodes is None else nodes for n in nodes: t = n.get("text", "") if t.endswith(" W"): return t return "" def temp_value(nodes=None) -> str: """The Battery Temperature label ("25.0°C"/"77.0°F"), or "".""" nodes = ui() if nodes is None else nodes for n in nodes: if "°" in n.get("text", ""): return n["text"] return "" def dual_value(nodes=None) -> str: """The Dual Cell value string ("No"/"Yes"), or "".""" nodes = ui() if nodes is None else nodes if find_node(nodes, text=DUAL_YES): return DUAL_YES if find_node(nodes, text=DUAL_NO): return DUAL_NO return "" def read_first(reader, want: str = "", tries: int = 5) -> str: """Poll `reader` across fresh dumps until it returns a non-empty value (or `want` when given). The dashboard can re-dump empty for one frame right after a dialog closes; this makes the read robust without ever fabricating a value.""" val = "" for _ in range(tries): val = reader(ui()) if val and (not want or val == want): return val settle("tap") return val def radio_buttons(nodes=None) -> list: nodes = ui() if nodes is None else nodes return [n for n in nodes if n.get("class", "").endswith("RadioButton")] # ══════════════════════════════════════════════════════════════════════════════ # depth-family helper — named and_enter_* so the depth auditor counts the declared # depth=1 as backed by a real navigation call. Opens the Calibrate dialog and # confirms its title appeared. # ══════════════════════════════════════════════════════════════════════════════ def and_enter_calibrate(nodes=None) -> bool: """Dashboard -> Calibrate dialog. Confirms the dialog title appeared, then counts one surface via the kit's depth counter.""" nodes = ui() if nodes is None else nodes trig = find_node(nodes, content_desc=CD_CALIBRATE) if trig is None or not tap_node(trig): return False if find_node(ui(), text=CAL_TITLE) is None: return False and_enter("calibrate_dialog") return True # ── Calibrate dialog sub-steps (an open dialog is assumed) ─────────────────────── def cal_pick_multiply() -> bool: """Tap the 1st RadioButton (Multiply). True iff it is checked afterwards.""" rb = radio_buttons() if len(rb) < 2 or not tap_node(rb[0]): return False rb = radio_buttons() return len(rb) >= 1 and rb[0].get("checked") == "true" def cal_pick_divide() -> bool: """Tap the 2nd RadioButton (Divide). True iff it is checked afterwards.""" rb = radio_buttons() if len(rb) < 2 or not tap_node(rb[1]): return False rb = radio_buttons() return len(rb) >= 2 and rb[1].get("checked") == "true" def cal_set_exponent(exp_text: str) -> bool: """Open the spinner (collapsed it shows "10^0") and pick `exp_text` (e.g. "10^3"). True iff the collapsed spinner then shows the chosen exponent.""" ed = find_node(ui(), text=SPINNER_LABEL) if ed is None or not tap_node(ed): return False item = find_node(ui(), text=exp_text) if item is None or not tap_node(item): return False return find_node(ui(), text=exp_text) is not None def cal_close() -> bool: """Tap the dialog's Close button (tap_node — Close is a DANGEROUS_TEXT so safe_tap would refuse; it only dismisses the dialog).""" c = find_node(ui(), text=CAL_CLOSE) return c is not None and tap_node(c) def cal_reset() -> bool: """Tap the dialog's Reset button (tap_node — Reset is a DANGEROUS_TEXT, but the app's Reset only resets the multiplier PREFERENCE, never user data). OBSERVED: Reset restores the value to 900000 mA AND dismisses the dialog.""" r = find_node(ui(), text=CAL_RESET) return r is not None and tap_node(r) def apply_multiplier(mode: str, exp_text: str) -> bool: """Open Calibrate, select Multiply/Divide, set the exponent, Close. Leaves the Dashboard showing and pops the dialog off the depth counter. Returns True iff every sub-step succeeded.""" if not and_enter_calibrate(): return False pick = cal_pick_multiply() if mode == "multiply" else cal_pick_divide() ok = pick and cal_set_exponent(exp_text) and cal_close() _dec_depth() # dialog dismissed by Close return ok def restore_multiplier() -> None: """Open Calibrate and Reset (restores 900000 AND closes), balancing depth.""" if and_enter_calibrate(): cal_reset() _dec_depth() read_first(cur_value, CUR_DEFAULT) def restore_dual_off() -> None: """Toggle Dual Cell back OFF if it is currently ON.""" if dual_value(ui()) == DUAL_YES: d = find_node(ui(), content_desc=CD_DUAL) if d: tap_node(d) read_first(dual_value, DUAL_NO) def restore_temp_c() -> None: """Swap the temperature unit back to Celsius if it is currently Fahrenheit.""" if temp_value(ui()) == TEMP_F: sw = find_node(ui(), content_desc=CD_SWAP) if sw: tap_node(sw) read_first(temp_value, TEMP_C) def ready() -> bool: """restart_app + wait; True once the Dashboard is up.""" restart_app() return wait_for_foreground() # ══════════════════════════════════════════════════════════════════════════════ # CURRENT MULTIPLIER — six exact-value cases across Divide 10^1..10^5 + Multiply # 10^1. Each opens the Calibrate dialog (depth=1), applies the multiplier, and # asserts the exact recomputed "N mA" string, then Resets back to 900000. # ══════════════════════════════════════════════════════════════════════════════ def _current_case(name: str, mode: str, exp_text: str, expected: str, vlm=None): """Shared body: assert Battery Current == `expected` after mode+exponent, with a positive/negative pair (the answer must be ABSENT before and PRESENT after). An optional `vlm` callback fires while the changed value is STILL on the card — before the multiplier is Reset.""" if not ready(): record(name, False, "setup_failed: app did not reach foreground", depth=1, jump_kind="value", expect=f"Battery Current {expected}") return before = read_first(cur_value, CUR_DEFAULT) if find_node(ui(), content_desc=CD_CALIBRATE) is None: record(name, False, "feature_missing: no 'Calibrate' control on the Battery Current card", depth=1, jump_kind="value", expect=f"Battery Current {expected}") return steps_ok = apply_multiplier(mode, exp_text) if not steps_ok: record(name, False, f"setup_failed: could not apply {mode} {exp_text} in the Calibrate dialog", depth=1, jump_kind="value", expect=f"Battery Current {expected}") restore_multiplier() return after = read_first(cur_value, expected) # positive/negative: expected value ABSENT at baseline, PRESENT after. ok = (before == CUR_DEFAULT) and (after == expected) and (expected != CUR_DEFAULT) record(name, ok, "" if ok else f"behavior_wrong: {mode} {exp_text} should give Battery Current " f"{expected!r}; saw before={before!r} after={after!r}", depth=1, jump_kind="value", expect=f"Battery Current {expected}") if vlm: vlm(name) # screenshot WHILE the divided value is on screen restore_multiplier() @and_test(expects=("computation_current_divide_10p1",)) def test_current_divide_10p1(): _current_case("computation_current_divide_10p1", "divide", "10^1", CUR_DIV1) @and_test(expects=("computation_current_divide_10p2",)) def test_current_divide_10p2(): _current_case("computation_current_divide_10p2", "divide", "10^2", CUR_DIV2) @and_test(expects=("computation_current_divide_10p3",)) def test_current_divide_10p3(): _current_case("computation_current_divide_10p3", "divide", "10^3", CUR_DIV3) @and_test(expects=("computation_current_divide_10p4",)) def test_current_divide_10p4(): _current_case("computation_current_divide_10p4", "divide", "10^4", CUR_DIV4) @and_test(expects=("computation_current_divide_10p5", "computation_current_divide_10p5_vlm")) def test_current_divide_10p5(): def _vlm(_name): # VLM (content track): with Divide 10^5 applied, the Battery Current card # renders a TINY value ("9 mA") instead of the six-digit default 900000 — # visible proof the multiplier recomputation happened. Captured before the # value is Reset, so the small number is actually on screen. vlm_assert("computation_current_divide_10p5", "Look at the 'Battery Current' row. Is its value a SMALL number of " "just one or two characters (for example '9'), rather than a long " "six-digit number like '900000'?", RESULTS_DIR, depth=0, jump_kind="none", tag="content") _current_case("computation_current_divide_10p5", "divide", "10^5", CUR_DIV5, vlm=_vlm) @and_test(expects=("computation_current_multiply_10p1",)) def test_current_multiply_10p1(): _current_case("computation_current_multiply_10p1", "multiply", "10^1", CUR_MUL1) # ══════════════════════════════════════════════════════════════════════════════ # POWER — recomputed from the (possibly multiplied) current. Baseline is depth=0 # (no dialog); the multiplier cases are depth=1. Every case asserts the exact "N W" # string, watching the integer-vs-decimal "clean" formatting. # ══════════════════════════════════════════════════════════════════════════════ @and_test(expects=("computation_power_baseline",)) def test_power_baseline(): if not ready(): record("computation_power_baseline", False, "setup_failed: app did not reach foreground", depth=0, jump_kind="value", expect=f"Battery Power {POW_DEFAULT}") return got = read_first(power_value, POW_DEFAULT) ok = got == POW_DEFAULT record("computation_power_baseline", ok, "" if ok else f"behavior_wrong: baseline Battery Power should be {POW_DEFAULT!r} " f"(900000*5000/1e6); saw {got!r}", depth=0, jump_kind="value", expect=f"Battery Power {POW_DEFAULT}") def _power_multiplier_case(name: str, exp_text: str, expected: str, vlm=None): """Divide the current by 10^N, then assert the recomputed Battery Power. The default power (4500 W) must be ABSENT and `expected` PRESENT after.""" if not ready(): record(name, False, "setup_failed: app did not reach foreground", depth=1, jump_kind="value", expect=f"Battery Power {expected}") return before = read_first(power_value, POW_DEFAULT) if find_node(ui(), content_desc=CD_CALIBRATE) is None: record(name, False, "feature_missing: no 'Calibrate' control on the Battery Current card", depth=1, jump_kind="value", expect=f"Battery Power {expected}") return steps_ok = apply_multiplier("divide", exp_text) if not steps_ok: record(name, False, f"setup_failed: could not apply divide {exp_text} in the Calibrate dialog", depth=1, jump_kind="value", expect=f"Battery Power {expected}") restore_multiplier() return after = read_first(power_value, expected) ok = (before == POW_DEFAULT) and (after == expected) and (expected != POW_DEFAULT) record(name, ok, "" if ok else f"behavior_wrong: divide {exp_text} should give Battery Power " f"{expected!r}; saw before={before!r} after={after!r}", depth=1, jump_kind="value", expect=f"Battery Power {expected}") if vlm: vlm(name) # screenshot WHILE the recomputed power is on screen restore_multiplier() @and_test(expects=("computation_power_divide_10p2",)) def test_power_divide_10p2(): _power_multiplier_case("computation_power_divide_10p2", "10^2", POW_DIV2) @and_test(expects=("computation_power_divide_10p3", "computation_power_divide_10p3_vlm")) def test_power_divide_10p3(): def _vlm(_name): # VLM (content track): with Divide 10^3 applied, the Battery Power card # renders a small decimal ("4.50 W"), not the large default 4500. Captured # before the multiplier is Reset. vlm_assert("computation_power_divide_10p3", "Look at the 'Battery Power' row. Is its value a SMALL decimal " "number like '4.50', rather than a large number like '4500'?", RESULTS_DIR, depth=0, jump_kind="none", tag="content") _power_multiplier_case("computation_power_divide_10p3", "10^3", POW_DIV3, vlm=_vlm) @and_test(expects=("computation_power_divide_10p4",)) def test_power_divide_10p4(): _power_multiplier_case("computation_power_divide_10p4", "10^4", POW_DIV4) @and_test(expects=("computation_power_divide_10p3_dual",)) def test_power_divide_10p3_dual(): """Divide 10^3 then Dual Cell ON: power 4.50 doubles to a rendered "9 W" (integer -> the ".00" is dropped).""" if not ready(): record("computation_power_divide_10p3_dual", False, "setup_failed: app did not reach foreground", depth=1, jump_kind="value", expect=f"Battery Power {POW_DIV3_DUAL} at Divide 10^3 + Dual ON") return if find_node(ui(), content_desc=CD_CALIBRATE) is None: record("computation_power_divide_10p3_dual", False, "feature_missing: no 'Calibrate' control on the Battery Current card", depth=1, jump_kind="value", expect=f"Battery Power {POW_DIV3_DUAL} at Divide 10^3 + Dual ON") return calc_ok = apply_multiplier("divide", "10^3") pow_div3 = read_first(power_value, POW_DIV3) dual = find_node(ui(), content_desc=CD_DUAL) dual_ok = dual is not None and tap_node(dual) pow_dual = read_first(power_value, POW_DIV3_DUAL) ok = (calc_ok and pow_div3 == POW_DIV3 and dual_ok and pow_dual == POW_DIV3_DUAL and dual_value(ui()) == DUAL_YES) record("computation_power_divide_10p3_dual", ok, "" if ok else f"behavior_wrong: Divide 10^3 should give Power {POW_DIV3}; Dual ON " f"should double it to {POW_DIV3_DUAL}; saw pow3={pow_div3!r} " f"powdual={pow_dual!r}", depth=1, jump_kind="value", expect=f"Battery Power {POW_DIV3_DUAL} at Divide 10^3 + Dual ON") # RESTORE: dual OFF then Reset multiplier. restore_dual_off() restore_multiplier() @and_test(expects=("computation_power_dual_only",)) def test_power_dual_only(): """Dual Cell ON at the DEFAULT multiplier doubles power 4500 -> "9000 W" (integer -> no decimals). Depth 0 (no dialog).""" if not ready(): record("computation_power_dual_only", False, "setup_failed: app did not reach foreground", depth=0, jump_kind="value", expect=f"Battery Power {POW_DUAL} with Dual Cell ON") return before = read_first(power_value, POW_DEFAULT) dual = find_node(ui(), content_desc=CD_DUAL) if dual is None: record("computation_power_dual_only", False, "feature_missing: no 'Toggle Dual Battery' control", depth=0, jump_kind="value", expect=f"Battery Power {POW_DUAL} with Dual Cell ON") return dual_ok = tap_node(dual) after = read_first(power_value, POW_DUAL) ok = (before == POW_DEFAULT) and dual_ok and (after == POW_DUAL) \ and dual_value(ui()) == DUAL_YES record("computation_power_dual_only", ok, "" if ok else f"behavior_wrong: Dual Cell ON should double Power {POW_DEFAULT} to " f"{POW_DUAL}; saw before={before!r} after={after!r}", depth=0, jump_kind="value", expect=f"Battery Power {POW_DUAL} with Dual Cell ON") restore_dual_off() # ══════════════════════════════════════════════════════════════════════════════ # TEMPERATURE C<->F — exact recomputed unit string. Both directions, depth 0. # ══════════════════════════════════════════════════════════════════════════════ @and_test(expects=("computation_temp_c_to_f",)) def test_temp_c_to_f(): if not ready(): record("computation_temp_c_to_f", False, "setup_failed: app did not reach foreground", depth=0, jump_kind="value", expect=f"Battery Temperature {TEMP_F}") return before = read_first(temp_value, TEMP_C) sw = find_node(ui(), content_desc=CD_SWAP) if sw is None or not tap_node(sw): record("computation_temp_c_to_f", False, "feature_missing: no 'Swap Unit' control on the temperature card", depth=0, jump_kind="value", expect=f"Battery Temperature {TEMP_F}") return after = read_first(temp_value, TEMP_F) ok = (before == TEMP_C) and (after == TEMP_F) record("computation_temp_c_to_f", ok, "" if ok else f"behavior_wrong: swap should convert {TEMP_C} -> {TEMP_F} (C*9/5+32); " f"saw before={before!r} after={after!r}", depth=0, jump_kind="value", expect=f"Battery Temperature {TEMP_F}") restore_temp_c() @and_test(expects=("computation_temp_f_to_c",)) def test_temp_f_to_c(): """Second swap converts Fahrenheit back to the exact "25.0°C".""" if not ready(): record("computation_temp_f_to_c", False, "setup_failed: app did not reach foreground", depth=0, jump_kind="value", expect=f"Battery Temperature {TEMP_C}") return start = read_first(temp_value, TEMP_C) sw = find_node(ui(), content_desc=CD_SWAP) if sw is None or not tap_node(sw): record("computation_temp_f_to_c", False, "feature_missing: no 'Swap Unit' control on the temperature card", depth=0, jump_kind="value", expect=f"Battery Temperature {TEMP_C}") return to_f = read_first(temp_value, TEMP_F) sw = find_node(ui(), content_desc=CD_SWAP) back_ok = sw is not None and tap_node(sw) to_c = read_first(temp_value, TEMP_C) ok = (start == TEMP_C) and (to_f == TEMP_F) and back_ok and (to_c == TEMP_C) record("computation_temp_f_to_c", ok, "" if ok else f"behavior_wrong: second swap should convert {TEMP_F} -> {TEMP_C}; " f"saw start={start!r} to_f={to_f!r} to_c={to_c!r}", depth=0, jump_kind="value", expect=f"Battery Temperature {TEMP_C}") restore_temp_c() # ══════════════════════════════════════════════════════════════════════════════ # ROUND-TRIP integrity — the computation is REVERSIBLE to the exact baseline. # ══════════════════════════════════════════════════════════════════════════════ @and_test(expects=("computation_current_divide_then_reset",)) def test_current_divide_then_reset(): """Divide 10^3 -> Current 900 mA, then Reset -> Current back to EXACTLY 900000 mA. depth=1 (the Calibrate dialog is entered twice).""" if not ready(): record("computation_current_divide_then_reset", False, "setup_failed: app did not reach foreground", depth=1, jump_kind="value", expect=f"Battery Current {CUR_DEFAULT} after Divide 10^3 then Reset") return before = read_first(cur_value, CUR_DEFAULT) if find_node(ui(), content_desc=CD_CALIBRATE) is None: record("computation_current_divide_then_reset", False, "feature_missing: no 'Calibrate' control on the Battery Current card", depth=1, jump_kind="value", expect=f"Battery Current {CUR_DEFAULT} after Divide 10^3 then Reset") return calc_ok = apply_multiplier("divide", "10^3") mid = read_first(cur_value, CUR_DIV3) # reopen dialog and Reset (restores AND closes) reset_ok = False if and_enter_calibrate(): reset_ok = cal_reset() _dec_depth() final = read_first(cur_value, CUR_DEFAULT) ok = (before == CUR_DEFAULT and calc_ok and mid == CUR_DIV3 and reset_ok and final == CUR_DEFAULT) record("computation_current_divide_then_reset", ok, "" if ok else f"behavior_wrong: expected {CUR_DEFAULT}->(Divide 10^3)->{CUR_DIV3}->" f"(Reset)->{CUR_DEFAULT}; saw before={before!r} mid={mid!r} final={final!r}", depth=1, jump_kind="value", expect=f"Battery Current {CUR_DEFAULT} after Divide 10^3 then Reset") restore_multiplier() @and_test(expects=("computation_temp_swap_round_trip",)) def test_temp_swap_round_trip(): """Two swaps return the temperature to EXACTLY "25.0°C" (C->F->C). depth 0.""" if not ready(): record("computation_temp_swap_round_trip", False, "setup_failed: app did not reach foreground", depth=0, jump_kind="value", expect=f"Battery Temperature {TEMP_C} after two swaps") return start = read_first(temp_value, TEMP_C) sw = find_node(ui(), content_desc=CD_SWAP) if sw is None or not tap_node(sw): record("computation_temp_swap_round_trip", False, "feature_missing: no 'Swap Unit' control on the temperature card", depth=0, jump_kind="value", expect=f"Battery Temperature {TEMP_C} after two swaps") return mid = read_first(temp_value, TEMP_F) sw = find_node(ui(), content_desc=CD_SWAP) back_ok = sw is not None and tap_node(sw) final = read_first(temp_value, TEMP_C) ok = (start == TEMP_C) and (mid == TEMP_F) and back_ok and (final == TEMP_C) record("computation_temp_swap_round_trip", ok, "" if ok else f"behavior_wrong: two swaps should return to {TEMP_C}; saw start={start!r} " f"mid={mid!r} final={final!r}", depth=0, jump_kind="value", expect=f"Battery Temperature {TEMP_C} after two swaps") restore_temp_c() TESTS = [ # current multiplier (6, depth 1) test_current_divide_10p1, test_current_divide_10p2, test_current_divide_10p3, test_current_divide_10p4, test_current_divide_10p5, # + 1 VLM (content) test_current_multiply_10p1, # power (5: 1 depth0 + 4 depth1) test_power_baseline, test_power_divide_10p2, test_power_divide_10p3, # + 1 VLM (content) test_power_divide_10p4, test_power_divide_10p3_dual, test_power_dual_only, # temperature (2, depth 0) test_temp_c_to_f, test_temp_f_to_c, # round-trips (2) test_current_divide_then_reset, # depth 1 test_temp_swap_round_trip, # depth 0 ] if __name__ == "__main__": run_suite(TESTS, "computation")