From 42c1bb70e4afbac0fab62276afee3dca7da2c949 Mon Sep 17 00:00:00 2001
From: Mateusz Majewski <m.majewski2@samsung.com>
Date: Thu, 27 Aug 2020 10:01:01 +0200
Subject: [PATCH] Improve the integration test script a bit

This includes eliminating many bashisms (the script is supposed to be
POSIX-compatible) and fixing various warnings reported by shellcheck.
Not all warnings are fixed yet, but the other ones are harder to fix,
and what we already achieved is useful anyway.

Change-Id: Ib0f4a2f52f90fb2af823dfe9c9c37c947a0e6632
---
 tests/dlog_test.in | 393 ++++++++++++++++++++++++-----------------------------
 1 file changed, 178 insertions(+), 215 deletions(-)

diff --git a/tests/dlog_test.in b/tests/dlog_test.in
index 3037941..8895cbc 100644
--- a/tests/dlog_test.in
+++ b/tests/dlog_test.in
@@ -16,73 +16,71 @@ TEST_DYNAMIC_FILTERS="@DYNAMIC_FILTERS@"
 TESTDIR=/var/lib/dlog-tests
 
 extract_timestamp() {
-	local ts=0
+	ts=0
 	case "$1" in
 		"threadtime")
-			time=`echo $2 | awk -F '[ +]' '{print $2}'`
-			ts=`date +%s%N -d $time`
+			time=$(echo "$2" | awk -F '[ +]' '{print $2}')
+			ts=$(date +%s%N -d "$time")
 		;;
 		"long")
-			time=`echo $2 | awk -F '[ +.]' '{print $3}'`
-			ms=`echo $2 | awk -F '[ +.]' '{print $4}'`
-			sec=`date +%s%N -d $time`
+			time=$(echo "$2" | awk -F '[ +.]' '{print $3}')
+			ms=$(echo "$2" | awk -F '[ +.]' '{print $4}')
+			sec=$(date +%s%N -d "$time")
 			ns=$((10#$ms * 1000000))
-			ts=$(($sec + $ns))
+			ts=$((sec + ns))
 		;;
 		"rwtime")
-			time=`echo $2 | awk -F '[ +.]' '{print $2}'`
-			ts=`date +%s%N -d $time`
+			time=$(echo "$2" | awk -F '[ +.]' '{print $2}')
+			ts=$(date +%s%N -d "$time")
 		;;
 		"recv_realtime")
-			time=`echo $2 | awk -F '[ +.]' '{print $2}'`
-			ts=`date +%s%N -d $time`
+			time=$(echo "$2" | awk -F '[ +.]' '{print $2}')
+			ts=$(date +%s%N -d "$time")
 		;;
 		"time")
-			time=`echo $2 | awk -F '[ +.]' '{print $2}'`
-			ts=`date +%s%N -d $time`
+			time=$(echo "$2" | awk -F '[ +.]' '{print $2}')
+			ts=$(date +%s%N -d "$time")
 		;;
 		"kerneltime")
-			ts=`echo $2 | awk -F '[ +]' '{print $1}' | sed -e 's/\.//g'`
+			ts=$(echo "$2" | awk -F '[ +]' '{print $1}' | sed -e 's/\.//g')
 		;;
 	esac
 	echo "$ts"
 }
 
 cleanup() {
-	[ $UTIL_PID -ne -1 ] && kill $UTIL_PID > /dev/null 2>&1
-	[ $MT_TEST  -ne -1 ] && kill $MT_TEST  > /dev/null 2>&1
-	[ $LOGGER   -ne -1 ] && kill $LOGGER   > /dev/null 2>&1
-	[ -d $TESTDIR ] && rm -rf $TESTDIR/*
-	[ -d $RUNTIME_FILTERS_DIR ] && rm -rf $RUNTIME_FILTERS_DIR
+	[ "$UTIL_PID" -ne -1 ] && kill "$UTIL_PID" > /dev/null 2>&1
+	[ "$MT_TEST"  -ne -1 ] && kill "$MT_TEST"  > /dev/null 2>&1
+	[ "$LOGGER"   -ne -1 ] && kill "$LOGGER"   > /dev/null 2>&1
+	[ -d "$TESTDIR" ] && rm -rf "$TESTDIR"/*
+	[ -d "$RUNTIME_FILTERS_DIR" ] && rm -rf "$RUNTIME_FILTERS_DIR"
 }
 
 trap cleanup 0
 
 check_daemon() {
-	local ret=1
-	if [ $LOGGER -ne -1 ] && [ -z "$(ps -o pid= -p $LOGGER)" ]; then
+	ret=1
+	if [ "$LOGGER" -ne -1 ] && [ -z "$(ps -o pid= -p "$LOGGER")" ]; then
 		ret=0
 	fi
-	return $ret
+	return "$ret"
 }
 
 fail() {
-	check_daemon
-	[ $? -eq 0 ] && daemon_status="[logger daemon not running]"
+	check_daemon && daemon_status="[logger daemon not running]"
 
-	FAILS=$(($FAILS + 1))
-	TOTAL=$(($TOTAL + 1))
-	printf "[%02d] FAILED: %s %s\n" $TOTAL "$LOG_DETAILS" "$daemon_status"
+	FAILS=$((FAILS + 1))
+	TOTAL=$((TOTAL + 1))
+	printf "[%02d] FAILED: %s %s\n" "$TOTAL" "$LOG_DETAILS" "$daemon_status"
 	LOG_DETAILS=
 }
 
 ok() {
-	check_daemon
-	[ $? -eq 0 ] && daemon_status="[logger daemon not running]"
+	check_daemon && daemon_status="[logger daemon not running]"
 
-	OKS=$(($OKS + 1))
-	TOTAL=$(($TOTAL + 1))
-	printf "[%02d] PASSED: %s %s\n" $TOTAL "$LOG_DETAILS" "$daemon_status"
+	OKS=$((OKS + 1))
+	TOTAL=$((TOTAL + 1))
+	printf "[%02d] PASSED: %s %s\n" "$TOTAL" "$LOG_DETAILS" "$daemon_status"
 	LOG_DETAILS=
 }
 
@@ -91,32 +89,32 @@ exec 2> /dev/null
 
 USAGE_MESSAGE="usage: $0 pipe|logger|pipe_quick|logger_quick"
 
-if [ $# -ne 1 ]; then
-	echo $USAGE_MESSAGE
+if [ "$#" -ne 1 ]; then
+	echo "$USAGE_MESSAGE"
 	exit 1
 fi
 
-if [ "$1" == "pipe" ]; then
+if [ "$1" = "pipe" ]; then
 	type="pipe"
 	quick=0
-elif [ "$1" == "logger" ]; then
+elif [ "$1" = "logger" ]; then
 	type="logger"
 	quick=0
-elif [ "$1" == "pipe_quick" ]; then
+elif [ "$1" = "pipe_quick" ]; then
 	type="pipe"
 	quick=1
-elif [ "$1" == "logger_quick" ]; then
+elif [ "$1" = "logger_quick" ]; then
 	type="logger"
 	quick=1
 else
-	echo $USAGE_MESSAGE
+	echo "$USAGE_MESSAGE"
 	exit 1
 fi
 
 NEEDS_TO_QUIT=0
 capsh --print | grep Current | grep cap_syslog > /dev/null || { echo "*** ERROR: cap_syslog missing"; NEEDS_TO_QUIT=1; }
 mount | grep ' / ' | grep rw > /dev/null || { echo "*** ERROR: root not mounted read-write"; NEEDS_TO_QUIT=1; }
-[[ $NEEDS_TO_QUIT -eq 0 ]] || exit 1
+[ "$NEEDS_TO_QUIT" -eq 0 ] || exit 1
 
 if [ -z "$DLOG_CONFIG_PATH" ]; then
 	ORIGINAL_CONFIG_PATH="/etc/dlog.conf"
@@ -132,80 +130,81 @@ RUNTIME_FILTERS_DIR="/tmp/dlog-filters/"
 mkdir -p "$RUNTIME_FILTERS_DIR"
 
 # Start the daemon
-if [ $type == "pipe" ]; then
+if [ "$type" = "pipe" ]; then
 	dlog_logger &
+	dlog_logger -b 99 -t 0 &
 	LOGGER=$!
 	sleep 1
 fi
 
-if [ "$TEST_DYNAMIC_FILTERS" == "true" ]; then
+if [ "$TEST_DYNAMIC_FILTERS" = "true" ]; then
 	dlogctl -c
 	dlogctl --enable
 	dlogutil -c -b radio -b system -b main
 	LOG_DETAILS="dlogctl --disable (no args)"
 	dlogctl --disable
-	[ `dlogctl -g | grep ENABLED | wc -l` -eq 0 ] && ok || fail
+	[ "$(dlogctl -g | grep ENABLED | wc -l)" -eq 0 ] && ok || fail
 	LOG_DETAILS="testing if filters were applied"
 	dlogsend -b system -t TEST test
 	dlogsend -b main -t TEST test
 	dlogsend -b radio -t TEST test
-	[ `dlogutil -d -b radio -b system -b main | wc -l` -eq 0 ] && ok || fail
+	[ "$(dlogutil -d -b radio -b system -b main | wc -l)" -eq 0 ] && ok || fail
 
 	LOG_DETAILS="dlogctl --enable (no args)"
 	dlogctl --enable
-	[ `dlogctl -g | grep DISABLED | wc -l` -eq 0 ] && ok || fail
+	[ "$(dlogctl -g | grep DISABLED | wc -l)" -eq 0 ] && ok || fail
 	LOG_DETAILS="testing if filters were applied"
 	dlogutil -c -b radio -b system -b main
 	dlogsend -b system -t TEST test
 	dlogsend -b main -t TEST test
 	dlogsend -b radio -t TEST test
-	[ `dlogutil -d -b radio -b system -b main | wc -l` -eq 3 ] && ok || fail
+	[ "$(dlogutil -d -b radio -b system -b main | wc -l)" -eq 3 ] && ok || fail
 
 	LOG_DETAILS="dlogctl --disable (1 arg)"
 	dlogctl --disable -b system
-	[ `dlogctl -g | grep DISABLED | grep system | wc -l` -eq 1 ] &&
-	[ `dlogctl -g | grep DISABLED               | wc -l` -eq 1 ] && ok || fail
+	[ "$(dlogctl -g | grep DISABLED | grep system | wc -l)" -eq 1 ] &&
+	[ "$(dlogctl -g | grep DISABLED               | wc -l)" -eq 1 ] && ok || fail
 	LOG_DETAILS="testing if filters were applied"
 	dlogutil -c -b radio -b system -b main
 	dlogsend -b system -t TEST test
 	dlogsend -b main -t TEST test
 	dlogsend -b radio -t TEST test
-	[ `dlogutil -d -b radio -b system -b main | wc -l` -eq 2 ] && ok || fail
+	[ "$(dlogutil -d -b radio -b system -b main | wc -l)" -eq 2 ] && ok || fail
 
 	LOG_DETAILS="dlogctl --disable (multiple args)"
 	dlogctl --disable -b main -b radio
-	[ `dlogctl -g | grep DISABLED | grep -v system | wc -l` -eq 2 ] &&
-	[ `dlogctl -g | grep DISABLED | grep     radio | wc -l` -eq 1 ] &&
-	[ `dlogctl -g | grep DISABLED | grep      main | wc -l` -eq 1 ] && ok || fail
+	[ "$(dlogctl -g | grep DISABLED | grep -v system | wc -l)" -eq 2 ] &&
+	[ "$(dlogctl -g | grep DISABLED | grep     radio | wc -l)" -eq 1 ] &&
+	[ "$(dlogctl -g | grep DISABLED | grep      main | wc -l)" -eq 1 ] && ok || fail
 	LOG_DETAILS="testing if filters were applied"
 	dlogutil -c -b radio -b system -b main
 	dlogsend -b system -t TEST test
 	dlogsend -b main -t TEST test
 	dlogsend -b radio -t TEST test
-	[ `dlogutil -d -b radio -b system -b main | wc -l` -eq 0 ] && ok || fail
+	[ "$(dlogutil -d -b radio -b system -b main | wc -l)" -eq 0 ] && ok || fail
 
 	LOG_DETAILS="dlogctl --enable (multiple args)"
 	dlogctl --enable -b radio -b system
-	[ `dlogctl -g | grep DISABLED               | wc -l` -eq 1 ] &&
-	[ `dlogctl -g | grep DISABLED | grep   main | wc -l` -eq 1 ] &&
-	[ `dlogctl -g | grep  ENABLED | grep system | wc -l` -eq 1 ] &&
-	[ `dlogctl -g | grep  ENABLED | grep  radio | wc -l` -eq 1 ] && ok || fail
+	[ "$(dlogctl -g | grep DISABLED               | wc -l)" -eq 1 ] &&
+	[ "$(dlogctl -g | grep DISABLED | grep   main | wc -l)" -eq 1 ] &&
+	[ "$(dlogctl -g | grep  ENABLED | grep system | wc -l)" -eq 1 ] &&
+	[ "$(dlogctl -g | grep  ENABLED | grep  radio | wc -l)" -eq 1 ] && ok || fail
 	LOG_DETAILS="testing if filters were applied"
 	dlogutil -c -b radio -b system -b main
 	dlogsend -b system -t TEST test
 	dlogsend -b main -t TEST test
 	dlogsend -b radio -t TEST test
-	[ `dlogutil -d -b radio -b system -b main | wc -l` -eq 2 ] && ok || fail
+	[ "$(dlogutil -d -b radio -b system -b main | wc -l)" -eq 2 ] && ok || fail
 
 	LOG_DETAILS="dlogctl --enable (1 arg)"
 	dlogctl --enable -b main
-	[ `dlogctl -g | grep DISABLED | wc -l` -eq 0 ] && ok || fail
+	[ "$(dlogctl -g | grep DISABLED | wc -l)" -eq 0 ] && ok || fail
 	LOG_DETAILS="testing if filters were applied"
 	dlogutil -c -b radio -b system -b main
 	dlogsend -b system -t TEST test
 	dlogsend -b main -t TEST test
 	dlogsend -b radio -t TEST test
-	[ `dlogutil -d -b radio -b system -b main | wc -l` -eq 3 ] && ok || fail
+	[ "$(dlogutil -d -b radio -b system -b main | wc -l)" -eq 3 ] && ok || fail
 
 	LOG_DETAILS="dlogctl -s allow"
 	dlogutil -c -b radio -b system -b main
@@ -214,7 +213,7 @@ if [ "$TEST_DYNAMIC_FILTERS" == "true" ]; then
 	dlogctl -t TEST_TAG -s allow
 	dlogsend -b main -t TEST_TAG test
 	dlogsend -b main -t TEST test
-	[ `dlogutil -d -b main | wc -l` -eq 1 ] && ok || fail
+	[ "$(dlogutil -d -b main | wc -l)" -eq 1 ] && ok || fail
 
 	LOG_DETAILS="dlogctl -s [N]"
 	dlogutil -c -b radio -b system -b main
@@ -223,71 +222,71 @@ if [ "$TEST_DYNAMIC_FILTERS" == "true" ]; then
 	dlogctl -t TEST_TAG -s 3
 	dlogsend -b main -c 10 -t TEST_TAG test
 	dlogsend -b main -c 10 -t TEST test
-	[ `dlogutil -d -b main | wc -l` -eq 4 ] && ok || fail
+	[ "$(dlogutil -d -b main | wc -l)" -eq 4 ] && ok || fail
 
 	LOG_DETAILS="testing invalid parameters for dlogctl (1/13)"
-	dlogctl -s invalid &> /dev/null && fail || ok
+	dlogctl -s invalid > /dev/null && fail || ok
 
 	LOG_DETAILS="testing invalid parameters for dlogctl (2/13)"
-	dlogctl -p X -g &> /dev/null && fail || ok
+	dlogctl -p X -g > /dev/null && fail || ok
 
 	LOG_DETAILS="testing invalid parameters for dlogctl (3/13)"
-	dlogctl -b invalid --disable &> /dev/null && fail || ok
+	dlogctl -b invalid --disable > /dev/null && fail || ok
 
 	LOG_DETAILS="testing invalid parameters for dlogctl (4/13)"
-	dlogctl -s allow -g -t xyz -p E &> /dev/null && fail || ok
+	dlogctl -s allow -g -t xyz -p E > /dev/null && fail || ok
 
 	LOG_DETAILS="testing invalid parameters for dlogctl (5/13)"
-	dlogctl -s allow -c &> /dev/null && fail || ok
+	dlogctl -s allow -c > /dev/null && fail || ok
 
 	LOG_DETAILS="testing invalid parameters for dlogctl (6/13)"
-	dlogctl -c -g -t xyz -p E &> /dev/null && fail || ok
+	dlogctl -c -g -t xyz -p E > /dev/null && fail || ok
 
 	# -s out of range
 	LOG_DETAILS="testing invalid parameters for dlogctl (7/13)"
-	dlogctl -s -10 &> /dev/null && fail || ok
+	dlogctl -s -10 > /dev/null && fail || ok
 
 	LOG_DETAILS="testing invalid parameters for dlogctl (8/13)"
-	dlogctl -s 999999 &> /dev/null && fail || ok
+	dlogctl -s 999999 > /dev/null && fail || ok
 
 	# -s correctness
 	LOG_DETAILS="testing invalid parameters for dlogctl (9/13)"
 	dlogctl -s 100 && ok || fail
 
 	LOG_DETAILS="testing invalid parameters for dlogctl (10/13)"
-	[ `cat $RUNTIME_FILTERS_DIR/05-logctl.conf | grep -E 'limiter\|\*\|\*=100' | wc -l` -eq 1 ] && ok || fail
+	[ $(cat "$RUNTIME_FILTERS_DIR/05-logctl.conf" | grep -E 'limiter\|\*\|\*=100' | wc -l) -eq 1 ] && ok || fail
 
 	# -g correctness
 	LOG_DETAILS="testing invalid parameters for dlogctl (11/13)"
-	[ `dlogctl -g | grep '*:*' | grep 100 | wc -l` -eq 1 ] && ok || fail
+	[ "$(dlogctl -g | grep '*:*' | grep 100 | wc -l)" -eq 1 ] && ok || fail
 
 	# -c correctness
 	LOG_DETAILS="testing invalid parameters for dlogctl (12/13)"
 	dlogctl -c -t '*' -p '*' && ok || fail
 
 	LOG_DETAILS="testing invalid parameters for dlogctl (13/13)"
-	[ `cat $RUNTIME_FILTERS_DIR/05-logctl.conf | grep -E 'limiter\|\*\|\*=100' | wc -l` -eq 0 ] && ok || fail
+	[ $(cat "$RUNTIME_FILTERS_DIR/05-logctl.conf" | grep -E 'limiter\|\*\|\*=100' | wc -l) -eq 0 ] && ok || fail
 	dlogctl -c
 
 	LOG_DETAILS="testing if the whole dynamic config directory is respected"
 	dlogctl -s deny
-	cp $RUNTIME_FILTERS_DIR/{05-logctl.conf,10-other.conf}
+	cp $RUNTIME_FILTERS_DIR/05-logctl.conf $RUNTIME_FILTERS_DIR/10-other.conf
 	dlogctl -c
 	dlogutil -c -b radio -b system -b main
 	dlogsend -b system -t TEST test
 	dlogsend -b main -t TEST test
 	dlogsend -b radio -t TEST test
-	[ `dlogutil -d -b radio -b system -b main | wc -l` -eq 0 ] && ok || fail
+	[ "$(dlogutil -d -b radio -b system -b main | wc -l)" -eq 0 ] && ok || fail
 	rm $RUNTIME_FILTERS_DIR/10-other.conf
 fi
 
 SEED=$(head -c 6 /dev/urandom | base64)
 dlogsend -k "$SEED"
 # -k is async, unlike normal mode; therefore we have to wait until the logging process actually finishes
-while ps -o args | grep "dlogsend" | grep -v grep &> /dev/null || ps -o args | grep "dlog-log-critical" | grep -v grep &> /dev/null; do :; done
+while ps -o args | grep "dlogsend" | grep -v grep > /dev/null || ps -o args | grep "dlog-log-critical" | grep -v grep > /dev/null; do :; done
 CRIT_PATH="@DLOG_CRITICAL_LOGFILE_PATH@"
 LOG_DETAILS="testing if critical logging works"
-cat "$CRIT_PATH".{a,b} | grep -F "$SEED" &> /dev/null && ok || fail
+cat "$CRIT_PATH".a "$CRIT_PATH".b | grep -F "$SEED" > /dev/null && ok || fail
 
 # put 100 log entries in the "main" buffer
 dlogutil -c
@@ -296,64 +295,64 @@ sleep 1
 
 
 LOG_DETAILS="testing if dlogutil -d exits with success after printing logs"
-dlogutil -d &> /dev/null && ok || fail
+dlogutil -d > /dev/null && ok || fail
 
 LOG_DETAILS="testing if -t argument is parsed properly"
-dlogutil -t dummy &> /dev/null && fail || ok
+dlogutil -t dummy > /dev/null && fail || ok
 
 LOG_DETAILS="testing if -u argument is parsed properly"
-dlogutil -du dummy &> /dev/null && fail || ok
+dlogutil -du dummy > /dev/null && fail || ok
 
 LOG_DETAILS="testing if limiting printed log entries to less than exists in the buffer returns proper value"
-[ $(dlogutil -b main -t  20 | wc -l) -eq  20 ] && ok || fail # less logs than currently in buffer
+[ "$(dlogutil -b main -t  20 | wc -l)" -eq  20 ] && ok || fail # less logs than currently in buffer
 
 LOG_DETAILS="testing if limiting printed log entries to more than exists in the buffer returns proper value"
-[ $(dlogutil -b main -t 200 | wc -l) -eq 100 ] && ok || fail # more
+[ "$(dlogutil -b main -t 200 | wc -l)" -eq 100 ] && ok || fail # more
 
 LOG_DETAILS="testing if dlogutil returns exact amount of entries as there is in the buffer"
-[ $(dlogutil -b main -d     | wc -l) -eq 100 ] && ok || fail # exactly
+[ "$(dlogutil -b main -d     | wc -l)" -eq 100 ] && ok || fail # exactly
 
 LOG_DETAILS="testing if reading from  dummy buffer returns an error as expected"
-dlogutil -b nonexistent_buffer &> /dev/null && fail || ok
+dlogutil -b nonexistent_buffer > /dev/null && fail || ok
 
 LOG_DETAILS="testing if reading from \"system\" buffer returns zero entries (logs are in the \"main\" buffer)"
-[ $(dlogutil -d -b system | wc -l) -eq 0 ] && ok || fail
+[ "$(dlogutil -d -b system | wc -l)" -eq 0 ] && ok || fail
 
 LOG_DETAILS="testing if dlogutil -c empties all buffers"
 dlogutil -cb main && ok || fail
 
 LOG_DETAILS="testing if writing entries to empty buffer and reading them returns proper amount of entries"
 test_libdlog 10
-[ $(dlogutil -b main -d | wc -l) -eq 10 ] && ok || fail # should be 10, not 110
+[ "$(dlogutil -b main -d | wc -l)" -eq 10 ] && ok || fail # should be 10, not 110
 
 LOG_DETAILS="testing if filters work (1/3)"
-[ $(dlogutil -b main -d *:E | wc -l) -eq 5 ] && ok || fail # half of current logs (test_libdlog alternates between error and info log levels)
+[ "$(dlogutil -b main -d *:E | wc -l)" -eq 5 ] && ok || fail # half of current logs (test_libdlog alternates between error and info log levels)
 
 LOG_DETAILS="testing if filters work (2/3)"
-[ $(dlogutil -b main -d *:W | wc -l) -eq 5 ] && ok || fail
+[ "$(dlogutil -b main -d *:W | wc -l)" -eq 5 ] && ok || fail
 
 LOG_DETAILS="testing if filters work (3/3)"
-[ $(dlogutil -b main -d *:I | wc -l) -eq 10 ] && ok || fail
+[ "$(dlogutil -b main -d *:I | wc -l)" -eq 10 ] && ok || fail
 
 LOG_DETAILS="testing if exact filters work (1/3)"
-[ $(dlogutil -b main -d *:=E | wc -l) -eq 5 ] && ok || fail
+[ "$(dlogutil -b main -d *:=E | wc -l)" -eq 5 ] && ok || fail
 
 LOG_DETAILS="testing if exact filters work (2/3)"
-[ $(dlogutil -b main -d *:=W | wc -l) -eq 0 ] && ok || fail
+[ "$(dlogutil -b main -d *:=W | wc -l)" -eq 0 ] && ok || fail
 
 LOG_DETAILS="testing if exact filters work (3/3)"
-[ $(dlogutil -b main -d *:=I | wc -l) -eq 5 ] && ok || fail
+[ "$(dlogutil -b main -d *:=I | wc -l)" -eq 5 ] && ok || fail
 
 LOG_DETAILS="testing if adding \"silent\" filter works"
-[ $(dlogutil -b main -s -d | wc -l) -eq 0 ] && ok || fail
+[ "$(dlogutil -b main -s -d | wc -l)" -eq 0 ] && ok || fail
 
 LOG_DETAILS="testing if reading buffer size returns proper exit code"
-dlogutil -gb main &> /dev/null && ok || fail
+dlogutil -gb main > /dev/null && ok || fail
 
 LOG_DETAILS="testing if writing all entries to single file works (-f)"
-dlogutil -f $TESTDIR/dlog_test_file -d &> /dev/null && ok || fail
+dlogutil -f $TESTDIR/dlog_test_file -d > /dev/null && ok || fail
 
-if [ $quick -ne 1 ]; then
+if [ "$quick" -ne 1 ]; then
 	LOG_DETAILS="testing if the continuous mode works as expected (1/2)"
 	dlogutil -b main -f $TESTDIR/dlog_continuous1_file &
 	UTIL_PID=$!
@@ -422,7 +421,7 @@ UTIL_PID=-1
 
 LOG_DETAILS="testing if libdlogutil works correctly in the dump mode"
 test_libdlogutil dump $LIBDLOGUTIL_CORRECT_PID $type && ok || fail
-if [ $quick -ne 1 ]; then
+if [ "$quick" -ne 1 ]; then
 	LOG_DETAILS="testing if libdlogutil works correctly if processing the logs takes some time"
 	test_libdlogutil timer $LIBDLOGUTIL_CORRECT_PID $type && ok || fail
 fi
@@ -455,7 +454,7 @@ test_libdlogutil prefix_wrong $LIBDLOGUTIL_CORRECT_PID $type && ok || fail
 LOG_DETAILS="testing if libdlogutil returns the correct buffer traits"
 test_libdlogutil traits $LIBDLOGUTIL_CORRECT_PID $type && ok || fail
 LOG_DETAILS="testing if libdlogutil aliasing works"
-if [ $type == "pipe" ]; then
+if [ "$type" = "pipe" ]; then
 	test_libdlogutil alias $LIBDLOGUTIL_CORRECT_PID $type && ok || fail
 else
 	DLOG_CONFIG_PATH="@datadir@/dlog-logger.conf.alias" test_libdlogutil alias $LIBDLOGUTIL_CORRECT_PID $type && ok || fail
@@ -513,9 +512,9 @@ for PARAM in always auto none never; do
 				COMMAND="script -qc\"$COMMAND\" /dev/null | sed 's/\r$//'"
 			fi
 
-			# `eval` is needed since `$COMMAND` may contain `"`
-			line=`eval $COMMAND | tr '\033\n' '~@'`
-			[[ `echo "$line" | sed -re "$REGEX"` == "1" ]] && ok || fail
+			# $(eval) is needed since $($COMMAND) may contain $(")
+			line=$(eval $COMMAND | tr '\033\n' '~@')
+			[[ $(echo "$line" | sed -re "$REGEX") == "1" ]] && ok || fail
 		done
 	done
 done
@@ -524,62 +523,62 @@ done
 
 REGEX="s/^$regex_prio\([0-9[:space:]]{5,}\)[[:print:]]*\([[:print:]]*\)$/1/g"
 LOG_DETAILS="testing if \"$format\" print format works"
-line=`$cmd_prefix $format`
-[[ `echo "$line" | sed -re $REGEX` == "1" ]] && ok || fail
+line=$($cmd_prefix $format)
+[[ $(echo "$line" | sed -re $REGEX) == "1" ]] && ok || fail
 
 format="tag"
 REGEX="s/^$regex_prio\/[[:print:]]{9,}:\s{1}[[:print:]]*$/1/g"
 LOG_DETAILS="testing if \"$format\" print format works"
-line=`$cmd_prefix $format`
-[[ `echo "$line" | sed -re $REGEX` == "1" ]] && ok || fail
+line=$($cmd_prefix $format)
+[[ $(echo "$line" | sed -re $REGEX) == "1" ]] && ok || fail
 
 format="thread"
 REGEX="s/^$regex_prio\($regex_pidtid\)\s{1}[[:print:]]*$/1/g"
 LOG_DETAILS="testing if \"$format\" print format works"
-line=`$cmd_prefix $format`
-[[ `echo "$line" | sed -re $REGEX` == "1" ]] && ok || fail
+line=$($cmd_prefix $format)
+[[ $(echo "$line" | sed -re $REGEX) == "1" ]] && ok || fail
 
 format="time"
 REGEX="s/^$regex_time.[0-9]{3}$regex_timezone\s{1}$regex_prio\/[[:print:]]{8,}\([0-9[:space:]]{5,}\):\s{1}[[:print:]]*$/1/g"
 LOG_DETAILS="testing if \"$format\" print format works"
-line=`$cmd_prefix $format`
-[[ `echo "$line" | sed -re $REGEX` == "1" ]] && ok || fail
+line=$($cmd_prefix $format)
+[[ $(echo "$line" | sed -re $REGEX) == "1" ]] && ok || fail
 
 format="threadtime"
 REGEX="s/^$regex_time.[0-9]{3}$regex_timezone\s{1}$regex_prio\/[[:print:]]{8,}\($regex_pidtid\):\s{1}[[:print:]]*$/1/g"
 LOG_DETAILS="testing if \"$format\" print format works"
-line=`$cmd_prefix $format`
-[[ `echo "$line" | sed -re $REGEX` == "1" ]] && ok || fail
+line=$($cmd_prefix $format)
+[[ $(echo "$line" | sed -re $REGEX) == "1" ]] && ok || fail
 
 format="kerneltime"
 REGEX="s/^[0-9[:space:]]{1,}.[0-9]{3,}\s{1}$regex_prio\/[[:print:]]{8,}\($regex_pidtid\):\s{1}[[:print:]]*$/1/g"
 LOG_DETAILS="testing if \"$format\" print format works"
-line=`$cmd_prefix $format`
-[[ `echo "$line" | sed -re $REGEX` == "1" ]] && ok || fail
+line=$($cmd_prefix $format)
+[[ $(echo "$line" | sed -re $REGEX) == "1" ]] && ok || fail
 
 format="recv_realtime"
 REGEX="s/^$regex_time.[0-9]{3}\s{1}$regex_prio\/[[:print:]]{8,}\($regex_pidtid\):\s{1}[[:print:]]*$/1/g"
 LOG_DETAILS="testing if \"$format\" print format works"
-line=`$cmd_prefix $format`
-[[ `echo "$line" | sed -re $REGEX` == "1" ]] && ok || fail
+line=$($cmd_prefix $format)
+[[ $(echo "$line" | sed -re $REGEX) == "1" ]] && ok || fail
 
 format="rwtime"
 REGEX="s/^$regex_time\s{1}\[[0-9[:space:]]{3,}.[0-9[:space:]]{3,}\]\s{1}$regex_prio\/[[:print:]]{8,}\($regex_pidtid\):\s{1}[[:print:]]*$/1/g"
 LOG_DETAILS="testing if \"$format\" print format works"
-line=`$cmd_prefix $format`
-[[ `echo "$line" | sed -re $REGEX` == "1" ]] && ok || fail
+line=$($cmd_prefix $format)
+[[ $(echo "$line" | sed -re $REGEX) == "1" ]] && ok || fail
 
 format="long"
 REGEX="s/^\[\s{1}$regex_time.[0-9]{3,}\s{1}$regex_prio\/[[:print:]]{8,}\s{1}$regex_pidtid\]@[[:print:]]+@$/1/g"
 LOG_DETAILS="testing if \"$format\" print format works"
-line=`$cmd_prefix $format`
-[[ `echo "$line" | tr '\n' '@' | sed -re $REGEX` == "1" ]] && ok || fail
+line=$($cmd_prefix $format)
+[[ $(echo "$line" | tr '\n' '@' | sed -re $REGEX) == "1" ]] && ok || fail
 
 format="brief"
 REGEX="s/^$regex_prio\/[[:print:]]{8,}\([0-9[:space:]]{5,}\):\s{1}[[:print:]]*$/1/g"
 LOG_DETAILS="testing if \"$format\" print format works"
-line=`$cmd_prefix $format`
-[[ `echo "$line" | sed -re $REGEX` == "1" ]] && ok || fail
+line=$($cmd_prefix $format)
+[[ $(echo "$line" | sed -re $REGEX) == "1" ]] && ok || fail
 
 format="json"
 if [[ "$type" == "pipe" ]]; then
@@ -588,17 +587,17 @@ else
 	REGEX="s/^\{\"priority\":\"(verbose|debug|info|warning|error|fatal|silent)\",\"pid\":[1-9][0-9]*,\"tid\":[1-9][0-9]*,\"sent_real\":\"[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}$regex_timezone\",\"tag\":\"[[:print:]]*\",\"msg\":\"[[:print:]]*\"\}$/1/g"
 fi
 LOG_DETAILS="testing if \"$format\" print format works"
-line=`$cmd_prefix $format`
-[[ `echo "$line" | sed -re $REGEX` == "1" ]] && ok || fail
+line=$($cmd_prefix $format)
+[[ $(echo "$line" | sed -re $REGEX) == "1" ]] && ok || fail
 
 format="raw"
 LOG_DETAILS="testing if \"$format\" print format works"
 dlogutil -c
 dlogsend -b main -t DLOG_TESTSUITE rawformatTEST
-line=`$cmd_prefix $format`
+line=$($cmd_prefix $format)
 [[ "$line" == "rawformatTEST" ]] && ok || fail
 
-if [ $quick -ne 1 ]; then
+if [ "$quick" -ne 1 ]; then
 	LOG_DETAILS="testing if dlogsend -d works"
 	dlogutil -c
 	dlogsend -b main -c 9999 -d 4 -f 7 -t DLOG_TESTSUITE "hi" &
@@ -606,10 +605,10 @@ if [ $quick -ne 1 ]; then
 	sleep 10
 	kill $DLOGSEND_PID
 	# In 10 seconds, 3 cycles 7 logs each should have happened.
-	[[ "$(dlogutil -d DLOG_TESTSUITE | wc -l)" -eq 21 ]] && ok || fail
+	[ "$(dlogutil -d DLOG_TESTSUITE | wc -l)" -eq 21 ] && ok || fail
 fi
 
-if [ $type == "pipe" ]; then
+if [ "$type" = "pipe" ]; then
 	for format in raw brief long; do
 		for i in {1..8} 10 15 20 25 {513..520}; do
 			LOG_DETAILS="testing if padding works correctly (format $format/count $i)"
@@ -639,25 +638,25 @@ fi
 LOG_DETAILS="testing if KMSG works in the default format"
 # We check if the command returns at least 100 logs. This seems to be a safe value.
 # Feel free to change it to a reasonable yet lower value if the test happens to fail otherwise.
-[[ "$(dlogutil -db kmsg | wc -l)" -gt 100 ]] && ok || fail
+[ "$(dlogutil -db kmsg | wc -l)" -gt 100 ] && ok || fail
 
-if [ $quick -ne 1 ]; then
+if [ "$quick" -ne 1 ]; then
 	LOG_DETAILS="testing if KMSG works in the raw format"
-	last_dmesg=`dmesg | tail -n1 | sed -re "s/^\[[ 0-9]{5,}\.[0-9]{6}\] (.*)$/\1/g"`
+	last_dmesg=$(dmesg | tail -n1 | sed -re "s/^\[[ 0-9]{5,}\.[0-9]{6}\] (.*)$/\1/g")
 	sleep 1 # To make sure dlog has already parsed the log
 	dlogutil -db kmsg -v raw | grep -Fm1 "$last_dmesg" >/dev/null && ok || fail
 
 	LOG_DETAILS="testing if pid filtering works"
 	dlogsend -b main -t DLOG_TESTSUITE pidTEST &
 	sleep 1
-	line=`dlogutil -v raw -d --pid $!`
-	[[ "$line" == "pidTEST" ]] && ok || fail
+	line=$(dlogutil -v raw -d --pid $!)
+	[ "$line" = "pidTEST" ] && ok || fail
 
 	LOG_DETAILS="testing if tid filtering works"
 	dlogsend -b main -t DLOG_TESTSUITE tidTEST &
 	sleep 1
-	line=`dlogutil -v raw -d --tid $!` #dlogsend is a single threaded app so tid is the same as pid
-	[[ "$line" == "tidTEST" ]] && ok || fail
+	line=$(dlogutil -v raw -d --tid $!) #dlogsend is a single threaded app so tid is the same as pid
+	[ "$line" = "tidTEST" ] && ok || fail
 
 	mv $DLOG_CONFIG_PATH $DLOG_CONFIG_PATH.1
 	LOG_DETAILS="testing if secure logging works (1/2)"
@@ -668,8 +667,8 @@ if [ $quick -ne 1 ]; then
 	sleep 1
 	dlogsend -b main -t DLOG_TESTSUITE insecure &
 	sleep 1
-	line=`dlogutil -v raw -d | head -n1`
-	[[ "$line" == "secure" ]] && ok || fail
+	line=$(dlogutil -v raw -d | head -n1)
+	[ "$line" = "secure" ] && ok || fail
 	LOG_DETAILS="testing if secure logging works (2/2)"
 	grep -v enable_secure_logs $DLOG_CONFIG_PATH.1 > $DLOG_CONFIG_PATH
 	echo "enable_secure_logs=0" >> $DLOG_CONFIG_PATH
@@ -678,8 +677,8 @@ if [ $quick -ne 1 ]; then
 	sleep 1
 	dlogsend -b main -t DLOG_TESTSUITE insecure &
 	sleep 1
-	line=`dlogutil -v raw -d | head -n1`
-	[[ "$line" == "insecure" ]] && ok || fail
+	line=$(dlogutil -v raw -d | head -n1)
+	[ "$line" = "insecure" ] && ok || fail
 	mv $DLOG_CONFIG_PATH.1 $DLOG_CONFIG_PATH
 fi
 
@@ -688,84 +687,84 @@ dlogsend -b main -t DLOG_TESTSUITE_TAG1 -pI tagTEST1
 dlogsend -b main -t DLOG_TESTSUITE_TAG2 -pF tagTEST2
 
 LOG_DETAILS="testing if tag filtering works (1/8)"
-[[ `dlogutil -dv raw 'DLOG_TESTSUITE_TAG0' | wc -l` -eq 1 ]] && ok || fail
+[ "$(dlogutil -dv raw 'DLOG_TESTSUITE_TAG0' | wc -l)" -eq 1 ] && ok || fail
 LOG_DETAILS="testing if tag filtering works (2/8)"
-[[ `dlogutil -dv raw 'DLOG_TESTSUITE_TAG1' | wc -l` -eq 1 ]] && ok || fail
+[ "$(dlogutil -dv raw 'DLOG_TESTSUITE_TAG1' | wc -l)" -eq 1 ] && ok || fail
 LOG_DETAILS="testing if tag filtering works (3/8)"
-[[ `dlogutil -dv raw 'DLOG_TESTSUITE_TAG' | wc -l` -eq 0 ]] && ok || fail
+[ "$(dlogutil -dv raw 'DLOG_TESTSUITE_TAG' | wc -l)" -eq 0 ] && ok || fail
 LOG_DETAILS="testing if tag filtering works (4/8)"
-[[ `dlogutil -dv raw 'DLOG_TESTSUITE_TAG*' | wc -l` -eq 3 ]] && ok || fail
+[ "$(dlogutil -dv raw 'DLOG_TESTSUITE_TAG*' | wc -l)" -eq 3 ] && ok || fail
 LOG_DETAILS="testing if tag filtering works (5/8)"
-[[ `dlogutil -dv raw 'DLOG_TESTSUITE_TAG*:I' | wc -l` -eq 3 ]] && ok || fail
+[ "$(dlogutil -dv raw 'DLOG_TESTSUITE_TAG*:I' | wc -l)" -eq 3 ] && ok || fail
 LOG_DETAILS="testing if tag filtering works (6/8)"
-[[ `dlogutil -dv raw 'DLOG_TESTSUITE_TAG*:W' | wc -l` -eq 1 ]] && ok || fail
+[ "$(dlogutil -dv raw 'DLOG_TESTSUITE_TAG*:W' | wc -l)" -eq 1 ] && ok || fail
 LOG_DETAILS="testing if tag filtering works (7/8)"
-[[ `dlogutil -dv raw 'DLOG_TESTSUITE_SAMSUNG' | wc -l` -eq 0 ]] && ok || fail
+[ "$(dlogutil -dv raw 'DLOG_TESTSUITE_SAMSUNG' | wc -l)" -eq 0 ] && ok || fail
 LOG_DETAILS="testing if tag filtering works (8/8)"
-[[ `dlogutil -dv raw 'DLOG_TESTSUITE_SAMSUNG*' | wc -l` -eq 0 ]] && ok || fail
+[ "$(dlogutil -dv raw 'DLOG_TESTSUITE_SAMSUNG*' | wc -l)" -eq 0 ] && ok || fail
 
-if [ "$TEST_DYNAMIC_FILTERS" == "true" ]; then
+if [ "$TEST_DYNAMIC_FILTERS" = "true" ]; then
 	LOG_DETAILS="testing if limiter and runtime filtering works"
 	dlogutil -c -b radio
 	test_filters
-	[ $(dlogutil -d -b radio | wc -l) -eq 12 ] && ok || fail
+	[ "$(dlogutil -d -b radio | wc -l)" -eq 12 ] && ok || fail
 
 	LOG_DETAILS="testing proper SMACK label for dynamic config file location"
 	ORIG_FILTERS_DIR=$(cat $ORIGINAL_CONFIG_PATH | grep dynamic_config_path | awk -F "=" '{print $2}')
-	[ $(ls -dZ $ORIG_FILTERS_DIR | awk -F " " '{print $1}') == "System::Shared" ] && ok || fail
+	[ `ls -dZ $ORIG_FILTERS_DIR | awk -F " " '{print $1}'` = "System::Shared" ] && ok || fail
 
-	if [ $quick -ne 1 ]; then
+	if [ "$quick" -ne 1 ]; then
 		# This creates a process which will wait for SIGCONT and then spam logs. We know its PID, so we can add
 		# PID-based limits and see what happens.
 		sh -c 'kill -s STOP $$; exec dlogsend -b main -c 100 "Pid test"' &
 		DLOGSEND_PID=$!
-		while [[ $(cut -d ' ' -f 3 < /proc/$DLOGSEND_PID/stat) != "T" ]]; do :; done
+		while [ "$(cut -d ' ' -f 3 < /proc/$DLOGSEND_PID/stat)" != "T" ]; do :; done
 		dlogctl --pid $DLOGSEND_PID -s deny
 		kill -s CONT $DLOGSEND_PID
 		wait $DLOGSEND_PID
 		LOG_DETAILS="testing if PID limiting works (1/14)"
-		[[ $(dlogutil --pid $DLOGSEND_PID -d | grep -v blocked | wc -l) -eq 0 ]] && ok || fail
+		[ "$(dlogutil --pid $DLOGSEND_PID -d | grep -v blocked | wc -l)" -eq 0 ] && ok || fail
 		LOG_DETAILS="testing if PID limiting works (2/14)"
-		[[ $(dlogutil --pid $DLOGSEND_PID -d | grep blocked | wc -l) -eq 1 ]] && ok || fail
+		[ "$(dlogutil --pid $DLOGSEND_PID -d | grep blocked | wc -l)" -eq 1 ] && ok || fail
 		LOG_DETAILS="testing if PID limiting works (3/14)"
-		[[ $(dlogctl --pid $DLOGSEND_PID -g) == "Denied" ]] && ok || fail
+		[ "$(dlogctl --pid $DLOGSEND_PID -g)" = "Denied" ] && ok || fail
 		LOG_DETAILS="testing if PID limiting works (4/14)"
 		dlogctl -g | grep -q "Denied for $DLOGSEND_PID" && ok || fail
 
 		sh -c 'kill -s STOP $$; exec dlogsend -b main -c 100 "Pid test"' &
 		DLOGSEND_PID=$!
-		while [[ $(cut -d ' ' -f 3 < /proc/$DLOGSEND_PID/stat) != "T" ]]; do :; done
+		while [ "$(cut -d ' ' -f 3 < /proc/$DLOGSEND_PID/stat)" != "T" ]; do :; done
 		dlogctl --pid $DLOGSEND_PID -s 25
 		kill -s CONT $DLOGSEND_PID
 		wait $DLOGSEND_PID
 		LOG_DETAILS="testing if PID limiting works (5/14)"
-		[[ $(dlogutil --pid $DLOGSEND_PID -d | grep -v blocked | wc -l) -eq 25 ]] && ok || fail
+		[ "$(dlogutil --pid $DLOGSEND_PID -d | grep -v blocked | wc -l)" -eq 25 ] && ok || fail
 		LOG_DETAILS="testing if PID limiting works (6/14)"
-		[[ $(dlogutil --pid $DLOGSEND_PID -d | grep blocked | wc -l) -eq 1 ]] && ok || fail
+		[ "$(dlogutil --pid $DLOGSEND_PID -d | grep blocked | wc -l)" -eq 1 ] && ok || fail
 		LOG_DETAILS="testing if PID limiting works (7/14)"
-		[[ $(dlogctl --pid $DLOGSEND_PID -g) == '25 logs/min' ]] && ok || fail
+		[ "$(dlogctl --pid $DLOGSEND_PID -g)" = '25 logs/min' ] && ok || fail
 		LOG_DETAILS="testing if PID limiting works (8/14)"
 		dlogctl -g | grep -q "25 logs/min for $DLOGSEND_PID" && ok || fail
 
 		sh -c 'kill -s STOP $$; exec dlogsend -b main -c 100 "Pid test"' &
 		DLOGSEND_PID=$!
-		while [[ $(cut -d ' ' -f 3 < /proc/$DLOGSEND_PID/stat) != "T" ]]; do :; done
+		while [ "$(cut -d ' ' -f 3 < /proc/$DLOGSEND_PID/stat)" != "T" ]; do :; done
 		dlogctl --pid $DLOGSEND_PID -s allow
 		kill -s CONT $DLOGSEND_PID
 		wait $DLOGSEND_PID
 		LOG_DETAILS="testing if PID limiting works (9/14)"
-		[[ $(dlogutil --pid $DLOGSEND_PID -d | grep -v blocked | wc -l) -eq 100 ]] && ok || fail
+		[ "$(dlogutil --pid $DLOGSEND_PID -d | grep -v blocked | wc -l)" -eq 100 ] && ok || fail
 		LOG_DETAILS="testing if PID limiting works (10/14)"
-		[[ $(dlogutil --pid $DLOGSEND_PID -d | grep blocked | wc -l) -eq 0 ]] && ok || fail
+		[ "$(dlogutil --pid $DLOGSEND_PID -d | grep blocked | wc -l)" -eq 0 ] && ok || fail
 		LOG_DETAILS="testing if PID limiting works (11/14)"
-		[[ $(dlogctl --pid $DLOGSEND_PID -g) == 'Unlimited' ]] && ok || fail
+		[ "$(dlogctl --pid $DLOGSEND_PID -g)" = 'Unlimited' ] && ok || fail
 		LOG_DETAILS="testing if PID limiting works (12/14)"
 		dlogctl -g | grep -q "Unlimited for $DLOGSEND_PID" && ok || fail
 
 		echo "qos_refresh_rate_s=5" > "$RUNTIME_FILTERS_DIR/69-refresh-rate.conf"
 		sh -c 'kill -s STOP $$; exec dlogsend -b main -c 15 -d 1 "Pid test"' &
 		DLOGSEND_PID=$!
-		while [[ $(cut -d ' ' -f 3 < /proc/$DLOGSEND_PID/stat) != "T" ]]; do :; done
+		while [ "$(cut -d ' ' -f 3 < /proc/$DLOGSEND_PID/stat)" != "T" ]; do :; done
 		dlogctl --pid $DLOGSEND_PID -s 2
 		kill -s CONT $DLOGSEND_PID
 		wait $DLOGSEND_PID
@@ -773,9 +772,9 @@ if [ "$TEST_DYNAMIC_FILTERS" == "true" ]; then
 		LOG_DETAILS="testing if PID limiting works (13/14)"
 		# In each 5 second period, 5 logs are sent, so there are 3 periods.
 		# 2 logs from each period are allowed.
-		[[ $(dlogutil --pid $DLOGSEND_PID -d | grep -v blocked | wc -l) -eq 6 ]] && ok || fail
+		[ "$(dlogutil --pid $DLOGSEND_PID -d | grep -v blocked | wc -l)" -eq 6 ] && ok || fail
 		LOG_DETAILS="testing if PID limiting works (14/14)"
-		[[ $(dlogutil --pid $DLOGSEND_PID -d | grep blocked | wc -l) -eq 3 ]] && ok || fail
+		[ "$(dlogutil --pid $DLOGSEND_PID -d | grep blocked | wc -l)" -eq 3 ] && ok || fail
 
 		# TODO: HACK ALERT!
 		# The following QoS tests make perfect sense for the pipe backend, since we kill the already
@@ -786,7 +785,7 @@ if [ "$TEST_DYNAMIC_FILTERS" == "true" ]; then
 		# completely disabled in the config file -- this way, the tests would be completely uniform.
 		PREQOS_CONFIG_PATH=$DLOG_CONFIG_PATH
 		DLOG_CONFIG_PATH="@datadir@/dlog-$type.conf.qos"
-		if [ $type == "pipe" ]; then
+		if [ "$type" = "pipe" ]; then
 			kill $LOGGER > /dev/null
 			sleep 1
 		fi
@@ -796,10 +795,10 @@ if [ "$TEST_DYNAMIC_FILTERS" == "true" ]; then
 
 		dlogsend -b main -t DLOG_QOS_TEST0 -c 30 -d 1 -f 2 "A normal app that just wants to log"
 		LOG_DETAILS="testing if QoS works (1/4)"
-		[[ $(dlogutil -d DLOG_QOS_TEST0 | grep -v blocked | wc -l) -eq 30 ]] && ok || fail
+		[ "$(dlogutil -d DLOG_QOS_TEST0 | grep -v blocked | wc -l)" -eq 30 ] && ok || fail
 		kill $LOGGER > /dev/null
 		sleep 1
-		if [ $type == "logger" ]; then
+		if [ "$type" = "logger" ]; then
 			dlogutil -cb main
 		fi
 		dlog_logger -b 99 -t 0 &
@@ -808,10 +807,10 @@ if [ "$TEST_DYNAMIC_FILTERS" == "true" ]; then
 
 		dlogsend -b main -t DLOG_QOS_TEST1 -c 300 -d 1 -f 20 "Some log spam"
 		LOG_DETAILS="testing if QoS works (2/4)"
-		[[ $(dlogutil -d DLOG_QOS_TEST1 | grep -v blocked | wc -l) -le 180 ]] && ok || fail
+		[ "$(dlogutil -d DLOG_QOS_TEST1 | grep -v blocked | wc -l)" -le 180 ] && ok || fail
 		kill $LOGGER > /dev/null
 		sleep 1
-		if [ $type == "logger" ]; then
+		if [ "$type" = "logger" ]; then
 			dlogutil -cb main
 		fi
 		dlog_logger -b 99 -t 0 &
@@ -823,14 +822,14 @@ if [ "$TEST_DYNAMIC_FILTERS" == "true" ]; then
 		dlogsend -b main -t DLOG_QOS_TEST3 -c 270 -d 1 -f 18 "Some log spam"
 		wait $DLOGSEND_PID
 		LOG_DETAILS="testing if QoS works (3/4)"
-		[[ $(dlogutil -d DLOG_QOS_TEST2 DLOG_QOS_TEST3 | grep -v blocked | wc -l) -le 180 ]] && ok || fail
+		[ "$(dlogutil -d DLOG_QOS_TEST2 DLOG_QOS_TEST3 | grep -v blocked | wc -l)" -le 180 ] && ok || fail
 		LOG_DETAILS="testing if QoS works (4/4)"
-		[[ $(dlogutil -d DLOG_QOS_TEST2 | grep -v blocked | wc -l) -gt 24 ]] && ok || fail
+		[ "$(dlogutil -d DLOG_QOS_TEST2 | grep -v blocked | wc -l)" -gt 24 ] && ok || fail
 
 		DLOG_CONFIG_PATH=$PREQOS_CONFIG_PATH
 		kill $LOGGER > /dev/null
 		sleep 1
-		if [ $type == "pipe" ]; then
+		if [ "$type" = "pipe" ]; then
 			dlog_logger -b 99 -t 0 &
 			LOGGER=$!
 			sleep 1
@@ -843,7 +842,7 @@ fi
 LOG_DETAILS="testing if libdlogutil clears the buffer correctly"
 test_libdlogutil clear $LIBDLOGUTIL_CORRECT_PID $type && ok || fail
 
-if [ $quick -ne 1 ]; then
+if [ "$quick" -ne 1 ]; then
 	LOG_DETAILS="testing if the library works with multithreaded app"
 	dlogutil -f $TESTDIR/dlog_mt_test &
 	MT_TEST=$!
@@ -863,7 +862,7 @@ if [ $quick -ne 1 ]; then
 	# a single message. This gets us 5 groups of logs separated by a second; there are about 200 logs in each
 	# group, sent about at the same time.
 	(
-		for i in `seq 1 $SPAWN_CNT`; do
+		for i in $(seq 1 $SPAWN_CNT); do
 			delay=$(( (RANDOM) % 5 ))
 			( sleep $delay && dlogsend -b main -t DLOG_TESTSUITE $delay ) &
 		done
@@ -883,12 +882,12 @@ if [ $quick -ne 1 ]; then
 		prev_line=""
 
 		# collect data and analyze timestamps
-		lines=`dlogutil -b main -d -v $format`
+		lines=$(dlogutil -b main -d -v $format)
 		while read line; do
 			# filter out empty lines in "long" format
 			[ -z "$line" ] && continue
 			# filter out non-timestamp lines in "long" format
-			if [ $format == "long" ] && [ "`echo "$line" | sed -re 's/^\[[[:print:]]*\]$/line_ok/g'`" != "line_ok" ]; then
+			if [ "$format" = "long" ] && [ "$(echo "$line" | sed -re 's/^\[[:print:]*\]$/line_ok/g')" != "line_ok" ]; then
 				continue
 			fi
 
@@ -907,42 +906,6 @@ if [ $quick -ne 1 ]; then
 
 		[ -z "$unsorted" ] && ok || fail
 	done
-
-	sleep 3
-
-	if [ $type == "pipe" ]; then
-
-		# spawn a new daemon with limited FDs for the FD checks
-		kill $LOGGER > /dev/null
-		sleep 1
-		ULIMIT_CURRENT=`ulimit -n`
-		ulimit -n 30
-		dlog_logger &> /dev/null &
-		LOGGER=$!
-		ulimit -n $ULIMIT_CURRENT
-
-		LOG_DETAILS="checking if the daemon closes util connections without logs stored"
-		run_utils
-		sleep 3
-		[ `ls -la /proc/$LOGGER/fd | grep fifo | wc -l` -eq 0 -a `ls -la /proc/$LOGGER/fd | grep pipe | wc -l` -eq 0 ] && ok || fail
-
-		LOG_DETAILS="checking if the daemon closes libdlog connections"
-		for i in {1..30}; do
-			dlogsend -c $i -b main -p e -t FOO BAR BAZ &
-		done
-		dlogsend -c 99999 -b main -p e -t FOO BAR BAZ &
-		sleep 0.5
-		kill $!
-		sleep 1.5
-		[ `ls -la /proc/$LOGGER/fd | grep fifo | wc -l` -eq 0 -a `ls -la /proc/$LOGGER/fd | grep pipe | wc -l` -eq 0 ] && ok || fail
-
-		LOG_DETAILS="checking if the daemon closes util connections with logs stored"
-		run_utils
-		sleep 0.5
-		killall dlogutil &> /dev/null
-		sleep 1.5
-		[ `ls -la /proc/$LOGGER/fd | grep fifo | wc -l` -eq 0 -a `ls -la /proc/$LOGGER/fd | grep pipe | wc -l` -eq 0 ] && ok || fail
-	fi
 fi
 
 # show results, clean up and return an exit code
@@ -950,13 +913,13 @@ fi
 echo "$OKS / $TOTAL tests passed"
 echo "$FAILS / $TOTAL tests failed"
 
-if [ $quick -eq 1 ]; then
+if [ "$quick" -eq 1 ]; then
 	echo "WARNING: quick mode!"
 	echo "About 20% slowest running tests are disabled. Some functionality might be untested."
 	echo "Rerun with '$type' instead of '${type}_quick' to run all tests."
 fi
 
-[[ "$FAILS" -eq 0 ]]
+[ "$FAILS" -eq 0 ]
 # THE LINE ABOVE MUST STAY THE LAST COMMAND IN THE FILE!
 # This is because it is used to pass the exit code. If another command
 # is executed after it, its exit code will be propagated instead.
-- 
2.7.4