blob: acc50e6119b4f61ed6290b274e614c4e4c0fcdcb [file]
# Copyright 2026 The Fuchsia Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Unit tests for the cpu diagnostic analysis plugin."""
import unittest
from typing import Any
from unittest.mock import MagicMock, patch
from cpu import (
CpuPlugin,
_analyze_binder_overhead,
_analyze_core_utilization_from_average,
_analyze_core_utilization_from_counters,
)
from plugins import PluginArgumentError
class CpuPluginTest(unittest.TestCase):
"""Tests for the cpu analysis plugin using mock trace processor queries."""
def setUp(self) -> None:
self.all_tables = {
"trace_bounds",
"thread_state",
"thread",
"process",
"slice",
"thread_track",
"counter",
"process_counter_track",
"flow",
}
def test_analyze_success_flow(self) -> None:
"""Tests that all 6 diagnostic sections are executed in prioritized order with expected outputs."""
plugin = CpuPlugin()
mock_tp = MagicMock()
mock_tp.get_tables.return_value = self.all_tables
def run_query_mock(sql: str) -> list[dict[str, Any]]:
if "wakeup_count" in sql:
return [
{
"thread_name": "idle",
"tid": 0,
"process_name": "idle",
"pid": 0,
"wakeup_count": 5000,
"avg_duration_ms": 0.85,
},
{
"thread_name": "worker_thread",
"tid": 101,
"process_name": "app.cm",
"pid": 42,
"wakeup_count": 1200,
"avg_duration_ms": 0.05,
},
]
elif "Rate:CPU" in sql or "effective_load_pct" in sql:
return [
{
"cpu": 0,
"running_ms": 150.0,
"running_pct": 1.5,
"avg_rate_pct": 52.4,
"min_rate_pct": 40.0,
"max_rate_pct": 100.0,
"effective_load_pct": 0.79,
}
]
elif "total_cpu_ms" in sql and "thread_state" in sql:
return [
{
"thread_name": "heavy_worker",
"tid": 201,
"process_name": "service.cm",
"pid": 50,
"total_cpu_ms": 320.5,
}
]
elif "slice_count" in sql:
return [
{
"thread_name": "async_executor",
"tid": 301,
"slice_count": 450,
"total_duration_ms": 42.1,
}
]
elif "binder transaction" in sql:
return [
{
"thread_name": "binder:401",
"tid": 401,
"process_name": "android.service",
"pid": 80,
"transaction_count": 85,
"total_duration_ms": 15.4,
"max_duration_ms": 2.1,
}
]
elif "wake_lease" in sql or "suspend" in sql:
return [
{
"event_name": "acquire_wake_lease:power",
"thread_name": "sag_thread",
"process_name": "system-activity-governor.cm",
"occurrences": 12,
"total_duration_ms": 55.0,
"max_duration_ms": 10.0,
}
]
return []
mock_tp.run_query.side_effect = run_query_mock
with patch("cpu.PerfettoTraceProcessor") as mock_tp_class:
mock_tp_class.return_value.__enter__.return_value = mock_tp
results = plugin.analyze(["--limit", "10"], "dummy_trace")
self.assertEqual(len(results), 6)
# 1. Restless Sleepers (Wakeups)
self.assertEqual(results[0].name, "Restless Sleepers (Wakeup Counts)")
res0 = results[0].results
assert res0 is not None
self.assertEqual(len(res0), 2)
self.assertEqual(res0[0]["thread_name"], "idle")
self.assertEqual(res0[1]["wakeup_count"], 1200)
# 2. Per-Core Utilization & Processing Rate
self.assertEqual(
results[1].name, "Per-Core Utilization & Processing Rate"
)
res1 = results[1].results
assert res1 is not None
self.assertEqual(len(res1), 1)
self.assertEqual(res1[0]["cpu"], 0)
self.assertEqual(res1[0]["avg_rate_pct"], 52.4)
# 3. Top CPU Consumers
self.assertEqual(results[2].name, "Top CPU Consumers (Usual Suspects)")
res2 = results[2].results
assert res2 is not None
self.assertEqual(len(res2), 1)
self.assertEqual(res2[0]["total_cpu_ms"], 320.5)
# 4. Fuchsia Async Executor Overhead
self.assertEqual(results[3].name, "Fuchsia Async Executor Overhead")
res3 = results[3].results
assert res3 is not None
self.assertEqual(len(res3), 1)
self.assertEqual(res3[0]["slice_count"], 450)
# 5. Binder IPC Breakdown
self.assertEqual(results[4].name, "Binder IPC Breakdown")
res4 = results[4].results
assert res4 is not None
self.assertEqual(len(res4), 1)
self.assertEqual(res4[0]["transaction_count"], 85)
# 6. Suspend and Wake Lease Tracking
self.assertEqual(results[5].name, "Suspend and Wake Lease Tracking")
res5 = results[5].results
assert res5 is not None
self.assertEqual(len(res5), 1)
self.assertEqual(res5[0]["event_name"], "acquire_wake_lease:power")
def test_binder_breakdown_counts_starnix_transactions(self) -> None:
"""Tests that Starnix binder transactions come from the enqueue/dequeue flow chain."""
mock_tp = MagicMock()
captured: list[str] = []
def run_query_mock(sql: str) -> list[dict[str, Any]]:
captured.append(sql)
return []
mock_tp.run_query.side_effect = run_query_mock
_analyze_binder_overhead(mock_tp, self.all_tables, 10)
query = captured[0]
# Round trip from the client's enqueue_transaction to its dequeue_reply.
for step in [
"e.name = 'enqueue_transaction'",
"d.name = 'dequeue_transaction'",
"r.name = 'enqueue_reply'",
"c.name = 'dequeue_reply'",
]:
with self.subTest(step=step):
self.assertIn(step, query)
self.assertIn("(c.ts - e.ts) AS dur", query)
self.assertIn("e.name = 'enqueue_oneway'", query)
self.assertIn("AS oneway_count", query)
# Linux ftrace slices still count.
self.assertIn("s.name LIKE 'binder transaction%'", query)
def test_analyze_empty_results(self) -> None:
"""Tests that empty query results format as empty lists across all 6 sections."""
plugin = CpuPlugin()
mock_tp = MagicMock()
mock_tp.get_tables.return_value = self.all_tables
mock_tp.run_query.return_value = []
with patch("cpu.PerfettoTraceProcessor") as mock_tp_class:
mock_tp_class.return_value.__enter__.return_value = mock_tp
results = plugin.analyze([], "dummy_trace")
self.assertEqual(len(results), 6)
for section in results:
self.assertTrue(section.name)
self.assertEqual(section.results, [])
def test_analyze_missing_schema(self) -> None:
"""Tests that missing schema tables are handled gracefully with section error messages."""
plugin = CpuPlugin()
mock_tp = MagicMock()
mock_tp.get_tables.return_value = set()
mock_tp.run_query.return_value = []
with patch("cpu.PerfettoTraceProcessor") as mock_tp_class:
mock_tp_class.return_value.__enter__.return_value = mock_tp
results = plugin.analyze([], "dummy_trace")
self.assertEqual(len(results), 6)
for section in results:
assert section.error is not None
self.assertIn("Required schema tables/views missing", section.error)
def test_analyze_without_frequency_counters(self) -> None:
"""Tests that Query 2 falls back to core utilization when frequency counters are absent."""
plugin = CpuPlugin()
mock_tp = MagicMock()
# All required tables except counter and process_counter_track
tables_no_counters = {
"trace_bounds",
"thread_state",
"thread",
"process",
"slice",
"thread_track",
}
mock_tp.get_tables.return_value = tables_no_counters
def run_query_mock(sql: str) -> list[dict[str, Any]]:
if "running_pct" in sql:
self.assertNotIn("process_counter_track", sql)
return [
{
"cpu": 0,
"running_ms": 100.0,
"running_pct": 2.0,
"avg_rate_pct": None,
"min_rate_pct": None,
"max_rate_pct": None,
"effective_load_pct": 2.0,
}
]
return []
mock_tp.run_query.side_effect = run_query_mock
with patch("cpu.PerfettoTraceProcessor") as mock_tp_class:
mock_tp_class.return_value.__enter__.return_value = mock_tp
results = plugin.analyze([], "dummy_trace")
self.assertEqual(len(results), 6)
core_util_section = results[1]
self.assertEqual(
core_util_section.name, "Per-Core Utilization & Processing Rate"
)
core_results = core_util_section.results
assert core_results is not None
self.assertEqual(len(core_results), 1)
self.assertIsNone(core_results[0]["avg_rate_pct"])
def test_analyze_query_failure(self) -> None:
"""Tests that runtime SQL query failures return formatted error dicts without crashing."""
plugin = CpuPlugin()
mock_tp = MagicMock()
mock_tp.get_tables.return_value = self.all_tables
mock_tp.run_query.side_effect = RuntimeError(
"database disk image is malformed"
)
with patch("cpu.PerfettoTraceProcessor") as mock_tp_class:
mock_tp_class.return_value.__enter__.return_value = mock_tp
results = plugin.analyze([], "dummy_trace")
self.assertEqual(len(results), 6)
for section in results:
assert section.error is not None
self.assertIn(
"Query execution failed: database disk image is malformed",
section.error,
)
def test_analyze_core_utilization_variants_directly(self) -> None:
"""Tests calling from_counters and from_average variants directly."""
mock_tp = MagicMock()
mock_tp.run_query.return_value = [
{
"cpu": 0,
"running_ms": 100.0,
"running_pct": 2.0,
"avg_rate_pct": 50.0,
"min_rate_pct": 40.0,
"max_rate_pct": 60.0,
"effective_load_pct": 1.0,
}
]
res_counters = _analyze_core_utilization_from_counters(
mock_tp, self.all_tables
)
self.assertEqual(
res_counters.name, "Per-Core Utilization & Processing Rate"
)
assert res_counters.results is not None
self.assertEqual(len(res_counters.results), 1)
res_average = _analyze_core_utilization_from_average(
mock_tp, self.all_tables
)
self.assertEqual(
res_average.name, "Per-Core Utilization & Processing Rate"
)
assert res_average.results is not None
self.assertEqual(len(res_average.results), 1)
def test_analyze_with_counter_tables_but_no_power_tracks(self) -> None:
"""Tests that from_average is used when counter tables exist but no kernel:power tracks exist."""
plugin = CpuPlugin()
mock_tp = MagicMock()
mock_tp.get_tables.return_value = self.all_tables
def run_query_mock(sql: str) -> list[dict[str, Any]]:
if "LIMIT 1" in sql and "Rate:CPU:%" in sql:
# Probe query finds no kernel:power tracks
return []
if "running_pct" in sql:
self.assertNotIn("process_counter_track", sql)
return [
{
"cpu": 0,
"running_ms": 100.0,
"running_pct": 2.0,
"avg_rate_pct": None,
"min_rate_pct": None,
"max_rate_pct": None,
"effective_load_pct": 2.0,
}
]
return []
mock_tp.run_query.side_effect = run_query_mock
with patch("cpu.PerfettoTraceProcessor") as mock_tp_class:
mock_tp_class.return_value.__enter__.return_value = mock_tp
results = plugin.analyze([], "dummy_trace")
self.assertEqual(len(results), 6)
core_util_section = results[1]
self.assertEqual(
core_util_section.name, "Per-Core Utilization & Processing Rate"
)
core_results = core_util_section.results
assert core_results is not None
self.assertEqual(len(core_results), 1)
self.assertIsNone(core_results[0]["avg_rate_pct"])
def test_analyze_invalid_limit(self) -> None:
"""Tests that invalid, non-positive, or non-integer limits raise PluginArgumentError."""
plugin = CpuPlugin()
for invalid_limit in ["0", "-5"]:
with self.subTest(limit=invalid_limit):
with self.assertRaisesRegex(
PluginArgumentError, "Limit must be a positive integer"
):
plugin.analyze(["--limit", invalid_limit], "dummy_trace")
with self.assertRaisesRegex(PluginArgumentError, "invalid int value"):
plugin.analyze(["--limit", "abc"], "dummy_trace")
if __name__ == "__main__":
unittest.main()