device-devtools-mcp 0.1.0

package/scripts/snapshot.awk

@@ -0,0 +1,362 @@
+# snapshot.awk — normalised rows in, a screen an agent can read out.
+#
+#   awk -v ALL=0 -v GREP="" -v MINHIT=44 [-v MODE=store] -f snapshot.awk < rows
+#
+# Everything here is arithmetic over rectangles and tests over strings. There is
+# no estimate anywhere in this file, and that is the rule it is written to keep:
+# a warning that is wrong one time in five is a warning an agent learns to skip,
+# which is worse than not having it. So "the text does not fit" is not computed
+# from a character count — the only truncation reported is the one the operating
+# system already performed and left an ellipsis to prove.
+#
+# ALL=1     show every element, no filter
+# GREP=s    case-insensitive substring of type, id, label or value
+# MINHIT=n  the minimum comfortable hit area, in points (44 iOS, 48 Android)
+# MODE      "display" (default) or "store", which emits the uid table instead
+#
+# Input, one element per line, twelve '|' separated fields, produced by each
+# adapter's snapshot_rows:
+#
+#   WINDOW|<w>|<h>|<orientation>
+#   <n>|<depth>|<parent-n>|<type>|<id>|<label>|<value>|<x>|<y>|<w>|<h>|<flags>
+#
+# exit 0  a screen was printed
+# exit 4  the rows were empty, or nothing survived the filter
+
+BEGIN {
+  FS = "|"
+  n = 0
+  if (MODE == "") MODE = "display"
+
+  # HOW MANY POINTS COUNT AS NOTHING.
+  #
+  # Both drivers report rectangles as floating point and this pipeline floors
+  # them, so each edge carries up to a point of error and any pair of edges up
+  # to two. A "1pt overlap" between two stacked lines of text is therefore not a
+  # layout bug, it is the arithmetic.
+  #
+  # Measured on a real, dense screen before this existed: a list of six
+  # contacts produced thirty-one warnings, of which twenty-three were overlaps
+  # of one to two points between text lines that are visibly not touching, and
+  # four were labels sitting four points outside a table cell that clips
+  # nothing. The eight that mattered — a 24x25 button, and the same button
+  # hanging eight points off the right edge — were buried in them.
+  #
+  # So anything at or below this is not reported. It is a floor on what this
+  # file will claim to have seen, not a judgement about what matters.
+  if (TOL == "") TOL = 2
+  # A byte table, because macOS awk has no ord() and its length()/substr() count
+  # bytes rather than characters. Every byte value matters: fold the non-ASCII
+  # ones together and two Vietnamese labels differing only in their diacritics
+  # would hash the same, which would report two screens as one and take change
+  # detection quietly out of service.
+  for (i = 1; i < 256; i++) ORD[sprintf("%c", i)] = i
+}
+
+$1 == "WINDOW" {
+  WW = $2 + 0; WH = $3 + 0; ORIENT = $4
+  next
+}
+
+$0 == "" { next }
+
+{
+  n++
+  serial[n] = $1 + 0
+  depth[n]  = $2 + 0
+  parent[n] = $3 + 0
+  type[n]   = $4
+  id[n]     = $5
+  label[n]  = $6
+  value[n]  = $7
+  x[n] = $8 + 0; y[n] = $9 + 0; w[n] = $10 + 0; h[n] = $11 + 0
+  flags[n]  = $12
+  byserial[$1 + 0] = n
+}
+
+function has(f, s)  { return index("," f ",", "," s ",") > 0 }
+function best(i)    { return label[i] != "" ? label[i] : (value[i] != "" ? value[i] : id[i]) }
+
+# Covers the window, give or take the same two points everything else gets.
+function fullscreen(i) {
+  if (WW <= 0 || WH <= 0) return 0
+  return (x[i] <= TOL && y[i] <= TOL \
+          && w[i] >= WW - TOL && h[i] >= WH - TOL)
+}
+
+# Overlap of two intervals, in points. Negative or zero means no overlap.
+function span(a1, a2, b1, b2,   lo, hi) {
+  lo = (a1 > b1) ? a1 : b1
+  hi = (a2 < b2) ? a2 : b2
+  return hi - lo
+}
+
+# An element is shown when it is visible AND it carries something to identify it
+# by, or is something a person can act on. An invisible element with a label is
+# noise; an unlabelled button is not, because a screen whose only three controls
+# are unlabelled would otherwise read as having nothing to tap.
+#
+# --grep searches the whole tree, including what the filter hides, so it can
+# find something that is present but off screen.
+function shown(i,   hay) {
+  if (GREP != "") {
+    hay = tolower(type[i] " " id[i] " " label[i] " " value[i])
+    return index(hay, tolower(GREP)) > 0
+  }
+  if (ALL == 1) return 1
+  if (!has(flags[i], "visible")) return 0
+  if (id[i] != "" || label[i] != "" || value[i] != "") return 1
+  return has(flags[i], "actionable")
+}
+
+# A stable, short identity for the screen: the set of (type,label) pairs of the
+# shown elements, folded into sixteen bits.
+#
+# NOT A CRYPTOGRAPHIC HASH AND NOT CLAIMING TO BE ONE. It answers "is this the
+# same screen as the one before", and a collision costs one unnecessary re-read.
+# XCUITest and UiAutomator publish no view-controller or activity class, so
+# there is no name to use instead; this is the honest substitute and it claims
+# less than a class name would.
+function screenhash(   i, s, acc, j) {
+  s = ""
+  for (i = 1; i <= n; i++) if (shown(i)) s = s type[i] "\037" label[i] "\036"
+  acc = 5381
+  for (j = 1; j <= length(s); j++)
+    acc = (acc * 33 + ORD[substr(s, j, 1)]) % 65536
+  return sprintf("%04x", acc)
+}
+
+# The screen's name: a navigation bar's label if there is one, otherwise the
+# topmost static text. Both are guesses about which string a person would call
+# the screen, and neither is load-bearing — the hash is what gets compared.
+function screenname(   i, bestY, name) {
+  for (i = 1; i <= n; i++)
+    if (type[i] ~ /NavigationBar|Toolbar|ActionBar/ && best(i) != "") return best(i)
+  bestY = 1000000; name = ""
+  for (i = 1; i <= n; i++) {
+    if (!shown(i) || best(i) == "") continue
+    if (type[i] !~ /StaticText|TextView|Label/) continue
+    if (y[i] < bestY) { bestY = y[i]; name = best(i) }
+  }
+  return name
+}
+
+END {
+  if (n == 0) {
+    print "the driver returned no elements" > "/dev/stderr"
+    exit 4
+  }
+
+  uid = 0
+  for (i = 1; i <= n; i++) {
+    if (!shown(i)) continue
+    uid++
+    uidof[i] = uid
+    order[uid] = i
+  }
+  if (uid == 0) {
+    print "nothing matched" > "/dev/stderr"
+    exit 4
+  }
+
+  # The uid table, for whoever has to resolve one of these numbers later. Same
+  # numbering as the display, by construction rather than by agreement: both
+  # come from the loop above.
+  #
+  # SEPARATED BY '|', NOT BY A TAB, and that is not a style choice. Two of these
+  # fields — the identifier and the value — are routinely empty, and bash `read`
+  # treats runs of a WHITESPACE delimiter as one separator. A tab is whitespace,
+  # so two empty fields in a row collapse and every field after them shifts
+  # left: the label ends up holding an x coordinate. A pipe is not whitespace,
+  # so empty fields survive, and the adapters have already replaced any pipe
+  # inside application copy with a slash.
+  if (MODE == "store") {
+    for (u = 1; u <= uid; u++) {
+      i = order[u]
+      printf "%d|%d|%s|%s|%s|%s|%d|%d|%d|%d\n",
+        u, serial[i], type[i], id[i], label[i], value[i], x[i], y[i], w[i], h[i]
+    }
+    exit 0
+  }
+
+  # The status bar's height, from the status bar. Zero when the tree has none,
+  # which is the honest answer for a full-screen app.
+  SBH = 0
+  for (i = 1; i <= n; i++)
+    if (type[i] ~ /StatusBar/ && y[i] <= TOL && h[i] > SBH) SBH = h[i]
+
+  nm = screenname()
+  if (nm != "") printf "SCREEN \"%s\" #%s  %dx%d  %s\n\n", nm, screenhash(), WW, WH, ORIENT
+  else          printf "SCREEN #%s  %dx%d  %s\n\n", screenhash(), WW, WH, ORIENT
+
+  for (u = 1; u <= uid; u++) {
+    i = order[u]
+
+    # THE IDENTIFIER IS PRINTED WHEN THERE IS ONE, AND SEPARATELY FROM THE TEXT.
+    #
+    # --grep has always searched identifiers, so a screen could be found by an
+    # identifier the display never showed — the data was here and the line did
+    # not carry it. It is also the one selector that survives a change of copy
+    # and a change of language, which makes it the one anybody writing a flow
+    # should reach for first. Shown as #id, beside the words rather than instead
+    # of them, because a name and a caption answer different questions.
+    #
+    # best() is left alone deliberately: it feeds the screen hash and the screen
+    # name, and changing what those fold over would silently invalidate every
+    # waypoint recorded before today.
+    line = sprintf("[%d]  %s", u, type[i])
+    if (id[i] != "") line = line sprintf(" #%s", id[i])
+    cap = (label[i] != "" ? label[i] : value[i])
+    if (cap != "") line = line sprintf(" \"%s\"", cap)
+    line = line sprintf("  (%d,%d)  %dx%d", x[i], y[i], w[i], h[i])
+    if (has(flags[i], "actionable"))
+      line = line (has(flags[i], "enabled") ? "  enabled" : "  disabled")
+    if (type[i] ~ /TextField|EditText|SearchField/ && value[i] == "")
+      line = line "  empty"
+    print line
+
+    # --- the warnings ---------------------------------------------------------
+    #
+    # Collected, not printed here. See the note above the LAYOUT block below.
+
+    # Zero size, but carrying text somebody meant to be read.
+    if ((w[i] == 0 || h[i] == 0) && best(i) != "")
+      warn(u, "zero size, but it carries text")
+
+    # Off the window, wholly or partly.
+    if (WW > 0 && WH > 0) {
+      if (x[i] >= WW || y[i] >= WH || x[i] + w[i] <= 0 || y[i] + h[i] <= 0) {
+        warn(u, "off screen")
+      } else {
+        over = 0
+        if (x[i] + w[i] > WW) over = x[i] + w[i] - WW
+        if (y[i] + h[i] > WH && y[i] + h[i] - WH > over) over = y[i] + h[i] - WH
+        if (x[i] < 0 && -x[i] > over) over = -x[i]
+        if (y[i] < 0 && -y[i] > over) over = -y[i]
+        if (over > TOL) warn(u, sprintf("partly off screen by %dpt", over))
+      }
+    }
+
+    # Outside the parent.
+    p = byserial[parent[i]]
+    if (p != "" && p > 0 && w[p] > 0 && h[p] > 0) {
+      esc = 0
+      if (x[i] < x[p]) esc = x[p] - x[i]
+      if (x[i] + w[i] > x[p] + w[p] && x[i] + w[i] - (x[p] + w[p]) > esc)
+        esc = x[i] + w[i] - (x[p] + w[p])
+      if (y[i] < y[p] && y[p] - y[i] > esc) esc = y[p] - y[i]
+      if (y[i] + h[i] > y[p] + h[p] && y[i] + h[i] - (y[p] + h[p]) > esc)
+        esc = y[i] + h[i] - (y[p] + h[p])
+      if (esc > TOL) warn(u, sprintf("outside its parent by %dpt", esc))
+    }
+
+    # Overlapping a shown sibling. Siblings only: a child overlapping its parent
+    # is what a child does. The worst overlap is the one reported — which
+    # sibling it is comes from `measure`, whose job is exactly that question.
+    worst = 0
+    for (v = 1; v < u; v++) {
+      j = order[v]
+      if (parent[j] != parent[i]) continue
+      # TWO FULL-SCREEN LAYERS ARE NOT AN OVERLAP, THEY ARE A STACK.
+      #
+      # --all shows the containers, and a screen is built out of several boxes
+      # that each cover the whole window. Reported as "overlaps a sibling by
+      # 428pt — [7] [8] [10] and 9 more", which is a true sentence about
+      # something no layout has ever got wrong.
+      if (fullscreen(i) && fullscreen(j)) continue
+      ox = span(x[i], x[i] + w[i], x[j], x[j] + w[j])
+      oy = span(y[i], y[i] + h[i], y[j], y[j] + h[j])
+      if (ox > TOL && oy > TOL) {
+        d = (ox < oy ? ox : oy)
+        if (d > worst) worst = d
+      }
+    }
+    if (worst > 0) warn(u, sprintf("overlaps a sibling by %dpt", worst))
+
+    # THE POINT A TAP LANDS ON, NOT THE BOX IT BELONGS TO.
+    #
+    # Every tap goes to the centre of the rectangle. Spotlight's search field
+    # measures (32,4) 364x48, which looks generous — but its centre is at y=28,
+    # underneath a status bar 47pt tall, so the tap lands on the clock and the
+    # keyboard never appears. The element is not too small and is not off
+    # screen; the one number that matters is simply covered.
+    #
+    # Only reported when the tree actually carries a StatusBar, because its
+    # height is measured rather than assumed.
+    if (has(flags[i], "actionable") && SBH > 0 && y[i] + h[i] / 2 < SBH)
+      warn(u, sprintf("tappable, but its centre is under the %dpt status bar", SBH))
+
+    # A hit area smaller than a fingertip. The size itself is already on the
+    # element's own line, so the warning does not repeat it.
+    if (has(flags[i], "actionable") && w[i] > 0 && h[i] > 0 &&
+        (w[i] < MINHIT || h[i] < MINHIT))
+      warn(u, sprintf("hit area below the %dpt minimum", MINHIT))
+
+    # A CONTROL WITH NO IDENTIFIER, WHICH IS A FAULT IN THE APP AND NOT ON THE
+    # SCREEN.
+    #
+    # Every other warning here is about geometry. This one is about whether the
+    # thing can be named at all: with no identifier the only way to reach it is
+    # its label, and a label changes when marketing rewrites the button or the
+    # app is read in another language. Nobody else is standing in the right
+    # place to say so — the tree is in front of us and it is not in front of the
+    # person who wrote the view.
+    #
+    # The keyboard is excluded. Its keys are the operating system's and telling
+    # an application developer to add identifiers to them is advice they cannot
+    # take.
+    if (has(flags[i], "actionable") && id[i] == "" && type[i] !~ /^(Key|Keyboard)$/)
+      warn(u, "no identifier: a selector has to use the label, which changes with the copy")
+
+    # The OS already truncated the string, and said so in the string.
+    s = best(i)
+    if (s ~ /…$/ || s ~ /\.\.\.$/)
+      warn(u, "the OS truncated this text with an ellipsis")
+  }
+
+  # --- what is wrong with this screen -----------------------------------------
+  #
+  # GROUPED BY MESSAGE, NOT PRINTED BESIDE EACH ELEMENT, AND THAT IS ABOUT COST.
+  #
+  # Measured on a real screen: a contact list of six identical rows produced the
+  # same three warnings once per row. Inline, that is forty-nine lines saying
+  # eight things, and an agent that reads forty-nine warnings on every screen
+  # stops reading warnings. Grouped, it is four lines and the uids are still
+  # there to act on.
+  #
+  # Nothing is dropped silently. When a group has more members than fit, the
+  # line says how many more.
+  if (nw > 0) {
+    printf "\n"
+    for (k = 1; k <= nw; k++) {
+      list = ""; shown_n = 0
+      cnt = split(wuids[k], parts, " ")
+      for (q = 1; q <= cnt && q <= 8; q++) {
+        list = list sprintf("%s[%s]", (list == "" ? "" : " "), parts[q])
+        shown_n++
+      }
+      if (cnt > shown_n) list = list sprintf(" and %d more", cnt - shown_n)
+      printf "⚠ %s — %s\n", wmsg[k], list
+    }
+  }
+}
+
+# warn <uid> <message> — remember it; the END block groups and prints.
+#
+# SILENT UNDER --grep, AND THAT IS THE POINT OF --grep.
+#
+# Without a filter this is an audit of the screen in front of you, and every
+# warning is about something you can see. --grep searches the whole tree
+# including what is off screen, so a home-screen icon sitting on another page
+# comes back "zero size, but it carries text" and "off screen" — both true,
+# neither a layout fault, and both noise in front of the one line the caller
+# asked for. Reported by an agent that grepped for an icon and got two warnings
+# about the phone not currently showing it.
+function warn(u, msg,   k) {
+  if (GREP != "") return
+  for (k = 1; k <= nw; k++)
+    if (wmsg[k] == msg) { wuids[k] = wuids[k] " " u; return }
+  nw++
+  wmsg[nw] = msg
+  wuids[nw] = u
+}

package/scripts/verify-npm-package.js

@@ -0,0 +1,133 @@
+#!/usr/bin/env node
+// verify-npm-package.js — pack it, install it somewhere else, and use it.
+//
+//   npm run verify-npm-package
+//
+// WHAT THIS IS FOR
+//
+// `npm pack` silently dropped all forty-four symlinks in scripts/ — the entire
+// verb surface — and produced a tarball that installs cleanly, starts cleanly,
+// and answers `unknown tool` to every one of the twenty-one tools. Nothing
+// about that looks like a failure until somebody tries to tap something.
+//
+// A published package is the one artefact in this repository that neither
+// self-test covers: they both run against the working tree, where the symlinks
+// are simply there. So this builds the real thing, unpacks it into a directory
+// with no relation to this one, and drives it: the handshake, the tool list,
+// and a verb — through the same `npx`-shaped entry point a user would get.
+//
+// It does not publish anything and needs no network.
+//
+// exit 0  the package works where it lands
+// exit 1  it does not, and the line above says which part
+
+'use strict';
+
+const { execFileSync, spawnSync } = require('node:child_process');
+const { mkdtempSync, rmSync, readdirSync, existsSync, writeFileSync, copyFileSync } = require('node:fs');
+const { join } = require('node:path');
+const { tmpdir } = require('node:os');
+
+const root = join(__dirname, '..');
+let failures = 0;
+
+function ok(what) { console.log(`OK   ${what}`); }
+function bad(what, detail) { console.log(`FAIL ${what} — ${detail}`); failures++; }
+function is(what, got, want) { got === want ? ok(what) : bad(what, `expected [${want}], got [${got}]`); }
+
+const work = mkdtempSync(join(tmpdir(), 'devicetools-pack-'));
+process.on('exit', () => rmSync(work, { recursive: true, force: true }));
+
+// --- build and unpack --------------------------------------------------------
+
+execFileSync('npm', ['pack', '--pack-destination', work], { cwd: root, stdio: 'pipe' });
+const tgz = readdirSync(work).find((f) => f.endsWith('.tgz'));
+if (!tgz) { bad('npm pack produces a tarball', 'no .tgz'); process.exit(1); }
+ok(`npm pack produces ${tgz}`);
+
+execFileSync('tar', ['xzf', join(work, tgz), '-C', work], { stdio: 'pipe' });
+const pkg = join(work, 'package');
+
+// --- the thing that was actually broken --------------------------------------
+
+const links = join(pkg, 'scripts', 'links.tsv');
+existsSync(links)
+  ? ok('the link manifest is in the tarball')
+  : bad('the link manifest is in the tarball', 'scripts/links.tsv is missing');
+
+// Before anything runs, the verbs are absent — that is npm, not a mistake, and
+// asserting it here means this check still means something on the day npm
+// starts carrying symlinks.
+existsSync(join(pkg, 'scripts', 'tap.sh'))
+  ? ok('npm now carries symlinks (the restore below is redundant, and harmless)')
+  : ok('npm dropped the symlinks, as expected — the restore is what fixes it');
+
+// --- drive it, the way npx would ---------------------------------------------
+//
+// A config it can find, in a directory that is not this repository, so nothing
+// can quietly fall back to the checkout being verified.
+const project = join(work, 'project');
+execFileSync('mkdir', ['-p', project]);
+writeFileSync(join(project, '.devicetools'), 'devicetools-project 1\n');
+copyFileSync(join(root, 'config.example.json'), join(project, 'config.json'));
+
+const entry = join(pkg, 'bin', 'device-devtools-mcp.js');
+const env = { ...process.env, DEVICETOOLS_CONFIG: join(project, 'config.json') };
+
+const rpc = [
+  '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-03-26"}}',
+  '{"jsonrpc":"2.0","id":2,"method":"tools/list"}',
+  '{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"waypoint","arguments":{"action":"list"}}}',
+].join('\n') + '\n';
+
+const server = spawnSync('node', [entry], { input: rpc, env, encoding: 'utf8' });
+const replies = server.stdout.trim().split('\n').filter(Boolean).map((l) => {
+  try { return JSON.parse(l); } catch { return null; }
+}).filter(Boolean);
+
+const listed = replies.find((r) => r.id === 2);
+const names = listed?.result?.tools?.map((t) => t.name).sort() ?? [];
+
+is('the server answers the handshake',
+   replies.find((r) => r.id === 1)?.result?.protocolVersion, '2025-03-26');
+is('every tool is on the list', String(names.length), '21');
+
+// THE FAILURE THIS FILE EXISTS FOR. A tool whose script is missing is still
+// advertised by tools/list — the list is built from a table, the dispatch is a
+// file lookup — so calling one is the only way to find out.
+const called = replies.find((r) => r.id === 3);
+if (called?.error) {
+  bad('a verb runs from the unpacked package', `${called.error.message} — the verb surface did not survive`);
+} else if (called?.result?.isError) {
+  bad('a verb runs from the unpacked package', called.result.content?.[0]?.text?.split('\n')[0] ?? 'error');
+} else {
+  ok('a verb runs from the unpacked package');
+}
+
+// The command line, through the same entry point.
+const cli = spawnSync('node', [entry, 'flow', 'list'], { env, encoding: 'utf8' });
+cli.status === 0
+  ? ok('the CLI runs from the unpacked package')
+  : bad('the CLI runs from the unpacked package', (cli.stderr || cli.stdout).trim().split('\n')[0]);
+
+// And the restore was not a one-off: the tree it left behind must be complete.
+const check = spawnSync('/bin/bash', [join(pkg, 'scripts', 'relink.sh'), '--check'], { encoding: 'utf8' });
+check.status === 0
+  ? ok('the restored tree is complete')
+  : bad('the restored tree is complete', check.stderr.trim());
+
+// --- nothing private, and nothing this machine's -----------------------------
+//
+// The package is the artefact that goes public. A grep over what is actually in
+// the tarball is cheaper than remembering.
+const listing = execFileSync('tar', ['tzf', join(work, tgz)], { encoding: 'utf8' });
+const forbidden = ['config.json\n', '.state/', '.runs/', '.git/'];
+const leaked = forbidden.filter((f) => listing.includes(`package/${f}`));
+leaked.length === 0
+  ? ok('no config, state or run artefacts are in the tarball')
+  : bad('no config, state or run artefacts are in the tarball', leaked.join(' '));
+
+console.log(failures === 0
+  ? 'RESULT PASS npm package'
+  : `RESULT FAIL npm package — ${failures} check(s)`);
+process.exit(failures === 0 ? 0 : 1);

package/tests/fixtures/ios-contacts-list.expected

@@ -0,0 +1,52 @@
+SCREEN "Liên hệ" #9b41  428x926  portrait
+
+[1]  Application "DemoApp"  (0,0)  428x926
+[2]  NavigationBar #Liên hệ  (0,47)  428x101
+[3]  Button  (20,51)  36x36  enabled
+[4]  StaticText "Liên hệ"  (19,108)  116x31
+[5]  StaticText "Liên hệ gần đây"  (24,224)  121x36
+[6]  StaticText "Liên hệ nhóm"  (153,224)  122x36
+[7]  StaticText "Liên hệ công việc"  (283,224)  121x36
+[8]  StaticText "Danh sách đã lưu"  (23,303)  126x18
+[9]  StaticText "Thêm mới"  (315,303)  65x18
+[10]  TextField "Tìm kiếm"  (72,368)  316x25  enabled
+[11]  StaticText "Tất cả"  (36,432)  39x19
+[12]  StaticText "Yêu thích"  (107,432)  60x19
+[13]  StaticText "Mã số"  (199,432)  82x19
+[14]  StaticText "Nhãn"  (312,432)  44x19
+[15]  Other "Vertical scroll bar, 1 pages"  (387,424)  30x35
+[16]  StaticText "000111222"  (68,520)  356x19
+[17]  StaticText "NGUOI DUNG A"  (68,500)  336x21
+[18]  StaticText "Acme Demo"  (68,482)  356x19
+[19]  Button "icMore"  (412,498)  24x25  enabled
+[20]  StaticText "000000******0000"  (68,600)  356x18
+[21]  StaticText "NGUOI DUNG C DEMO BA XX"  (68,579)  336x22
+[22]  StaticText "Acme Demo"  (68,562)  356x18
+[23]  Button "icMore"  (412,578)  24x25  enabled
+[24]  StaticText "000000******0000"  (68,679)  356x19
+[25]  StaticText "NGUOI DUNG E DEMO HAI TEST"  (68,659)  336x21
+[26]  StaticText "Epsilon"  (68,641)  356x19
+[27]  Button "icMore"  (412,657)  24x25  enabled
+[28]  StaticText "0000000000000"  (68,759)  356x19
+[29]  StaticText "NGUOI DUNG B DEMO MOT"  (68,739)  356x21
+[30]  StaticText "Delta"  (68,721)  356x19
+[31]  Button "icMore"  (412,737)  24x25  enabled
+[32]  StaticText "0000000000"  (68,839)  356x18
+[33]  StaticText "NGUOI DUNG H"  (68,818)  356x22
+[34]  StaticText "Gamma"  (68,801)  356x18
+[35]  Button "icMore"  (412,817)  24x25  enabled
+[36]  StaticText "000000******0000"  (68,918)  356x19
+[37]  StaticText "NGUOI DUNG D DEMO"  (68,898)  356x21
+[38]  StaticText "Alpha"  (68,880)  356x19
+[39]  Button "icMore"  (412,896)  24x25  enabled
+[40]  Other "Vertical scroll bar, 2 pages"  (395,148)  30x730
+[41]  Other "Horizontal scroll bar, 1 pages"  (47,893)  334x30
+
+⚠ hit area below the 44pt minimum — [3] [10] [19] [23] [27] [31] [35] [39]
+⚠ no identifier: a selector has to use the label, which changes with the copy — [3] [10] [19] [23] [27] [31] [35] [39]
+⚠ outside its parent by 4pt — [16] [18] [20] [22] [24] [26] [28] [29] and 7 more
+⚠ partly off screen by 8pt — [19] [23] [27] [31] [35] [39]
+⚠ outside its parent by 16pt — [19] [23] [27] [31] [35] [39]
+⚠ overlaps a sibling by 3pt — [19] [23] [27]
+⚠ overlaps a sibling by 12pt — [31] [35] [39]
+⚠ partly off screen by 11pt — [36]