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:
committed by
Claude Haiku 5.5
co-authored by
Claude Haiku 5.5
parent
aa01bca930
commit
6f8903c1df
@@ -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
@@ -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
|
||||
@@ -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"
|
||||
|
||||
Reference in New Issue
Block a user