[thirdparty/util-linux.git] / tests / functions.sh

#
# Copyright (C) 2007 Karel Zak <kzak@redhat.com>
#
# This file is part of util-linux.
#
# This file is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This file is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#


function ts_abspath {
	cd $1
	pwd
}

function ts_canonicalize {
	P="$1"
	C=$(readlink -f $P)

	if [ -n "$C" ]; then
		echo "$C"
	else
		echo "$P"
	fi
}

function ts_report {
	if [ "$TS_PARALLEL" == "yes" ]; then
		echo "$TS_TITLE $1"
	else
		echo "$1"
	fi
}

function ts_check_test_command {
	if [ ! -x "$1" ]; then
		ts_skip "${1##*/} not found"
	fi
}

function ts_skip_subtest {
	ts_report " IGNORE ($1)"
}

function ts_skip {
	ts_skip_subtest "$1"
	if [ -n "$2" -a -b "$2" ]; then
		ts_device_deinit "$2"
	fi
	exit 0
}

function ts_skip_nonroot {
	if [ $UID -ne 0 ]; then
		ts_skip "not root permissions"
	fi
}

function ts_failed_subtest {
	if [ x"$1" == x"" ]; then
		ts_report " FAILED ($TS_NS)"
	else
		ts_report " FAILED ($1)"
	fi
}

function ts_failed {
	ts_failed_subtest "$1"
	exit 1
}

function ts_ok_subtest {
	if [ x"$1" == x"" ]; then
		ts_report " OK"
	else
		ts_report " OK ($1)"
	fi
}

function ts_ok {
	ts_ok_subtest "$1"
	exit 0
}

function ts_log {
	echo "$1" >> $TS_OUTPUT
	[ "$TS_VERBOSE" == "yes" ] && echo "$1"
}

function ts_has_option {
	NAME="$1"
	ALL="$2"
	echo -n $ALL | sed 's/ //g' | awk 'BEGIN { FS="="; RS="--" } /('$NAME'$|'$NAME'=)/ { print "yes" }'
}

function ts_option_argument {
	NAME="$1"
	ALL="$2"
	echo -n $ALL | sed 's/ //g' | awk 'BEGIN { FS="="; RS="--" } /'$NAME'=/ { print $2 }'
}

function ts_init_core_env {
	TS_NS="$TS_COMPONENT/$TS_TESTNAME"
	TS_OUTPUT="$TS_OUTDIR/$TS_TESTNAME"
	TS_VGDUMP="$TS_OUTDIR/$TS_TESTNAME.vgdump"
	TS_DIFF="$TS_DIFFDIR/$TS_TESTNAME"
	TS_EXPECTED="$TS_TOPDIR/expected/$TS_NS"
	TS_MOUNTPOINT="$TS_OUTDIR/${TS_TESTNAME}-mnt"
}

function ts_init_core_subtest_env {
	TS_NS="$TS_COMPONENT/$TS_TESTNAME-$TS_SUBNAME"
	TS_OUTPUT="$TS_OUTDIR/$TS_TESTNAME-$TS_SUBNAME"
	TS_VGDUMP="$TS_OUTDIR/$TS_TESTNAME-$TS_SUBNAME.vgdump"
	TS_DIFF="$TS_DIFFDIR/$TS_TESTNAME-$TS_SUBNAME"
	TS_EXPECTED="$TS_TOPDIR/expected/$TS_NS"
	TS_MOUNTPOINT="$TS_OUTDIR/${TS_TESTNAME}-${TS_SUBNAME}-mnt"

	rm -f $TS_OUTPUT $TS_VGDUMP
	[ -d "$TS_OUTDIR" ]  || mkdir -p "$TS_OUTDIR"

	touch $TS_OUTPUT
	[ -n "$TS_VALGRIND_CMD" ] && touch $TS_VGDUMP
}

function ts_init_env {
	local mydir=$(ts_abspath ${0%/*})
	local tmp

	LANG="POSIX"
	LANGUAGE="POSIX"
	LC_ALL="POSIX"
	CHARSET="UTF-8"

	export LANG LANGUAGE LC_ALL CHARSET

	mydir=$(ts_canonicalize "$mydir")

	# automake directories
	top_srcdir=$(ts_option_argument "srcdir" "$*")
	top_builddir=$(ts_option_argument "builddir" "$*")

	# where is this script
	TS_TOPDIR=$(ts_abspath $mydir/../../)

	# default
	if [ -z "$top_srcdir" ]; then
		top_srcdir="$TS_TOPDIR/.."
	fi
	if [ -z "$top_builddir" ]; then
		top_builddir="$TS_TOPDIR/.."
	fi

	top_srcdir=$(ts_abspath $top_srcdir)
	top_builddir=$(ts_abspath $top_builddir)

	TS_SCRIPT="$mydir/$(basename $0)"
	TS_SUBDIR=$(dirname $TS_SCRIPT)
	TS_TESTNAME=$(basename $TS_SCRIPT)
	TS_COMPONENT=$(basename $TS_SUBDIR)

	TS_NSUBTESTS=0
	TS_NSUBFAILED=0

	TS_SELF="$TS_SUBDIR"

	TS_OUTDIR="$top_builddir/tests/output/$TS_COMPONENT"
	TS_DIFFDIR="$top_builddir/tests/diff/$TS_COMPONENT"

	ts_init_core_env

	TS_VERBOSE=$(ts_has_option "verbose" "$*")
	TS_PARALLEL=$(ts_has_option "parallel" "$*")

	tmp=$( ts_has_option "memcheck" "$*")
	if [ "$tmp" == "yes" -a -f /usr/bin/valgrind ]; then
		TS_VALGRIND_CMD="/usr/bin/valgrind"
	fi

	BLKID_FILE="$TS_OUTDIR/${TS_TESTNAME}.blkidtab"

	declare -a TS_SUID_PROGS
	declare -a TS_SUID_USER
	declare -a TS_SUID_GROUP

	if [ -f $TS_TOPDIR/commands.sh ]; then
		. $TS_TOPDIR/commands.sh
	fi

	export BLKID_FILE

	rm -f $TS_OUTPUT $TS_VGDUMP
	[ -d "$TS_OUTDIR" ]  || mkdir -p "$TS_OUTDIR"

	touch $TS_OUTPUT
	[ -n "$TS_VALGRIND_CMD" ] && touch $TS_VGDUMP

	if [ "$TS_VERBOSE" == "yes" ]; then
		echo
		echo "     script: $TS_SCRIPT"
		echo "    sub dir: $TS_SUBDIR"
		echo "    top dir: $TS_TOPDIR"
		echo "       self: $TS_SELF"
		echo "  test name: $TS_TESTNAME"
		echo "  test desc: $TS_DESC"
		echo "  component: $TS_COMPONENT"
		echo "  namespace: $TS_NS"
		echo "    verbose: $TS_VERBOSE"
		echo "     output: $TS_OUTPUT"
		echo "   valgrind: $TS_VGDUMP"
		echo "   expected: $TS_EXPECTED"
		echo " mountpoint: $TS_MOUNTPOINT"
		echo
	fi
}

function ts_init_subtest {

	TS_SUBNAME="$1"

	ts_init_core_subtest_env

	[ $TS_NSUBTESTS -eq 0 ] && echo
	TS_NSUBTESTS=$(( $TS_NSUBTESTS + 1 ))

	if [ "$TS_PARALLEL" == "yes" ]; then
		TS_TITLE=$(printf "%13s: %-30s ...\n%16s: %-27s ..." "$TS_COMPONENT" "$TS_DESC" "" "$TS_SUBNAME")
	else
		TS_TITLE=$(printf "%16s: %-27s ..." "" "$TS_SUBNAME")
		echo -n "$TS_TITLE"
	fi
}

function ts_init {
	ts_init_env "$*"

	local is_fake=$( ts_has_option "fake" "$*")
	local is_force=$( ts_has_option "force" "$*")

	if [ "$TS_PARALLEL" == "yes" ]; then
		TS_TITLE=$(printf "%13s: %-30s ..." "$TS_COMPONENT" "$TS_DESC")
	else
		TS_TITLE=$(printf "%13s: %-30s ..." "$TS_COMPONENT" "$TS_DESC")
		echo -n "$TS_TITLE"
	fi

	[ "$is_fake" == "yes" ] && ts_skip "fake mode"
	[ "$TS_OPTIONAL" == "yes" -a "$is_force" != "yes" ] && ts_skip "optional"
}

function ts_init_suid {
	PROG="$1"
	ct=${#TS_SUID_PROGS[*]}

	# Save info about original setting
	TS_SUID_PROGS[$ct]=$PROG
	TS_SUID_USER[$ct]=$(stat --printf="%U" $PROG)
	TS_SUID_GROUP[$ct]=$(stat --printf="%G" $PROG)

	chown root.root $PROG &> /dev/null
	chmod u+s $PROG &> /dev/null
}

function ts_init_py {
	LIBNAME="$1"

	[ -f "$TS_TOPDIR/../py${LIBNAME}.la" ] || ts_skip "py${LIBNAME} not compiled"

	export LD_LIBRARY_PATH="$TS_TOPDIR/../.libs"
	export PYTHONPATH="$TS_TOPDIR/../$LIBNAME/python:$TS_TOPDIR/../.libs"

	export PYTHON_VERSION=$(awk '/^PYTHON_VERSION/ { print $3 }' $top_builddir/Makefile)
	export PYTHON_MAJOR_VERSION=$(echo $PYTHON_VERSION | sed 's/\..*//')

	export PYTHON="python${PYTHON_MAJOR_VERSION}"
}

function ts_valgrind {
	if [ -z "$TS_VALGRIND_CMD" ]; then
		$*
	else
		$TS_VALGRIND_CMD --tool=memcheck --leak-check=full \
				 --leak-resolution=high --num-callers=20 \
				 --log-file="$TS_VGDUMP" $*
	fi
}

function ts_gen_diff {
	local res=0

	if [ -s "$TS_OUTPUT" ]; then

		# remove libtool lt- prefixes
		sed --in-place 's/^lt\-\(.*\: \)/\1/g' $TS_OUTPUT

		[ -d "$TS_DIFFDIR" ] || mkdir -p "$TS_DIFFDIR"
		diff -u $TS_EXPECTED $TS_OUTPUT > $TS_DIFF

		if [ -s $TS_DIFF ]; then
			res=1
		else
			rm -f $TS_DIFF;
		fi
	else
		res=1
	fi
	return $res
}

function tt_gen_mem_report {
	[ -z "$TS_VALGRIND_CMD" ] && echo "$1"

	grep -q -E 'ERROR SUMMARY: [1-9]' $TS_VGDUMP &> /dev/null
	if [ $? -eq 0 ]; then
		echo "mem-error detected!"
	fi
}

function ts_finalize_subtest {
	local res=0

	if [ -s "$TS_EXPECTED" ]; then
		ts_gen_diff
		if [ $? -eq 1 ]; then
			ts_failed_subtest "$1"
			res=1
		else
			ts_ok_subtest "$(tt_gen_mem_report "$1")"
		fi
	else
		ts_skip_subtest "output undefined"
	fi

	[ $res -ne 0 ] && TS_NSUBFAILED=$(( $TS_NSUBFAILED + 1 ))

	# reset environment back to parental test
	ts_init_core_env

	return $res
}

function ts_finalize {
	for idx in $(seq 0 $((${#TS_SUID_PROGS[*]} - 1))); do
		PROG=${TS_SUID_PROGS[$idx]}
		chmod a-s $PROG &> /dev/null
		chown ${TS_SUID_USER[$idx]}.${TS_SUID_GROUP[$idx]} $PROG &> /dev/null
	done

	if [ $TS_NSUBTESTS -ne 0 ]; then
		printf "%11s..."
		if [ $TS_NSUBFAILED -ne 0 ]; then
			ts_failed "$TS_NSUBFAILED from $TS_NSUBTESTS sub-tests"
		else
			ts_ok "all $TS_NSUBTESTS sub-tests PASSED"
		fi
	fi

	if [ -s $TS_EXPECTED ]; then
		ts_gen_diff
		if [ $? -eq 1 ]; then
			ts_failed "$1"
		fi
		ts_ok "$1"
	fi

	ts_skip "output undefined"
}

function ts_die {
	ts_log "$1"
	if [ -n "$2" ] && [ -b "$2" ]; then
		ts_device_deinit "$2"
		ts_fstab_clean		# for sure...
	fi
	ts_finalize
}

function ts_image_md5sum {
	local img=${1:-"$TS_OUTDIR/${TS_TESTNAME}.img"}
	echo $(md5sum "$img" | awk '{printf $1}') $(basename "$img")
}

function ts_image_init {
	local mib=${1:-"5"}	# size in MiBs
	local img=${2:-"$TS_OUTDIR/${TS_TESTNAME}.img"}

	dd if=/dev/zero of="$img" bs=1M count=$mib &> /dev/null
	echo "$img"
	return 0
}

function ts_device_init {
	local img=$(ts_image_init $1 $2)
	local dev=$($TS_CMD_LOSETUP --show -f "$img")

	if [ -z "$dev" ]; then
		ts_device_deinit $dev
		return 1		# error
	fi

	echo $dev
	return 0			# succes
}

function ts_device_deinit {
	local DEV="$1"

	if [ -b "$DEV" ]; then
		$TS_CMD_UMOUNT "$DEV" &> /dev/null
		$TS_CMD_LOSETUP -d "$DEV" &> /dev/null
	fi
}

function ts_uuid_by_devname {
	echo $($TS_CMD_BLKID -p -s UUID -o value $1)
}

function ts_label_by_devname {
	echo $($TS_CMD_BLKID -p -s LABEL -o value $1)
}

function ts_fstype_by_devname {
	echo $($TS_CMD_BLKID -p -s TYPE -o value $1)
}

function ts_device_has {
	local TAG="$1"
	local VAL="$2"
	local DEV="$3"
	local vl=""

	case $TAG in
		"TYPE") vl=$(ts_fstype_by_devname $DEV);;
		"LABEL") vl=$(ts_label_by_devname $DEV);;
		"UUID") vl=$(ts_uuid_by_devname $DEV);;
		*) return 1;;
	esac

	if [ "$vl" == "$VAL" ]; then
		return 0
	fi
	return 1
}

function ts_device_has_uuid {
	ts_uuid_by_devname "$1" | egrep -q '^[0-9a-z]{8}-[0-9a-z]{4}-[0-9a-z]{4}-[0-9a-z]{4}-[0-9a-z]{12}$'
	return $?
}

function ts_is_mounted {
	local DEV=$(ts_canonicalize "$1")

	grep -q $DEV /proc/mounts && return 0

	if [ "${DEV#/dev/loop/}" != "$DEV" ]; then
		return grep -q "/dev/loop${DEV#/dev/loop/}" /proc/mounts
	fi
	return 1
}

function ts_fstab_open {
	echo "# <!-- util-linux test entry" >> /etc/fstab
}

function ts_fstab_close {
	echo "# -->" >> /etc/fstab
}

function ts_fstab_addline {
	local SPEC="$1"
	local MNT=${2:-"$TS_MOUNTPOINT"}
	local FS=${3:-"auto"}
	local OPT=${4:-"defaults"}

	echo "$SPEC   $MNT   $FS   $OPT   0   0" >> /etc/fstab
}

function ts_fstab_add {
	ts_fstab_open
	ts_fstab_addline $*
	ts_fstab_close
}

function ts_fstab_clean {
	sed --in-place "
/# <!-- util-linux/!b
:a
/# -->/!{
  N
  ba
}
s/# <!-- util-linux.*-->//;
/^$/d" /etc/fstab
}

function ts_fdisk_clean {
	local DEVNAME=$1

	# remove non comparable parts of fdisk output
	if [ x"${DEVNAME}" != x"" ]; then
	       sed -i -e "s:${DEVNAME}:<removed>:g" $TS_OUTPUT
	fi

	sed -i -e 's/Disk identifier:.*/Disk identifier: <removed>/g' \
	       -e 's/Created a new.*/Created a new <removed>./g' \
	       -e 's/^Device[[:blank:]]*Start/Device             Start/g' \
	       -e 's/^Device[[:blank:]]*Boot/Device     Boot/g' \
	       -e 's/^Device[[:blank:]]*Flag/Device     Flag/g' \
	       -e 's/Welcome to fdisk.*/Welcome to fdisk <removed>./g' \
	       $TS_OUTPUT
}

function ts_scsi_debug_init {

	modprobe --dry-run --quiet scsi_debug
	[ "$?" == 0 ] || ts_skip "missing scsi_debug module"

	rmmod scsi_debug &> /dev/null
	modprobe scsi_debug $*
	[ "$?" == 0 ] || ts_die "Cannot init device"

	DEVNAME=$(grep --with-filename scsi_debug /sys/block/*/device/model | awk -F '/' '{print $4}')
	[ "x${DEVNAME}" == "x" ] && ts_die "Cannot find device"

	DEVICE="/dev/${DEVNAME}"

	sleep 1
	udevadm settle

	echo $DEVICE
}
Commit	Line	Data
92f2c23e KZ	1	#
	2	# Copyright (C) 2007 Karel Zak <kzak@redhat.com>
	3	#
601d12fb	4	# This file is part of util-linux.
92f2c23e KZ	5	#
	6	# This file is free software; you can redistribute it and/or modify
	7	# it under the terms of the GNU General Public License as published by
	8	# the Free Software Foundation; either version 2 of the License, or
	9	# (at your option) any later version.
	10	#
	11	# This file is distributed in the hope that it will be useful,
	12	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	# GNU General Public License for more details.
	15	#
e83446da	16
e83446da	17
a02f320d KZ	18	function ts_abspath {
	19	cd $1
	20	pwd
	21	}
d42bbae5	22
6dfe6f0e KZ	23	function ts_canonicalize {
	24	P="$1"
	25	C=$(readlink -f $P)
	26
	27	if [ -n "$C" ]; then
	28	echo "$C"
	29	else
	30	echo "$P"
	31	fi
	32	}
	33
40e6f7a0 SK	34	function ts_report {
	35	if [ "$TS_PARALLEL" == "yes" ]; then
	36	echo "$TS_TITLE $1"
	37	else
	38	echo "$1"
	39	fi
2f791546	40	}
40e6f7a0	41
2f791546 SK	42	function ts_check_test_command {
	43	if [ ! -x "$1" ]; then
	44	ts_skip "${1##*/} not found"
	45	fi
40e6f7a0 SK	46	}
40e6f7a0 SK	47
09888efe	48	function ts_skip_subtest {
40e6f7a0	49	ts_report " IGNORE ($1)"
09888efe KZ	50	}
	51
	52	function ts_skip {
	53	ts_skip_subtest "$1"
f0b561b6	54	if [ -n "$2" -a -b "$2" ]; then
3dfa278e KZ	55	ts_device_deinit "$2"
3dfa278e KZ	56	fi
b30cd7ee KZ	57	exit 0
	58	}
	59
09892fb6	60	function ts_skip_nonroot {
f0b561b6	61	if [ $UID -ne 0 ]; then
09892fb6 KZ	62	ts_skip "not root permissions"
	63	fi
	64	}
	65
09888efe	66	function ts_failed_subtest {
05de8126	67	if [ x"$1" == x"" ]; then
40e6f7a0	68	ts_report " FAILED ($TS_NS)"
05de8126	69	else
40e6f7a0	70	ts_report " FAILED ($1)"
05de8126	71	fi
05de8126 KZ	72	}
05de8126 KZ	73
09888efe KZ	74	function ts_failed {
	75	ts_failed_subtest "$1"
	76	exit 1
	77	}
	78
	79	function ts_ok_subtest {
05de8126	80	if [ x"$1" == x"" ]; then
40e6f7a0	81	ts_report " OK"
05de8126	82	else
40e6f7a0	83	ts_report " OK ($1)"
05de8126	84	fi
09888efe KZ	85	}
	86
	87	function ts_ok {
	88	ts_ok_subtest "$1"
05de8126 KZ	89	exit 0
	90	}
	91
57a917d6 KZ	92	function ts_log {
	93	echo "$1" >> $TS_OUTPUT
	94	[ "$TS_VERBOSE" == "yes" ] && echo "$1"
	95	}
	96
1d9acab1 KZ	97	function ts_has_option {
	98	NAME="$1"
	99	ALL="$2"
a02f320d	100	echo -n $ALL \| sed 's/ //g' \| awk 'BEGIN { FS="="; RS="--" } /('$NAME'$\|'$NAME'=)/ { print "yes" }'
1d9acab1 KZ	101	}
1d9acab1 KZ	102
1b03e2cd KZ	103	function ts_option_argument {
	104	NAME="$1"
	105	ALL="$2"
	106	echo -n $ALL \| sed 's/ //g' \| awk 'BEGIN { FS="="; RS="--" } /'$NAME'=/ { print $2 }'
	107	}
	108
db17c74b KZ	109	function ts_init_core_env {
	110	TS_NS="$TS_COMPONENT/$TS_TESTNAME"
	111	TS_OUTPUT="$TS_OUTDIR/$TS_TESTNAME"
495674f8	112	TS_VGDUMP="$TS_OUTDIR/$TS_TESTNAME.vgdump"
db17c74b KZ	113	TS_DIFF="$TS_DIFFDIR/$TS_TESTNAME"
	114	TS_EXPECTED="$TS_TOPDIR/expected/$TS_NS"
	115	TS_MOUNTPOINT="$TS_OUTDIR/${TS_TESTNAME}-mnt"
	116	}
	117
	118	function ts_init_core_subtest_env {
	119	TS_NS="$TS_COMPONENT/$TS_TESTNAME-$TS_SUBNAME"
	120	TS_OUTPUT="$TS_OUTDIR/$TS_TESTNAME-$TS_SUBNAME"
495674f8	121	TS_VGDUMP="$TS_OUTDIR/$TS_TESTNAME-$TS_SUBNAME.vgdump"
db17c74b KZ	122	TS_DIFF="$TS_DIFFDIR/$TS_TESTNAME-$TS_SUBNAME"
db17c74b KZ	123	TS_EXPECTED="$TS_TOPDIR/expected/$TS_NS"
64a2331f	124	TS_MOUNTPOINT="$TS_OUTDIR/${TS_TESTNAME}-${TS_SUBNAME}-mnt"
495674f8 KZ	125
495674f8 KZ	126	rm -f $TS_OUTPUT $TS_VGDUMP
4210c47a KZ	127	[ -d "$TS_OUTDIR" ] \|\| mkdir -p "$TS_OUTDIR"
4210c47a KZ	128
495674f8 KZ	129	touch $TS_OUTPUT
495674f8 KZ	130	[ -n "$TS_VALGRIND_CMD" ] && touch $TS_VGDUMP
db17c74b KZ	131	}
db17c74b KZ	132
905d0b9b	133	function ts_init_env {
e130ce53	134	local mydir=$(ts_abspath ${0%/*})
d9a9ff09	135	local tmp
d42bbae5	136
08b825db YD	137	LANG="POSIX"
	138	LANGUAGE="POSIX"
	139	LC_ALL="POSIX"
	140	CHARSET="UTF-8"
	141
1b03e2cd KZ	142	export LANG LANGUAGE LC_ALL CHARSET
1b03e2cd KZ	143
6dfe6f0e KZ	144	mydir=$(ts_canonicalize "$mydir")
6dfe6f0e KZ	145
1b03e2cd KZ	146	# automake directories
	147	top_srcdir=$(ts_option_argument "srcdir" "$*")
	148	top_builddir=$(ts_option_argument "builddir" "$*")
d42bbae5	149
1b03e2cd	150	# where is this script
a02f320d	151	TS_TOPDIR=$(ts_abspath $mydir/../../)
1b03e2cd KZ	152
	153	# default
	154	if [ -z "$top_srcdir" ]; then
	155	top_srcdir="$TS_TOPDIR/.."
	156	fi
	157	if [ -z "$top_builddir" ]; then
	158	top_builddir="$TS_TOPDIR/.."
	159	fi
	160
	161	top_srcdir=$(ts_abspath $top_srcdir)
	162	top_builddir=$(ts_abspath $top_builddir)
	163
a02f320d	164	TS_SCRIPT="$mydir/$(basename $0)"
d42bbae5 KZ	165	TS_SUBDIR=$(dirname $TS_SCRIPT)
	166	TS_TESTNAME=$(basename $TS_SCRIPT)
	167	TS_COMPONENT=$(basename $TS_SUBDIR)
	168
09888efe KZ	169	TS_NSUBTESTS=0
	170	TS_NSUBFAILED=0
	171
d42bbae5 KZ	172	TS_SELF="$TS_SUBDIR"
d42bbae5 KZ	173
1b03e2cd KZ	174	TS_OUTDIR="$top_builddir/tests/output/$TS_COMPONENT"
1b03e2cd KZ	175	TS_DIFFDIR="$top_builddir/tests/diff/$TS_COMPONENT"
db17c74b KZ	176
db17c74b KZ	177	ts_init_core_env
d42bbae5	178
cbac71bd	179	TS_VERBOSE=$(ts_has_option "verbose" "$*")
40e6f7a0	180	TS_PARALLEL=$(ts_has_option "parallel" "$*")
d42bbae5	181
d9a9ff09 RM	182	tmp=$( ts_has_option "memcheck" "$*")
	183	if [ "$tmp" == "yes" -a -f /usr/bin/valgrind ]; then
	184	TS_VALGRIND_CMD="/usr/bin/valgrind"
	185	fi
	186
632830cc	187	BLKID_FILE="$TS_OUTDIR/${TS_TESTNAME}.blkidtab"
d42bbae5	188
1b5417ac KZ	189	declare -a TS_SUID_PROGS
	190	declare -a TS_SUID_USER
	191	declare -a TS_SUID_GROUP
	192
adc8c80f KZ	193	if [ -f $TS_TOPDIR/commands.sh ]; then
	194	. $TS_TOPDIR/commands.sh
	195	fi
a02f320d	196
b7ea07e0	197	export BLKID_FILE
66822df3	198
495674f8	199	rm -f $TS_OUTPUT $TS_VGDUMP
4210c47a KZ	200	[ -d "$TS_OUTDIR" ] \|\| mkdir -p "$TS_OUTDIR"
4210c47a KZ	201
3dfa278e	202	touch $TS_OUTPUT
495674f8	203	[ -n "$TS_VALGRIND_CMD" ] && touch $TS_VGDUMP
97cdb3cb	204
d42bbae5 KZ	205	if [ "$TS_VERBOSE" == "yes" ]; then
	206	echo
	207	echo " script: $TS_SCRIPT"
d42bbae5	208	echo " sub dir: $TS_SUBDIR"
a02f320d	209	echo " top dir: $TS_TOPDIR"
d42bbae5 KZ	210	echo " self: $TS_SELF"
	211	echo " test name: $TS_TESTNAME"
	212	echo " test desc: $TS_DESC"
	213	echo " component: $TS_COMPONENT"
	214	echo " namespace: $TS_NS"
	215	echo " verbose: $TS_VERBOSE"
	216	echo " output: $TS_OUTPUT"
495674f8	217	echo " valgrind: $TS_VGDUMP"
d42bbae5 KZ	218	echo " expected: $TS_EXPECTED"
	219	echo " mountpoint: $TS_MOUNTPOINT"
	220	echo
	221	fi
905d0b9b KZ	222	}
905d0b9b KZ	223
09888efe KZ	224	function ts_init_subtest {
	225
	226	TS_SUBNAME="$1"
	227
db17c74b	228	ts_init_core_subtest_env
09888efe KZ	229
	230	[ $TS_NSUBTESTS -eq 0 ] && echo
	231	TS_NSUBTESTS=$(( $TS_NSUBTESTS + 1 ))
	232
40e6f7a0 SK	233	if [ "$TS_PARALLEL" == "yes" ]; then
	234	TS_TITLE=$(printf "%13s: %-30s ...\n%16s: %-27s ..." "$TS_COMPONENT" "$TS_DESC" "" "$TS_SUBNAME")
	235	else
	236	TS_TITLE=$(printf "%16s: %-27s ..." "" "$TS_SUBNAME")
	237	echo -n "$TS_TITLE"
	238	fi
09888efe KZ	239	}
09888efe KZ	240
905d0b9b	241	function ts_init {
d9a9ff09 RM	242	ts_init_env "$*"
d9a9ff09 RM	243
905d0b9b	244	local is_fake=$( ts_has_option "fake" "$*")
949cf64b	245	local is_force=$( ts_has_option "force" "$*")
905d0b9b	246
40e6f7a0 SK	247	if [ "$TS_PARALLEL" == "yes" ]; then
	248	TS_TITLE=$(printf "%13s: %-30s ..." "$TS_COMPONENT" "$TS_DESC")
	249	else
	250	TS_TITLE=$(printf "%13s: %-30s ..." "$TS_COMPONENT" "$TS_DESC")
	251	echo -n "$TS_TITLE"
	252	fi
d42bbae5 KZ	253
d42bbae5 KZ	254	[ "$is_fake" == "yes" ] && ts_skip "fake mode"
949cf64b	255	[ "$TS_OPTIONAL" == "yes" -a "$is_force" != "yes" ] && ts_skip "optional"
e83446da KZ	256	}
e83446da KZ	257
1b5417ac KZ	258	function ts_init_suid {
	259	PROG="$1"
	260	ct=${#TS_SUID_PROGS[*]}
	261
	262	# Save info about original setting
	263	TS_SUID_PROGS[$ct]=$PROG
	264	TS_SUID_USER[$ct]=$(stat --printf="%U" $PROG)
	265	TS_SUID_GROUP[$ct]=$(stat --printf="%G" $PROG)
	266
	267	chown root.root $PROG &> /dev/null
	268	chmod u+s $PROG &> /dev/null
	269	}
	270
a731b541 KZ	271	function ts_init_py {
	272	LIBNAME="$1"
	273
f48145b5	274	[ -f "$TS_TOPDIR/../py${LIBNAME}.la" ] \|\| ts_skip "py${LIBNAME} not compiled"
a731b541 KZ	275
	276	export LD_LIBRARY_PATH="$TS_TOPDIR/../.libs"
	277	export PYTHONPATH="$TS_TOPDIR/../$LIBNAME/python:$TS_TOPDIR/../.libs"
46407453 OO	278
	279	export PYTHON_VERSION=$(awk '/^PYTHON_VERSION/ { print $3 }' $top_builddir/Makefile)
	280	export PYTHON_MAJOR_VERSION=$(echo $PYTHON_VERSION \| sed 's/\..*//')
	281
	282	export PYTHON="python${PYTHON_MAJOR_VERSION}"
a731b541 KZ	283	}
a731b541 KZ	284
495674f8 KZ	285	function ts_valgrind {
	286	if [ -z "$TS_VALGRIND_CMD" ]; then
	287	$*
	288	else
	289	$TS_VALGRIND_CMD --tool=memcheck --leak-check=full \
	290	--leak-resolution=high --num-callers=20 \
	291	--log-file="$TS_VGDUMP" $*
	292	fi
	293	}
	294
09888efe KZ	295	function ts_gen_diff {
	296	local res=0
	297
64a2331f	298	if [ -s "$TS_OUTPUT" ]; then
4210c47a	299
46949388 KZ	300	# remove libtool lt- prefixes
	301	sed --in-place 's/^lt\-\(.*\: \)/\1/g' $TS_OUTPUT
	302
4210c47a	303	[ -d "$TS_DIFFDIR" ] \|\| mkdir -p "$TS_DIFFDIR"
09888efe	304	diff -u $TS_EXPECTED $TS_OUTPUT > $TS_DIFF
4210c47a KZ	305
	306	if [ -s $TS_DIFF ]; then
	307	res=1
	308	else
	309	rm -f $TS_DIFF;
	310	fi
09888efe KZ	311	else
	312	res=1
	313	fi
	314	return $res
	315	}
	316
495674f8 KZ	317	function tt_gen_mem_report {
	318	[ -z "$TS_VALGRIND_CMD" ] && echo "$1"
	319
	320	grep -q -E 'ERROR SUMMARY: [1-9]' $TS_VGDUMP &> /dev/null
	321	if [ $? -eq 0 ]; then
	322	echo "mem-error detected!"
	323	fi
	324	}
	325
09888efe	326	function ts_finalize_subtest {
e83446da KZ	327	local res=0
e83446da KZ	328
64a2331f	329	if [ -s "$TS_EXPECTED" ]; then
09888efe KZ	330	ts_gen_diff
	331	if [ $? -eq 1 ]; then
	332	ts_failed_subtest "$1"
	333	res=1
	334	else
495674f8	335	ts_ok_subtest "$(tt_gen_mem_report "$1")"
09888efe KZ	336	fi
	337	else
	338	ts_skip_subtest "output undefined"
	339	fi
	340
	341	[ $res -ne 0 ] && TS_NSUBFAILED=$(( $TS_NSUBFAILED + 1 ))
db17c74b KZ	342
	343	# reset environment back to parental test
	344	ts_init_core_env
	345
09888efe KZ	346	return $res
	347	}
	348
	349	function ts_finalize {
1b5417ac KZ	350	for idx in $(seq 0 $((${#TS_SUID_PROGS[*]} - 1))); do
	351	PROG=${TS_SUID_PROGS[$idx]}
	352	chmod a-s $PROG &> /dev/null
	353	chown ${TS_SUID_USER[$idx]}.${TS_SUID_GROUP[$idx]} $PROG &> /dev/null
	354	done
	355
09888efe	356	if [ $TS_NSUBTESTS -ne 0 ]; then
b8ab3744	357	printf "%11s..."
09888efe KZ	358	if [ $TS_NSUBFAILED -ne 0 ]; then
	359	ts_failed "$TS_NSUBFAILED from $TS_NSUBTESTS sub-tests"
	360	else
	361	ts_ok "all $TS_NSUBTESTS sub-tests PASSED"
	362	fi
e83446da	363	fi
425ca40a KZ	364
	365	if [ -s $TS_EXPECTED ]; then
	366	ts_gen_diff
	367	if [ $? -eq 1 ]; then
	368	ts_failed "$1"
	369	fi
	370	ts_ok "$1"
	371	fi
	372
09888efe	373	ts_skip "output undefined"
e83446da KZ	374	}
e83446da KZ	375
3dfa278e	376	function ts_die {
57a917d6	377	ts_log "$1"
3dfa278e KZ	378	if [ -n "$2" ] && [ -b "$2" ]; then
3dfa278e KZ	379	ts_device_deinit "$2"
2f791546	380	ts_fstab_clean # for sure...
3dfa278e KZ	381	fi
	382	ts_finalize
	383	}
	384
35c636e1 KZ	385	function ts_image_md5sum {
	386	local img=${1:-"$TS_OUTDIR/${TS_TESTNAME}.img"}
	387	echo $(md5sum "$img" \| awk '{printf $1}') $(basename "$img")
	388	}
05de8126	389
35c636e1 KZ	390	function ts_image_init {
	391	local mib=${1:-"5"} # size in MiBs
	392	local img=${2:-"$TS_OUTDIR/${TS_TESTNAME}.img"}
2f791546	393
35c636e1 KZ	394	dd if=/dev/zero of="$img" bs=1M count=$mib &> /dev/null
	395	echo "$img"
	396	return 0
	397	}
05de8126	398
35c636e1	399	function ts_device_init {
5792255b	400	local img=$(ts_image_init $1 $2)
e2f092d3	401	local dev=$($TS_CMD_LOSETUP --show -f "$img")
df7e52d7	402
632830cc KZ	403	if [ -z "$dev" ]; then
632830cc KZ	404	ts_device_deinit $dev
df7e52d7 KZ	405	return 1 # error
	406	fi
	407
632830cc	408	echo $dev
df7e52d7 KZ	409	return 0 # succes
	410	}
	411
	412	function ts_device_deinit {
3dfa278e KZ	413	local DEV="$1"
	414
	415	if [ -b "$DEV" ]; then
	416	$TS_CMD_UMOUNT "$DEV" &> /dev/null
	417	$TS_CMD_LOSETUP -d "$DEV" &> /dev/null
df7e52d7 KZ	418	fi
df7e52d7 KZ	419	}
064b8c38	420
3f5bda01	421	function ts_uuid_by_devname {
283a8c15	422	echo $($TS_CMD_BLKID -p -s UUID -o value $1)
3f5bda01 KZ	423	}
	424
	425	function ts_label_by_devname {
283a8c15	426	echo $($TS_CMD_BLKID -p -s LABEL -o value $1)
3f5bda01 KZ	427	}
	428
	429	function ts_fstype_by_devname {
283a8c15	430	echo $($TS_CMD_BLKID -p -s TYPE -o value $1)
3f5bda01 KZ	431	}
	432
	433	function ts_device_has {
	434	local TAG="$1"
	435	local VAL="$2"
	436	local DEV="$3"
3dfa278e	437	local vl=""
3f5bda01 KZ	438
	439	case $TAG in
	440	"TYPE") vl=$(ts_fstype_by_devname $DEV);;
	441	"LABEL") vl=$(ts_label_by_devname $DEV);;
	442	"UUID") vl=$(ts_uuid_by_devname $DEV);;
	443	*) return 1;;
	444	esac
	445
	446	if [ "$vl" == "$VAL" ]; then
	447	return 0
	448	fi
	449	return 1
	450	}
3dfa278e KZ	451
	452	function ts_device_has_uuid {
	453	ts_uuid_by_devname "$1" \| egrep -q '^[0-9a-z]{8}-[0-9a-z]{4}-[0-9a-z]{4}-[0-9a-z]{4}-[0-9a-z]{12}$'
	454	return $?
	455	}
	456
3ff2557c	457	function ts_is_mounted {
6dfe6f0e	458	local DEV=$(ts_canonicalize "$1")
3ff2557c KZ	459
	460	grep -q $DEV /proc/mounts && return 0
	461
	462	if [ "${DEV#/dev/loop/}" != "$DEV" ]; then
	463	return grep -q "/dev/loop${DEV#/dev/loop/}" /proc/mounts
	464	fi
	465	return 1
	466	}
	467
c98825ac	468	function ts_fstab_open {
601d12fb	469	echo "# <!-- util-linux test entry" >> /etc/fstab
c98825ac KZ	470	}
	471
	472	function ts_fstab_close {
	473	echo "# -->" >> /etc/fstab
	474	}
	475
	476	function ts_fstab_addline {
	477	local SPEC="$1"
	478	local MNT=${2:-"$TS_MOUNTPOINT"}
	479	local FS=${3:-"auto"}
b002d021	480	local OPT=${4:-"defaults"}
c98825ac	481
b002d021	482	echo "$SPEC $MNT $FS $OPT 0 0" >> /etc/fstab
c98825ac KZ	483	}
	484
	485	function ts_fstab_add {
	486	ts_fstab_open
b002d021	487	ts_fstab_addline $*
c98825ac KZ	488	ts_fstab_close
	489	}
	490
	491	function ts_fstab_clean {
	492	sed --in-place "
601d12fb	493	/# <!-- util-linux/!b
c98825ac KZ	494	:a
	495	/# -->/!{
	496	N
	497	ba
	498	}
601d12fb	499	s/# <!-- util-linux.*-->//;
c98825ac KZ	500	/^$/d" /etc/fstab
	501	}
	502
d0bcd9b3	503	function ts_fdisk_clean {
e1fe1815	504	local DEVNAME=$1
618ec053	505
d0bcd9b3	506	# remove non comparable parts of fdisk output
618ec053	507	if [ x"${DEVNAME}" != x"" ]; then
e1fe1815	508	sed -i -e "s:${DEVNAME}:<removed>:g" $TS_OUTPUT
618ec053 KZ	509	fi
618ec053 KZ	510
e1fe1815 KZ	511	sed -i -e 's/Disk identifier:.*/Disk identifier: <removed>/g' \
	512	-e 's/Created a new.*/Created a new <removed>./g' \
	513	-e 's/^Device[[:blank:]]*Start/Device Start/g' \
	514	-e 's/^Device[[:blank:]]*Boot/Device Boot/g' \
	515	-e 's/^Device[[:blank:]]*Flag/Device Flag/g' \
	516	-e 's/Welcome to fdisk.*/Welcome to fdisk <removed>./g' \
d0bcd9b3 FC	517	$TS_OUTPUT
d0bcd9b3 FC	518	}
618ec053 KZ	519
	520	function ts_scsi_debug_init {
	521
	522	modprobe --dry-run --quiet scsi_debug
	523	[ "$?" == 0 ] \|\| ts_skip "missing scsi_debug module"
	524
	525	rmmod scsi_debug &> /dev/null
	526	modprobe scsi_debug $*
	527	[ "$?" == 0 ] \|\| ts_die "Cannot init device"
	528
ef2c9e3f	529	DEVNAME=$(grep --with-filename scsi_debug /sys/block/*/device/model \| awk -F '/' '{print $4}')
618ec053 KZ	530	[ "x${DEVNAME}" == "x" ] && ts_die "Cannot find device"
	531
	532	DEVICE="/dev/${DEVNAME}"
	533
	534	sleep 1
	535	udevadm settle
	536
	537	echo $DEVICE
	538	}