Fail the adbd rule on a failed step, test the real gate [skip ci]

The android-tools rule in board patch 0015 ignored failed steps. A debian
series entry or android-tools.patch.sh step that stopped applying, a failed
build, and a failed copy into out/usr/bin all went on, and the stamp was
written after them. The stamp then marked a binary that was not built from
the patch set as current, which is the failure class of bfe-core1106-sdk#44
(bfe-core1106-sdk#45).

The rule now stops at each failed step. android-tools.patch.sh runs with
-e, so a failed middle step is not hidden by the status of the last patch,
and the stamp is written last. On a clean patch set the commands run are
the same as before; only the failure paths differ.

tests/test-adbd-no-tcp.sh runs the rule under make with stub toolchains, so
nothing compiles. It evaluates ADBD_INPUTS through make and compares it with
the sha256 of the Makefile, adbd-current.sh and the patch set. It checks the
skip and rebuild cases and five injected failures that must stop the rule
with no stamp. The old test replayed the steps by hand and recomputed the
gate formula, so a Makefile with a different ADBD_INPUTS still passed
(bfe-core1106-sdk#46).

tests/adbd-no-tcp-cases.sh runs the real patch (must pass), the unpatched
base (must fail) and three mutants of the patch, each of which must fail for
its own reason: ADBD_INPUTS over the Makefile only, no fail-fast, and an
unchecked copy. The pre-fix 0015 fails four of the five fail-closed cases,
and the stamp is written in each of the four.

[skip ci] keeps this push from starting a CI run: no CI runs until the
scada rebuild is verified.

Fixes #45
Fixes #46
Refs #44

Co-Authored-By: Claude Haiku 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01B1W6qGbdxD3FcrGMcjLNhv
This commit is contained in:
BFE Engineering
2026-11-15 14:21:53 -06:00
committed by Claude Haiku 5.5
co-authored by Claude Haiku 5.5
parent aa01bca930
commit 6f8903c1df
4 changed files with 314 additions and 64 deletions
+17 -6
View File
@@ -105,16 +105,21 @@ applying the patches, then stages `buildroot/files/` and applies
## Regression tests
`tests/test-adbd-no-tcp.sh BASE_DIR PATCH_FILE|none` replays the android-tools
build (tarball, debian series, `android-tools.patch.sh`) on the base tree and
checks the adbd TCP listener removal (flare-edge#3129) and the adbd rebuild
gate (bfe-core1106-sdk#44). `BASE_DIR` is the luckfox base commit 824b817f8,
`sysdrv/tools/board/android-tools` only:
`tests/test-adbd-no-tcp.sh BASE_DIR PATCH_FILE|none` applies the board patch to
a copy of the base tree and runs the android-tools rule of the Makefile under
make. It checks the adbd TCP listener removal (flare-edge#3129), the rule's
fail-closed behaviour (bfe-core1106-sdk#45) and the adbd rebuild gate as the
Makefile evaluates it (bfe-core1106-sdk#44, #46). `BASE_DIR` is the luckfox base
commit 824b817f8, `sysdrv/tools/board/android-tools` only:
git -C <luckfox-sdk> archive 824b817f8 sysdrv/tools/board/android-tools | tar -C BASE_DIR -xf -
sh tests/test-adbd-no-tcp.sh BASE_DIR board/patches/0015-adbd-no-tcp-listener.patch
sh tests/adbd-no-tcp-cases.sh BASE_DIR board/patches/0015-adbd-no-tcp-listener.patch
It compiles nothing. Run it with `none` as the patch file to see the base fail.
The toolchain is a stub: the compiler stub only creates its output file, so
nothing is compiled. Run the test with `none` as the patch file to see the base
fail. `adbd-no-tcp-cases.sh` runs the real patch (must pass), the unpatched base
and three mutants of the patch (each must fail for the reason it names).
## Completeness check
@@ -324,6 +329,12 @@ the binary (bfe-core1106-sdk#44). `adbd-current.sh` now compares a stamp in
`out/.adbd-inputs` with a hash of the Makefile, the gate script and the patch
set, and the build writes that stamp.
The rule now stops at the first failed step (a debian series entry, an
`android-tools.patch.sh` step run with `-e`, the build, or the copy into
`out/usr/bin`), and the stamp is written last. A failed step therefore never
leaves a stamp for an adbd that was not built from the patch set
(bfe-core1106-sdk#45).
### `board/patches/0009` to `0013` (issue #4)
Deltas that lived only in the workstation SDK until issue #4. Each patch
@@ -18,27 +18,38 @@ gates adbd on adbd-current.sh: the build writes a stamp holding a hash of the
Makefile, the gate script and the patch set, and a missing or stale stamp
rebuilds adbd.
Regression test: luckfox-sdk-patches/tests/test-adbd-no-tcp.sh.
The rule stops at the first failed step: a debian series entry, an
android-tools.patch.sh step (run with -e), the build, or the copy into
out/usr/bin. The stamp is written last, so no binary that was not built from
the patch set gets one (bfe-core1106-sdk#45).
Regression tests: luckfox-sdk-patches/tests/test-adbd-no-tcp.sh runs the rule
under make with stub toolchains. It checks the listeners, the fail-closed
cases, the stamp and the gate that the Makefile evaluates (bfe-core1106-sdk#46).
tests/adbd-no-tcp-cases.sh runs the real patch, the unpatched base and mutants
that must fail.
diff --git a/sysdrv/tools/board/android-tools/Makefile b/sysdrv/tools/board/android-tools/Makefile
index bb72255..50fae52 100644
index bb72255..889e983 100644
--- a/sysdrv/tools/board/android-tools/Makefile
+++ b/sysdrv/tools/board/android-tools/Makefile
@@ -23,6 +23,13 @@ PKG_TARBALL_DEBIAN := android-tools_4.2.2+git20130218-3ubuntu41.debian.tar.gz
@@ -23,6 +23,15 @@ PKG_TARBALL_DEBIAN := android-tools_4.2.2+git20130218-3ubuntu41.debian.tar.gz
PKG_BIN := out
PKG_INSTALL_BIN_DIR := $(CURRENT_DIR)/$(PKG_BIN)/usr/bin
+# flare-edge#3129: adbd is rebuilt whenever its inputs change. The stamp holds
+# the hash of this Makefile, adbd-current.sh and the android-tools patch set.
+# An adbd without a matching stamp (left in out/ by a build from other patches)
+# is built again from the regenerated source.
+# is built again from the regenerated source. Every step below stops the rule
+# when it fails, and the stamp is written last, so no binary that was not built
+# from the patch set gets one (bfe-core1106-sdk#45).
+ADBD_STAMP := $(CURRENT_DIR)/$(PKG_BIN)/.adbd-inputs
+ADBD_INPUTS := $(shell cat $(CURRENT_DIR)/Makefile $(CURRENT_DIR)/adbd-current.sh $(CURRENT_DIR)/$(PKG_PATCHES_ANDROID_TOOLS)/* | sha256sum | cut -d' ' -f1)
+
PKG_DEP_OPENSSL := $(CURRENT_DIR)/../toolkits/openssl
PKG_DEP_ZLIB := $(CURRENT_DIR)/../toolkits/zlib
@@ -36,7 +43,7 @@ PKG_CONF_OPTS += -mthumb -Wa,-mimplicit-it=thumb -mthumb-interwork
@@ -36,7 +45,7 @@ PKG_CONF_OPTS += -mthumb -Wa,-mimplicit-it=thumb -mthumb-interwork
endif
all: dep-openssl
@@ -47,11 +58,24 @@ index bb72255..50fae52 100644
rm -rf $(CURRENT_DIR)/$(PKG_NAME_ANDROID_TOOLS); \
tar -xf $(PKG_TARBALL_ANDROID_TOOLS); \
tar -xf $(PKG_TARBALL_DEBIAN) -C $(PKG_NAME_ANDROID_TOOLS); \
@@ -55,6 +62,7 @@ all: dep-openssl
@@ -45,16 +54,17 @@ all: dep-openssl
pushd $(CURRENT_DIR)/$(PKG_NAME_ANDROID_TOOLS)/; \
cp -af $(CURRENT_DIR)/$(PKG_PATCHES_ANDROID_TOOLS)/* ./; \
for item in `cat ./debian/patches/series`; do \
- patch -p1 < ./debian/patches/$$item; \
+ patch -p1 < ./debian/patches/$$item || exit 1; \
done; \
- $(SHELL) ./android-tools.patch.sh; \
+ $(SHELL) -e ./android-tools.patch.sh || exit 1; \
CC="$(SYSDRV_CROSS)-gcc" GCC="$(SYSDRV_CROSS)-gcc" CXX="$(SYSDRV_CROSS)-g++" CPP="$(SYSDRV_CROSS)-cpp" \
CFLAGS="$(PKG_CONF_OPTS)" CPPFLAGS="$(PKG_CONF_OPTS)" \
CXXFLAGS="$(PKG_CONF_OPTS)" LDFLAGS="$(PKG_CONF_OPTS) $(PKG_ADBD_BUILD_STATIC)" \
make -j$(SYSDRV_JOBS) -C $(CURRENT_DIR)/$(PKG_NAME_ANDROID_TOOLS)/$(PKG_BIN) \
SRCDIR=$(CURRENT_DIR)/$(PKG_NAME_ANDROID_TOOLS) \
-f $(CURRENT_DIR)/$(PKG_NAME_ANDROID_TOOLS)/debian/makefiles/adbd.mk 1>/dev/null || exit -1; \
cp -f $(CURRENT_DIR)/$(PKG_NAME_ANDROID_TOOLS)/$(PKG_BIN)/adbd $(PKG_INSTALL_BIN_DIR)/ ; \
+ echo $(ADBD_INPUTS) > $(ADBD_STAMP) ; \
- cp -f $(CURRENT_DIR)/$(PKG_NAME_ANDROID_TOOLS)/$(PKG_BIN)/adbd $(PKG_INSTALL_BIN_DIR)/ ; \
+ cp -f $(CURRENT_DIR)/$(PKG_NAME_ANDROID_TOOLS)/$(PKG_BIN)/adbd $(PKG_INSTALL_BIN_DIR)/ || exit 1; \
+ echo $(ADBD_INPUTS) > $(ADBD_STAMP) || exit 1; \
popd; )
$(SYSDRV_CROSS)-strip -s $(PKG_INSTALL_BIN_DIR)/adbd ;
@mkdir -p $(PKG_BIN)/etc/init.d;
+100
View File
@@ -0,0 +1,100 @@
#!/bin/sh
# adbd-no-tcp-cases.sh BASE_DIR PATCH_FILE
#
# Runs test-adbd-no-tcp.sh on the real patch (must PASS), on the unpatched base
# (must FAIL), and on three mutants of the patch. Each mutant must FAIL, and its
# FAIL line must name the reason given here:
# gate-makefile-only ADBD_INPUTS hashes only the Makefile; the patch set and
# the gate script are dropped (bfe-core1106-sdk#46)
# no-fail-fast the rule ignores failed series, patch and copy steps,
# so a failed 0017 hunk still stamps adbd (bfe-core1106-sdk#45)
# copy-unchecked only the copy into out/usr/bin is unchecked, so a failed
# copy still writes the stamp (bfe-core1106-sdk#45)
# Usage and layout: see test-adbd-no-tcp.sh.
# Exit 0 when every case behaves as expected, 1 otherwise, 2 on usage.
set -u
LC_ALL=C
export LC_ALL
if [ $# -ne 2 ]; then
echo "usage: $0 BASE_DIR PATCH_FILE" >&2
exit 2
fi
HERE=$(cd "$(dirname "$0")" && pwd) || exit 2
TEST=$HERE/test-adbd-no-tcp.sh
BASE=$(cd "$1" && pwd) || exit 2
PATCH=$(cd "$(dirname "$2")" && pwd)/$(basename "$2") || exit 2
WORK=$(mktemp -d "${TMPDIR:-/tmp}/adbd-no-tcp-cases.XXXXXX") || exit 2
trap 'rm -rf "$WORK"' EXIT
fail=0
pass() { echo "PASS $1"; }
bad() { echo "FAIL $1"; fail=1; }
# mutant NAME: writes $WORK/NAME.patch from PATCH with the sed script
# $WORK/NAME.sed. Fails when the script changes nothing.
mutant() {
sed -f "$WORK/$1.sed" "$PATCH" > "$WORK/$1.patch" || return 1
if cmp -s "$PATCH" "$WORK/$1.patch"; then return 1; fi
return 0
}
# expect WANT LABEL PATCH [REASON]: runs the test on PATCH. The exit status must
# be WANT. For a FAIL case, REASON must appear in one of the FAIL lines.
expect() {
log=$WORK/run-$(echo "$2" | tr -c 'a-zA-Z0-9' '_').log
sh "$TEST" "$BASE" "$3" > "$log" 2>&1
rc=$?
if [ "$rc" != "$1" ]; then
bad "$2 (exit $rc, want $1)"
return
fi
if [ -n "${4:-}" ] && ! grep -q "^FAIL.*$4" "$log"; then
bad "$2 (exit $rc, no FAIL line names: $4)"
return
fi
pass "$2 (exit $rc)"
}
# The mutant scripts. Each edits only the Makefile hunk of the patch, or the
# gate line that carries ADBD_INPUTS.
cat > "$WORK/gate-makefile-only.sed" <<'SEDEOF'
s#^+ADBD_INPUTS := .*$#+ADBD_INPUTS := $(shell sha256sum $(CURRENT_DIR)/Makefile | cut -c1-64)#
SEDEOF
cat > "$WORK/no-fail-fast.sed" <<'SEDEOF'
/^diff --git a\/sysdrv\/tools\/board\/android-tools\/Makefile /,/^diff --git a\/sysdrv\/tools\/board\/android-tools\/adbd-current.sh /{
/^+/{
s/ || exit 1//
s/\$(SHELL) -e /$(SHELL) /
}
}
SEDEOF
cat > "$WORK/copy-unchecked.sed" <<'SEDEOF'
/^diff --git a\/sysdrv\/tools\/board\/android-tools\/Makefile /,/^diff --git a\/sysdrv\/tools\/board\/android-tools\/adbd-current.sh /{
/^+.*cp -f /s/ || exit 1//
}
SEDEOF
expect 0 "real patch" "$PATCH"
expect 1 "unpatched base" none
if mutant gate-makefile-only; then
expect 1 "mutant gate-makefile-only" "$WORK/gate-makefile-only.patch" "ADBD_INPUTS is"
else
bad "mutant gate-makefile-only does not change the patch"
fi
if mutant no-fail-fast; then
expect 1 "mutant no-fail-fast" "$WORK/no-fail-fast.patch" "stops before compile"
else
bad "mutant no-fail-fast does not change the patch"
fi
if mutant copy-unchecked; then
expect 1 "mutant copy-unchecked" "$WORK/copy-unchecked.patch" "copy into out/usr/bin"
else
bad "mutant copy-unchecked does not change the patch"
fi
if [ "$fail" = 0 ]; then
echo "RESULT PASS"
exit 0
fi
echo "RESULT FAIL"
exit 1
+165 -50
View File
@@ -2,8 +2,10 @@
# test-adbd-no-tcp.sh BASE_DIR PATCH_FILE|none
#
# Regression test for flare-edge#3129 (adbd listened on TCP 5555 and on
# 127.0.0.1:5037) and bfe-core1106-sdk#44 (a change to the adbd patch set never
# reached the image, because the Makefile kept an adbd built from older inputs).
# 127.0.0.1:5037), bfe-core1106-sdk#44 (a change to the adbd patch set never
# reached the image), bfe-core1106-sdk#45 (a failed patch or copy step still
# stamped adbd current) and bfe-core1106-sdk#46 (the gate was tested by a copy
# of its formula instead of by the Makefile).
#
# BASE_DIR holds sysdrv/tools/board/android-tools at the luckfox base commit
# 824b817f8, as in the vendor checkout:
@@ -11,9 +13,11 @@
# PATCH_FILE is luckfox-sdk-patches/board/patches/0015-adbd-no-tcp-listener.patch,
# or "none" to check the unpatched base, which must FAIL.
#
# The test replays what the android-tools Makefile does when it builds adbd:
# the orig tarball, the debian series and android-tools.patch.sh. Then it checks
# the device half of adb_main() and the rebuild gate. It compiles nothing.
# The android-tools rule of the Makefile runs for real under make, with stub
# toolchains, so nothing is compiled: the compiler stub only creates its -o
# file. The fail-closed cases each break one step and check that the rule stops
# before the stamp is written. tests/adbd-no-tcp-cases.sh runs this test on the
# real patch, on the base and on mutants of the patch.
# Exit 0 PASS, 1 FAIL, 2 usage or missing input.
set -u
LC_ALL=C
@@ -33,6 +37,7 @@ if [ ! -d "$BASE/sysdrv/tools/board/android-tools" ]; then
echo "no sysdrv/tools/board/android-tools under $BASE" >&2
exit 2
fi
BASE=$(cd "$BASE" && pwd) || exit 2
if [ "$PATCH" != none ]; then
[ -f "$PATCH" ] || { echo "no patch file $PATCH" >&2; exit 2; }
PATCH=$(cd "$(dirname "$PATCH")" && pwd)/$(basename "$PATCH")
@@ -55,30 +60,64 @@ if [ "$PATCH" != none ]; then
fi
fi
# 2. Regenerate the adbd source the way the Makefile does. Every step is strict
# here; the Makefile itself ignores patch failures.
cd "$AT" || exit 2
tar -xf android-tools_4.2.2+git20130218.orig.tar.xz || { bad "orig tarball extraction"; echo "RESULT FAIL"; exit 1; }
tar -xf android-tools_4.2.2+git20130218-3ubuntu41.debian.tar.gz -C android-tools || { bad "debian tarball extraction"; echo "RESULT FAIL"; exit 1; }
mkdir -p android-tools/out
cp -af android-tools-patches/* android-tools/ || exit 2
cd android-tools || exit 2
series_ok=1
for item in $(cat ./debian/patches/series); do
patch -p1 -s < "./debian/patches/$item" >/dev/null 2>&1 || { bad "debian series $item"; series_ok=0; }
# Stub toolchain for the rule: the compiler (also CXX and CPP), strip, and the
# openssl and zlib sub-makes. The compiler stub logs each run to $STUB_LOG,
# creates its -o output, and fails when STUB_CC_FAIL is set.
STUB=$WORK/stub
mkdir -p "$STUB/dep" || exit 2
cat > "$STUB/cross-gcc" <<'STUBEOF'
#!/bin/sh
[ -n "${STUB_LOG:-}" ] && echo "cc $*" >> "$STUB_LOG"
[ -n "${STUB_CC_FAIL:-}" ] && { echo "stub compiler: forced failure" >&2; exit 1; }
out=
while [ $# -gt 0 ]; do
if [ "$1" = -o ]; then out=$2; shift; fi
shift
done
[ "$series_ok" = 1 ] && pass "debian series applies to the orig source"
sh ./android-tools.patch.sh > "$WORK/patch-sh.log" 2>&1
if grep -q -E 'FAILED|saving rejects|malformed' "$WORK/patch-sh.log"; then
bad "android-tools.patch.sh reports a failed hunk: $(grep -m1 -E 'FAILED|saving rejects|malformed' "$WORK/patch-sh.log")"
[ -n "$out" ] && : > "$out"
exit 0
STUBEOF
cp "$STUB/cross-gcc" "$STUB/cross-g++" || exit 2
cp "$STUB/cross-gcc" "$STUB/cross-cpp" || exit 2
printf '#!/bin/sh\nexit 0\n' > "$STUB/cross-strip" || exit 2
printf 'all:\n\t@true\n' > "$STUB/dep/Makefile" || exit 2
chmod 755 "$STUB/cross-gcc" "$STUB/cross-g++" "$STUB/cross-cpp" "$STUB/cross-strip" || exit 2
# run_make AT_DIR LOG: runs the rule of the Makefile in AT_DIR under make, with
# the stubs. Sets RC (make's exit status) and CC_RUNS (compiler runs).
run_make() {
rm -f "$2.cc"
(cd "$1" && STUB_LOG="$2.cc" make -f Makefile SYSDRV_PARAM=/dev/null \
SYSDRV_CROSS="$STUB/cross" SYSDRV_JOBS=1 \
PKG_DEP_OPENSSL="$STUB/dep" PKG_DEP_ZLIB="$STUB/dep" all) > "$2" 2>&1
RC=$?
CC_RUNS=0
if [ -s "$2.cc" ]; then CC_RUNS=$(wc -l < "$2.cc" | tr -d ' '); fi
}
# case_at NAME: a fresh copy of the patched android-tools tree; prints its path.
case_at() {
rm -rf "$WORK/case-$1"
mkdir -p "$WORK/case-$1/sysdrv/tools/board" || return 1
cp -a "$AT" "$WORK/case-$1/sysdrv/tools/board/" || return 1
echo "$WORK/case-$1/sysdrv/tools/board/android-tools"
}
# 2. The rule applies every debian series entry and every android-tools.patch.sh
# step, builds adbd, and writes the stamp.
GOOD=$(case_at good) || exit 2
run_make "$GOOD" "$WORK/good.log"
if [ "$RC" = 0 ] && [ "$CC_RUNS" -gt 0 ]; then
pass "rule applies the debian series and android-tools.patch.sh, then builds adbd"
else
pass "android-tools.patch.sh applies every patch"
bad "rule does not build adbd from the patch set (rc $RC, compiler runs $CC_RUNS): $(grep -m1 -E 'FAILED|No such|Error' "$WORK/good.log")"
fi
# 3. The device half of adb_main(): the TCP listeners must be gone, and the USB
# transport must stay.
# 3. The device half of adb_main(), in the source the rule generated: the TCP
# listeners must be gone, and the USB transport must stay.
# Comments are stripped first: the source keeps commented-out calls, and a
# comment that names a call is not a call.
ADB=$GOOD/android-tools/core/adbd/adb.c
awk '
/^int adb_main\(/ { inmain = 1 }
inmain && /^}/ { exit }
@@ -91,7 +130,7 @@ inmain {
if (host && line ~ /^#else/) { host = 0; dev = 1; next }
if (dev && line ~ /^#endif/) { dev = 0; next }
if (dev) print line
}' core/adbd/adb.c > "$WORK/device-main.txt"
}' "$ADB" > "$WORK/device-main.txt" 2>/dev/null
if [ ! -s "$WORK/device-main.txt" ]; then
bad "could not extract the device half of adb_main()"
else
@@ -114,36 +153,112 @@ else
done
fi
# 4. The rebuild gate: adbd is current only when its stamp matches its inputs.
cd "$AT" || exit 2
if [ -f ./adbd-current.sh ] && grep -q 'sh $(CURRENT_DIR)/adbd-current.sh $(PKG_INSTALL_BIN_DIR)/adbd $(ADBD_STAMP) $(ADBD_INPUTS)' Makefile \
&& grep -q 'echo $(ADBD_INPUTS) > $(ADBD_STAMP)' Makefile; then
pass "Makefile gates adbd on the stamp and writes it after the build"
G=$WORK/gate
mkdir -p "$G/out/usr/bin"
inputs=$(cat Makefile adbd-current.sh android-tools-patches/* | sha256sum | cut -d' ' -f1)
stamp=$G/out/.adbd-inputs
adbd=$G/out/usr/bin/adbd
gate() { sh ./adbd-current.sh "$adbd" "$stamp" "$inputs"; }
expect() { # expect RC LABEL
gate >/dev/null 2>&1; rc=$?
if [ "$rc" = "$1" ]; then pass "gate: $2 (exit $rc)"; else bad "gate: $2 (exit $rc, want $1)"; fi
}
expect 1 "no adbd, so rebuild"
: > "$adbd"
expect 1 "adbd without a stamp, so rebuild"
echo "0000000000000000000000000000000000000000000000000000000000000000" > "$stamp"
expect 1 "adbd with a stale stamp, so rebuild"
echo "$inputs" > "$stamp"
expect 0 "adbd with a matching stamp, so skip"
# 4. The gate, as the Makefile evaluates it: ADBD_INPUTS must be the sha256 of
# the Makefile, adbd-current.sh and the patch set, the three inputs that the
# stamp must match.
# shellcheck disable=SC2016 # the make text must reach make unexpanded
printf '%s\n' '$(info ADBD_INPUTS=$(ADBD_INPUTS))' > "$WORK/probe.mk" || exit 2
probe=$(cd "$GOOD" && make -s -f Makefile -f "$WORK/probe.mk" SYSDRV_PARAM=/dev/null no-such-target 2>/dev/null | sed -n 's/^ADBD_INPUTS=//p')
want=$(cd "$AT" && cat Makefile adbd-current.sh android-tools-patches/* 2>/dev/null | sha256sum | cut -d' ' -f1)
if [ -n "$probe" ] && [ "$probe" = "$want" ]; then
pass "ADBD_INPUTS is the sha256 of Makefile, adbd-current.sh and the patch set"
else
bad "Makefile does not gate adbd on adbd-current.sh and the stamp"
bad "ADBD_INPUTS is '$probe', want '$want' (sha256 of Makefile, adbd-current.sh and the patch set)"
fi
# 5. The Makefile still parses (a parse error prints something other than
# 5. The rule itself: a matching stamp with adbd present skips the build, and a
# stale or missing stamp rebuilds it. The stamp must hold ADBD_INPUTS.
if [ -n "$probe" ] && [ "$(cat "$GOOD/out/.adbd-inputs" 2>/dev/null)" = "$probe" ]; then
pass "rule writes the stamp of its inputs after the build"
else
bad "rule did not write the stamp of its inputs after the build"
fi
run_make "$GOOD" "$WORK/skip.log"
if [ "$RC" = 0 ] && [ "$CC_RUNS" = 0 ] && [ -n "$probe" ] && [ "$(cat "$GOOD/out/.adbd-inputs" 2>/dev/null)" = "$probe" ]; then
pass "rule skips adbd when the stamp matches"
else
bad "rule did not skip adbd with a matching stamp (rc $RC, compiler runs $CC_RUNS)"
fi
echo "0000000000000000000000000000000000000000000000000000000000000000" > "$GOOD/out/.adbd-inputs" || exit 2
run_make "$GOOD" "$WORK/stale.log"
if [ "$RC" = 0 ] && [ "$CC_RUNS" -gt 0 ]; then
pass "rule rebuilds adbd when the stamp is stale"
else
bad "rule did not rebuild adbd with a stale stamp (rc $RC, compiler runs $CC_RUNS)"
fi
rm -f "$GOOD/out/.adbd-inputs"
run_make "$GOOD" "$WORK/nostamp.log"
if [ "$RC" = 0 ] && [ "$CC_RUNS" -gt 0 ]; then
pass "rule rebuilds adbd when there is no stamp"
else
bad "rule did not rebuild adbd without a stamp (rc $RC, compiler runs $CC_RUNS)"
fi
# 6. Fail closed. An injected failure must stop the rule with a non-zero status
# and leave no stamp. The failures before the compile step must also stop the
# rule before the compiler runs.
check_closed() { # AT_DIR LOG PRE LABEL
run_make "$1" "$2"
stamp=absent
[ -e "$1/out/.adbd-inputs" ] && stamp=written
if [ "$RC" != 0 ] && [ "$stamp" = absent ] && { [ "$3" != pre ] || [ "$CC_RUNS" = 0 ]; }; then
pass "$4"
else
bad "$4 (rc $RC, stamp $stamp, compiler runs $CC_RUNS): $(grep -m1 -E 'FAILED|No such|Error|forced|cannot|Is a directory' "$2")"
fi
}
inject_drift() { # AT_DIR: one removed line of the 0017 hunk stops matching
f=$1/android-tools-patches/0017-no-adb-tcp-listener.patch
[ -f "$f" ] || return 1
awk '{ if ($0 == "- build_local_name(local_name, sizeof(local_name), server_port);") $0 = $0 " /* drift */"; print }' "$f" > "$f.new" || return 1
grep -q 'drift' "$f.new" || return 1
mv "$f.new" "$f"
}
inject_middle() { # AT_DIR: a failing patch step ahead of the last step
f=$1/android-tools-patches/android-tools.patch.sh
[ -f "$f" ] || return 1
awk 'NR == 4 { print "patch -p1 < 0000-no-such-patch.patch" } { print }' "$f" > "$f.new" || return 1
mv "$f.new" "$f"
}
inject_series() { # AT_DIR: a debian series entry with no patch file behind it
t=$1/android-tools_4.2.2+git20130218-3ubuntu41.debian.tar.gz
d=$WORK/deb-series
rm -rf "$d" && mkdir -p "$d" || return 1
tar -xzf "$t" -C "$d" || return 1
printf '\nno-such-debian-patch.patch\n' >> "$d/debian/patches/series" || return 1
tar -czf "$t.new" -C "$d" debian || return 1
mv "$t.new" "$t"
}
D=$(case_at drift) || exit 2
if inject_drift "$D"; then
check_closed "$D" "$WORK/drift.log" pre "rule stops before compile when a 0017 hunk does not apply"
else
bad "could not inject a 0017 failure (no 0017 patch in the tree)"
fi
D=$(case_at middle) || exit 2
if inject_middle "$D"; then
check_closed "$D" "$WORK/middle.log" pre "rule stops before compile when a middle android-tools.patch.sh step fails"
else
bad "could not inject a failing android-tools.patch.sh step"
fi
D=$(case_at series) || exit 2
if inject_series "$D"; then
check_closed "$D" "$WORK/series.log" pre "rule stops before compile when a debian series entry does not apply"
else
bad "could not inject a failing debian series entry"
fi
D=$(case_at compile) || exit 2
export STUB_CC_FAIL=1
check_closed "$D" "$WORK/compile.log" any "rule stops and writes no stamp when the compiler fails"
unset STUB_CC_FAIL
D=$(case_at copy) || exit 2
mkdir -p "$D/out/usr/bin/adbd" || exit 2
check_closed "$D" "$WORK/copy.log" any "rule stops and writes no stamp when the copy into out/usr/bin fails"
# 7. The Makefile still parses (a parse error prints something other than
# "No rule to make target").
cd "$AT" || exit 2
if make -f Makefile SYSDRV_PARAM=/dev/null -n no-such-target 2>&1 | grep -q 'No rule to make target'; then
if (cd "$AT" && make -f Makefile SYSDRV_PARAM=/dev/null -n no-such-target 2>&1 | grep -q 'No rule to make target'); then
pass "Makefile parses"
else
bad "Makefile does not parse"