scottk/OpenCellular
1
0
Fork 0
mirror of https://github.com/Telecominfraproject/OpenCellular.git synced 2026-01-11 02:15:14 +00:00
Code Issues Packages Projects Releases Wiki Activity

Rename $GPT as $CGPT, just for clarity.

Browse Source 
I'm about to add a new test to fix some borkage with cgpt. First step is to
clean up the script a little bit.

BUG=none (yet)
BRANCH=all
TEST=manual

make && make runtests

Change-Id: I2311b5eb20aff80c4a0435cf1d10331c679af3c0
Signed-off-by: Bill Richardson <wfrichar@chromium.org>
Reviewed-on: https://gerrit.chromium.org/gerrit/31379
Reviewed-by: Randall Spangler <rspangler@chromium.org>
This commit is contained in:
Bill Richardson
2012-08-24 14:39:21 -07:00
committed by Gerrit
parent 2e70c1226a
commit 263ffdfdd7
1 changed files with 63 additions and 63 deletions
Download Patch File Download Diff File Expand all files Collapse all files

126
tests/run_cgpt_tests.sh
View File

@@ -4,18 +4,18 @@
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
#
# Run tests for CGPT.
# Run tests for cgpt utility.
# Load common constants and variables.
. "$(dirname "$0")/common.sh"
GPT=$(readlink -f "$1")
[ -x "$GPT" ] || error "Can't execute $GPT"
CGPT=$(readlink -f "$1")
[ -x "$CGPT" ] || error "Can't execute $CGPT"
# Run tests in a dedicated directory for easy cleanup or debugging.
DIR="${TEST_DIR}/cgpt_test_dir"
[ -d "$DIR" ] || mkdir -p "$DIR"
warning "testing $GPT in $DIR"
warning "testing $CGPT in $DIR"
cd "$DIR"
echo "Create an empty file to use as the device..."
@@ -62,55 +62,55 @@ RANDOM_LABEL="random stuff"
RANDOM_GUID='2364a860-bf63-42fb-a83d-9ad3e057fcf5'
RANDOM_NUM=6
$GPT create ${DEV}
$CGPT create ${DEV}
$GPT add -b ${DATA_START} -s ${DATA_SIZE} -t ${DATA_GUID} \
$CGPT add -b ${DATA_START} -s ${DATA_SIZE} -t ${DATA_GUID} \
-l "${DATA_LABEL}" ${DEV}
$GPT add -b ${KERN_START} -s ${KERN_SIZE} -t ${KERN_GUID} \
$CGPT add -b ${KERN_START} -s ${KERN_SIZE} -t ${KERN_GUID} \
-l "${KERN_LABEL}" ${DEV}
$GPT add -b ${ROOTFS_START} -s ${ROOTFS_SIZE} -t ${ROOTFS_GUID} \
$CGPT add -b ${ROOTFS_START} -s ${ROOTFS_SIZE} -t ${ROOTFS_GUID} \
-l "${ROOTFS_LABEL}" ${DEV}
$GPT add -b ${ESP_START} -s ${ESP_SIZE} -t ${ESP_GUID} \
$CGPT add -b ${ESP_START} -s ${ESP_SIZE} -t ${ESP_GUID} \
-l "${ESP_LABEL}" ${DEV}
$GPT add -b ${FUTURE_START} -s ${FUTURE_SIZE} -t ${FUTURE_GUID} \
$CGPT add -b ${FUTURE_START} -s ${FUTURE_SIZE} -t ${FUTURE_GUID} \
-l "${FUTURE_LABEL}" ${DEV}
$GPT add -b ${RANDOM_START} -s ${RANDOM_SIZE} -t ${RANDOM_GUID} \
$CGPT add -b ${RANDOM_START} -s ${RANDOM_SIZE} -t ${RANDOM_GUID} \
-l "${RANDOM_LABEL}" ${DEV}
echo "Extract the start and size of given partitions..."
X=$($GPT show -b -i $DATA_NUM ${DEV})
Y=$($GPT show -s -i $DATA_NUM ${DEV})
X=$($CGPT show -b -i $DATA_NUM ${DEV})
Y=$($CGPT show -s -i $DATA_NUM ${DEV})
[ "$X $Y" = "$DATA_START $DATA_SIZE" ] || error
X=$($GPT show -b -i $KERN_NUM ${DEV})
Y=$($GPT show -s -i $KERN_NUM ${DEV})
X=$($CGPT show -b -i $KERN_NUM ${DEV})
Y=$($CGPT show -s -i $KERN_NUM ${DEV})
[ "$X $Y" = "$KERN_START $KERN_SIZE" ] || error
X=$($GPT show -b -i $ROOTFS_NUM ${DEV})
Y=$($GPT show -s -i $ROOTFS_NUM ${DEV})
X=$($CGPT show -b -i $ROOTFS_NUM ${DEV})
Y=$($CGPT show -s -i $ROOTFS_NUM ${DEV})
[ "$X $Y" = "$ROOTFS_START $ROOTFS_SIZE" ] || error
X=$($GPT show -b -i $ESP_NUM ${DEV})
Y=$($GPT show -s -i $ESP_NUM ${DEV})
X=$($CGPT show -b -i $ESP_NUM ${DEV})
Y=$($CGPT show -s -i $ESP_NUM ${DEV})
[ "$X $Y" = "$ESP_START $ESP_SIZE" ] || error
X=$($GPT show -b -i $FUTURE_NUM ${DEV})
Y=$($GPT show -s -i $FUTURE_NUM ${DEV})
X=$($CGPT show -b -i $FUTURE_NUM ${DEV})
Y=$($CGPT show -s -i $FUTURE_NUM ${DEV})
[ "$X $Y" = "$FUTURE_START $FUTURE_SIZE" ] || error
X=$($GPT show -b -i $RANDOM_NUM ${DEV})
Y=$($GPT show -s -i $RANDOM_NUM ${DEV})
X=$($CGPT show -b -i $RANDOM_NUM ${DEV})
Y=$($CGPT show -s -i $RANDOM_NUM ${DEV})
[ "$X $Y" = "$RANDOM_START $RANDOM_SIZE" ] || error
echo "Set the boot partition.."
$GPT boot -i ${KERN_NUM} ${DEV} >/dev/null
$CGPT boot -i ${KERN_NUM} ${DEV} >/dev/null
echo "Check the PMBR's idea of the boot partition..."
X=$($GPT boot ${DEV})
Y=$($GPT show -u -i $KERN_NUM $DEV)
X=$($CGPT boot ${DEV})
Y=$($CGPT show -u -i $KERN_NUM $DEV)
[ "$X" = "$Y" ] || error
@@ -120,18 +120,18 @@ echo "Test the cgpt prioritize command..."
# Output: ${DEV} has kernel partitions with the given priorities
make_pri() {
local idx=0
$GPT create ${DEV}
$CGPT create ${DEV}
for pri in "$@"; do
idx=$((idx+1))
$GPT add -t kernel -l "kern$idx" -b $((100 + 2 * $idx)) -s 1 -P $pri ${DEV}
$CGPT add -t kernel -l "kern$idx" -b $((100 + 2 * $idx)) -s 1 -P $pri ${DEV}
done
}
# Output: returns string containing priorities of all kernels
get_pri() {
echo $(
for idx in $($GPT find -t kernel ${DEV} | sed -e s@${DEV}@@); do
$GPT show -i $idx -P ${DEV}
for idx in $($CGPT find -t kernel ${DEV} | sed -e s@${DEV}@@); do
$CGPT show -i $idx -P ${DEV}
done
)
}
@@ -147,90 +147,90 @@ assert_pri() {
# no kernels at all. This should do nothing.
$GPT create ${DEV}
$GPT add -t rootfs -b 100 -s 1 ${DEV}
$GPT prioritize ${DEV}
$CGPT create ${DEV}
$CGPT add -t rootfs -b 100 -s 1 ${DEV}
$CGPT prioritize ${DEV}
assert_pri ""
# common install/upgrade sequence
make_pri 2 0 0
$GPT prioritize -i 1 ${DEV}
$CGPT prioritize -i 1 ${DEV}
assert_pri 1 0 0
$GPT prioritize -i 2 ${DEV}
$CGPT prioritize -i 2 ${DEV}
assert_pri 1 2 0
$GPT prioritize -i 1 ${DEV}
$CGPT prioritize -i 1 ${DEV}
assert_pri 2 1 0
$GPT prioritize -i 2 ${DEV}
$CGPT prioritize -i 2 ${DEV}
assert_pri 1 2 0
# lots of kernels, all same starting priority, should go to priority 1
make_pri 8 8 8 8 8 8 8 8 8 8 8 0 0 8
$GPT prioritize ${DEV}
$CGPT prioritize ${DEV}
assert_pri 1 1 1 1 1 1 1 1 1 1 1 0 0 1
# now raise them all up again
$GPT prioritize -P 4 ${DEV}
$CGPT prioritize -P 4 ${DEV}
assert_pri 4 4 4 4 4 4 4 4 4 4 4 0 0 4
# set one of them higher, should leave the rest alone
$GPT prioritize -P 5 -i 3 ${DEV}
$CGPT prioritize -P 5 -i 3 ${DEV}
assert_pri 4 4 5 4 4 4 4 4 4 4 4 0 0 4
# set one of them lower, should bring the rest down
$GPT prioritize -P 3 -i 4 ${DEV}
$CGPT prioritize -P 3 -i 4 ${DEV}
assert_pri 1 1 2 3 1 1 1 1 1 1 1 0 0 1
# raise a group by including the friends of one partition
$GPT prioritize -P 6 -i 1 -f ${DEV}
$CGPT prioritize -P 6 -i 1 -f ${DEV}
assert_pri 6 6 4 5 6 6 6 6 6 6 6 0 0 6
# resurrect one, should not affect the others
make_pri 0 0 0 0 0 0 0 0 0 0 0 0 0 0
$GPT prioritize -i 2 ${DEV}
$CGPT prioritize -i 2 ${DEV}
assert_pri 0 1 0 0 0 0 0 0 0 0 0 0 0 0
# resurrect one and all its friends
make_pri 0 0 0 0 0 0 0 0 1 2 0 0 0 0
$GPT prioritize -P 5 -i 2 -f ${DEV}
$CGPT prioritize -P 5 -i 2 -f ${DEV}
assert_pri 5 5 5 5 5 5 5 5 3 4 5 5 5 5
# no options should maintain the same order
$GPT prioritize ${DEV}
$CGPT prioritize ${DEV}
assert_pri 3 3 3 3 3 3 3 3 1 2 3 3 3 3
# squish all the ranks
make_pri 1 1 2 2 3 3 4 4 5 5 0 6 7 7
$GPT prioritize -P 6 ${DEV}
$CGPT prioritize -P 6 ${DEV}
assert_pri 1 1 1 1 2 2 3 3 4 4 0 5 6 6
# squish the ranks by not leaving room
make_pri 1 1 2 2 3 3 4 4 5 5 0 6 7 7
$GPT prioritize -P 7 -i 3 ${DEV}
$CGPT prioritize -P 7 -i 3 ${DEV}
assert_pri 1 1 7 1 2 2 3 3 4 4 0 5 6 6
# squish the ranks while bringing the friends along
make_pri 1 1 2 2 3 3 4 4 5 5 0 6 7 7
$GPT prioritize -P 6 -i 3 -f ${DEV}
$CGPT prioritize -P 6 -i 3 -f ${DEV}
assert_pri 1 1 6 6 1 1 2 2 3 3 0 4 5 5
# squish them pretty hard
make_pri 1 1 2 2 3 3 4 4 5 5 0 6 7 7
$GPT prioritize -P 2 ${DEV}
$CGPT prioritize -P 2 ${DEV}
assert_pri 1 1 1 1 1 1 1 1 1 1 0 1 2 2
# squish them really really hard (nobody gets reduced to zero, though)
make_pri 1 1 2 2 3 3 4 4 5 5 0 6 7 7
$GPT prioritize -P 1 -i 3 ${DEV}
$CGPT prioritize -P 1 -i 3 ${DEV}
assert_pri 1 1 1 1 1 1 1 1 1 1 0 1 1 1
# squish if we try to go too high
make_pri 15 15 14 14 13 13 12 12 11 11 10 10 9 9 8 8 7 7 6 6 5 5 4 4 3 3 2 2 1 1 0
$GPT prioritize -i 3 ${DEV}
$CGPT prioritize -i 3 ${DEV}
assert_pri 14 14 15 13 12 12 11 11 10 10 9 9 8 8 7 7 6 6 5 5 4 4 3 3 2 2 1 1 1 1 0
$GPT prioritize -i 5 ${DEV}
$CGPT prioritize -i 5 ${DEV}
assert_pri 13 13 14 12 15 11 10 10 9 9 8 8 7 7 6 6 5 5 4 4 3 3 2 2 1 1 1 1 1 1 0
# but if I bring friends I don't have to squish
$GPT prioritize -i 1 -f ${DEV}
$CGPT prioritize -i 1 -f ${DEV}
assert_pri 15 15 13 12 14 11 10 10 9 9 8 8 7 7 6 6 5 5 4 4 3 3 2 2 1 1 1 1 1 1 0
@@ -239,21 +239,21 @@ echo "Test read vs read-write access..."
chmod 0444 ${DEV}
# These should fail
$GPT create -z ${DEV} 2>/dev/null && error
$GPT add -i 2 -P 3 ${DEV} 2>/dev/null && error
$GPT repair ${DEV} 2>/dev/null && error
$GPT prioritize -i 3 ${DEV} 2>/dev/null && error
$CGPT create -z ${DEV} 2>/dev/null && error
$CGPT add -i 2 -P 3 ${DEV} 2>/dev/null && error
$CGPT repair ${DEV} 2>/dev/null && error
$CGPT prioritize -i 3 ${DEV} 2>/dev/null && error
# Most 'boot' usage should fail too.
$GPT boot -p ${DEV} 2>/dev/null && error
$CGPT boot -p ${DEV} 2>/dev/null && error
dd if=/dev/zero of=fake_mbr.bin bs=100 count=1 2>/dev/null
$GPT boot -b fake_mbr.bin ${DEV} 2>/dev/null && error
$GPT boot -i 2 ${DEV} 2>/dev/null && error
$CGPT boot -b fake_mbr.bin ${DEV} 2>/dev/null && error
$CGPT boot -i 2 ${DEV} 2>/dev/null && error
# These should pass
$GPT boot ${DEV} >/dev/null
$GPT show ${DEV} >/dev/null
$GPT find -t kernel ${DEV} >/dev/null
$CGPT boot ${DEV} >/dev/null
$CGPT show ${DEV} >/dev/null
$CGPT find -t kernel ${DEV} >/dev/null
echo "Done."