diff --git a/tests/01-known-values.sh b/tests/01-known-values.sh
index 68848889..4b3b21b9 100644
--- a/tests/01-known-values.sh
+++ b/tests/01-known-values.sh
@@ -11,7 +11,7 @@ reference_small="${scriptdir}/verify-strings/test_scrypt_small.good"
 ### Actual command
 scenario_cmd() {
 	# Run the binary which tests known input/output strings.
-	setup_check_variables "test_scrypt"
+	setup_check "test_scrypt"
 	(
 		${c_valgrind_cmd} "${bindir}/tests/verify-strings/test_scrypt" \
 			"${SMALLMEM:-0}" 1> "${test_output}"
@@ -19,7 +19,7 @@ scenario_cmd() {
 	)
 
 	# The generated values should match the known good values.
-	setup_check_variables "test_scrypt output against reference"
+	setup_check "test_scrypt output against reference"
 	if [ "${SMALLMEM:-0}" -gt "0" ]; then
 		cmp -s "${test_output}" "${reference_small}"
 	else
diff --git a/tests/02-decrypt-reference-file.sh b/tests/02-decrypt-reference-file.sh
index 4deb0825..0f2849d6 100644
--- a/tests/02-decrypt-reference-file.sh
+++ b/tests/02-decrypt-reference-file.sh
@@ -11,7 +11,7 @@ decrypted_badpass_log="${s_basename}-decrypt-badpass.log"
 
 scenario_cmd() {
 	# Decrypt a reference file.
-	setup_check_variables "scrypt dec"
+	setup_check "scrypt dec"
 	(
 		echo "${password}" | ${c_valgrind_cmd} "${bindir}/scrypt" \
 		    dec -P "${encrypted_reference_file}"		\
@@ -21,18 +21,18 @@ scenario_cmd() {
 	)
 
 	# The decrypted reference file should match the reference.
-	setup_check_variables "scrypt dec output against reference"
+	setup_check "scrypt dec output against reference"
 	cmp -s "${decrypted_reference_file}" "${reference_file}"
 	echo $? > "${c_exitfile}"
 
 	# We should not have any output on stderr.
-	setup_check_variables "scrypt dec no stderr"
+	setup_check "scrypt dec no stderr"
 	test -s "${decrypted_reference_file_stderr}"
 	expected_exitcode 1 $? > "${c_exitfile}"
 
 	# Attempt to decrypt the reference file with an incorrect passphrase.
 	# We want this command to fail with 1.
-	setup_check_variables "scrypt dec bad passphrase"
+	setup_check "scrypt dec bad passphrase"
 	(
 		echo "bad-pass" | ${c_valgrind_cmd} "${bindir}/scrypt"	\
 		    dec -P "${encrypted_reference_file}"		\
@@ -42,7 +42,7 @@ scenario_cmd() {
 	)
 
 	# We should have received an error message.
-	setup_check_variables "scrypt dec bad passphrase error"
+	setup_check "scrypt dec bad passphrase error"
 	if grep -q "scrypt: Passphrase is incorrect" \
 	    "${decrypted_badpass_log}"; then
 		echo "0"
@@ -51,7 +51,7 @@ scenario_cmd() {
 	fi > "${c_exitfile}"
 
 	# We should not have created a file.
-	setup_check_variables "scrypt dec bad passphrase no file"
+	setup_check "scrypt dec bad passphrase no file"
 	if [ -e "${decrypted_badpass_file}" ]; then
 		echo "1"
 	else
diff --git a/tests/03-encrypt-decrypt-file.sh b/tests/03-encrypt-decrypt-file.sh
index c1430ecf..0454f8e4 100644
--- a/tests/03-encrypt-decrypt-file.sh
+++ b/tests/03-encrypt-decrypt-file.sh
@@ -8,7 +8,7 @@ decrypted_file="${s_basename}-attempt.txt"
 
 scenario_cmd() {
 	# Encrypt a file.  Use --passphrase dev:stdin-once instead of -P.
-	setup_check_variables "scrypt enc"
+	setup_check "scrypt enc"
 	(
 		echo "${password}" | ${c_valgrind_cmd} "${bindir}/scrypt" \
 		    enc --passphrase dev:stdin-once -t 1		\
@@ -20,12 +20,12 @@ scenario_cmd() {
 	# We cannot check against the "reference" encrypted file, because
 	# encrypted files include random salt.  If successful, don't delete
 	# ${encrypted_file} yet; we need it for the next test.
-	setup_check_variables "scrypt enc random salt"
+	setup_check "scrypt enc random salt"
 	cmp -s "${encrypted_file}" "${reference_file}"
 	expected_exitcode 1 $? > "${c_exitfile}"
 
 	# Decrypt the file we just encrypted.
-	setup_check_variables "scrypt enc decrypt"
+	setup_check "scrypt enc decrypt"
 	(
 		echo "${password}" | ${c_valgrind_cmd} "${bindir}/scrypt" \
 		    dec -P "${encrypted_file}" "${decrypted_file}"
@@ -33,7 +33,7 @@ scenario_cmd() {
 	)
 
 	# The decrypted file should match the reference.
-	setup_check_variables "scrypt enc decrypt output against reference"
+	setup_check "scrypt enc decrypt output against reference"
 	cmp -s "${decrypted_file}" "${reference_file}"
 	echo $? > "${c_exitfile}"
 }
diff --git a/tests/04-force-resources.sh b/tests/04-force-resources.sh
index c7ca3efa..6ab9974e 100644
--- a/tests/04-force-resources.sh
+++ b/tests/04-force-resources.sh
@@ -9,7 +9,7 @@ longwait_failed_log="${s_basename}-failed.log"
 
 scenario_cmd() {
 	# Encrypt file which should take a long time to decrypt.
-	setup_check_variables "scrypt enc 10 seconds"
+	setup_check "scrypt enc 10 seconds"
 	(
 		echo "${password}" | ${c_valgrind_cmd} "${bindir}/scrypt" \
 			enc -P -t 10 "${reference_file}"		\
@@ -19,7 +19,7 @@ scenario_cmd() {
 
 	# Attempt to decrypt it with limited time.  We want this
 	# command to fail, so we negate the normal return code.
-	setup_check_variables "scrypt dec 1 second"
+	setup_check "scrypt dec 1 second"
 	(
 		echo "${password}" | ${c_valgrind_cmd} "${bindir}/scrypt" \
 			dec -P -t 1 "${longwait_encrypted_file}"	\
@@ -29,13 +29,13 @@ scenario_cmd() {
 	)
 
 	# We should have received an error message.
-	setup_check_variables "scrypt dec 1 second error"
+	setup_check "scrypt dec 1 second error"
 	grep -q "scrypt: Decrypting file would take too much CPU time" \
 	    "${longwait_failed_log}"
 	echo "$?" > "${c_exitfile}"
 
 	# Attempt to decrypt it with limited time, but force success.
-	setup_check_variables "scrypt dec force"
+	setup_check "scrypt dec force"
 	(
 		echo "${password}" | ${c_valgrind_cmd} "${bindir}/scrypt" \
 			dec -P -t 1 -f "${longwait_encrypted_file}"	\
@@ -44,7 +44,7 @@ scenario_cmd() {
 	)
 
 	# The decrypted reference file should match the reference.
-	setup_check_variables "scrypt dec force output against reference"
+	setup_check "scrypt dec force output against reference"
 	cmp -s "${longwait_decrypted_file}" "${reference_file}"
 	echo $? > "${c_exitfile}"
 }
diff --git a/tests/05-system-scrypt-encrypt-decrypt.sh b/tests/05-system-scrypt-encrypt-decrypt.sh
index 2d684666..5370322f 100644
--- a/tests/05-system-scrypt-encrypt-decrypt.sh
+++ b/tests/05-system-scrypt-encrypt-decrypt.sh
@@ -12,13 +12,13 @@ scenario_cmd() {
 	if [ -z "${system_scrypt}" ]; then
 		printf "no suitable system scrypt: " 1>&2
 		# Inform test suite that we are skipping.
-		setup_check_variables "system scrypt skip"
+		setup_check "system scrypt skip"
 		echo "-1" > "${c_exitfile}"
 		return
 	fi
 
 	# Encrypt a file with our scrypt.
-	setup_check_variables "scrypt enc for system"
+	setup_check "scrypt enc for system"
 	(
 		echo "${password}" | ${c_valgrind_cmd} "${bindir}/scrypt" \
 		    enc -P -t 1 "${reference_file}" "${encrypted_file_1}"
@@ -27,7 +27,7 @@ scenario_cmd() {
 
 	# Use the system scrypt to decrypt the file we just
 	# encrypted. Don't use valgrind for this.
-	setup_check_variables "system scrypt dec"
+	setup_check "system scrypt dec"
 	(
 		echo "${password}" | ${system_scrypt}			\
 		    dec -P "${encrypted_file_1}" "${decrypted_file_1}"
@@ -35,13 +35,13 @@ scenario_cmd() {
 	)
 
 	# The decrypted file should match the reference.
-	setup_check_variables "system scrypt dec output against reference"
+	setup_check "system scrypt dec output against reference"
 	cmp -s "${decrypted_file_1}" "${reference_file}"
 	echo $? > "${c_exitfile}"
 
 	# Encrypt a file with the system scrypt.  Don't use
 	# valgrind for this.
-	setup_check_variables "system scrypt enc"
+	setup_check "system scrypt enc"
 	(
 		echo "${password}" | ${system_scrypt}			\
 		    enc -P -t 1 "${reference_file}" "${encrypted_file_2}"
@@ -49,7 +49,7 @@ scenario_cmd() {
 	)
 
 	# Use our scrypt to decrypt the file we just encrypted.
-	setup_check_variables "scrypt dec for system"
+	setup_check "scrypt dec for system"
 	(
 		echo "${password}" | ${c_valgrind_cmd} "${bindir}/scrypt" \
 		    dec -P "${encrypted_file_2}" "${decrypted_file_2}"
@@ -57,7 +57,7 @@ scenario_cmd() {
 	)
 
 	# The decrypted file should match the reference.
-	setup_check_variables "scrypt dec for system output against reference"
+	setup_check "scrypt dec for system output against reference"
 	cmp -s "${decrypted_file_2}" "${reference_file}"
 	echo $? > "${c_exitfile}"
 }
diff --git a/tests/06-decrypt-fail.sh b/tests/06-decrypt-fail.sh
index 0a02c8e3..b3abbf75 100644
--- a/tests/06-decrypt-fail.sh
+++ b/tests/06-decrypt-fail.sh
@@ -9,7 +9,7 @@ non_encoded_file_output="${s_basename}-nonfile.txt"
 scenario_cmd() {
 	# Attempt to decrypt a non-scrypt-encoded file.
 	# We want this command to fail with 1.
-	setup_check_variables "scrypt dec non-scrypt"
+	setup_check "scrypt dec non-scrypt"
 	(
 		echo "" | ${c_valgrind_cmd} "${bindir}/scrypt"		\
 		    dec -P "${non_encoded_file}"			\
@@ -19,13 +19,13 @@ scenario_cmd() {
 	)
 
 	# We should have received an error message.
-	setup_check_variables "scrypt dec non-scrypt error"
+	setup_check "scrypt dec non-scrypt error"
 	grep -q "scrypt: Input is not valid scrypt-encrypted block" \
 	    "${non_encoded_file_stderr}"
 	echo "$?" > "${c_exitfile}"
 
 	# We should not have created a file.
-	setup_check_variables "scrypt dec non-scrypt no file"
+	setup_check "scrypt dec non-scrypt no file"
 	if [ -e "${non_encoded_file_output}" ]; then
 		echo "1"
 	else
diff --git a/tests/07-passphrase-env.sh b/tests/07-passphrase-env.sh
index 80b98d12..03d137d8 100644
--- a/tests/07-passphrase-env.sh
+++ b/tests/07-passphrase-env.sh
@@ -11,7 +11,7 @@ decrypted_no_envvar_log="${s_basename}-decrypt-no-envvar.log"
 
 scenario_cmd() {
 	# Decrypt a reference file using --passphrase env:VAR.
-	setup_check_variables "scrypt dec env"
+	setup_check "scrypt dec env"
 	PASSPHRASE="${password}"					\
 	${c_valgrind_cmd} "${bindir}/scrypt"				\
 	    dec --passphrase env:PASSPHRASE				\
@@ -19,13 +19,13 @@ scenario_cmd() {
 	echo $? > "${c_exitfile}"
 
 	# The decrypted reference file should match the reference.
-	setup_check_variables "scrypt dec env output against reference"
+	setup_check "scrypt dec env output against reference"
 	cmp -s "${decrypted_reference_file}" "${reference_file}"
 	echo $? > "${c_exitfile}"
 
 	# Attempt to decrypt the reference file with a non-existent envvar.
 	# We want this command to fail with 1.
-	setup_check_variables "scrypt dec env none"
+	setup_check "scrypt dec env none"
 	${c_valgrind_cmd} "${bindir}/scrypt"				\
 	    dec --passphrase env:THIS_ENVVAR_DOES_NOT_EXIST		\
 	    "${encrypted_reference_file}" "${decrypted_reference_file}"	\
@@ -33,20 +33,20 @@ scenario_cmd() {
 	expected_exitcode 1 $? > "${c_exitfile}"
 
 	# We should have received an error message.
-	setup_check_variables "scrypt dec env none error"
+	setup_check "scrypt dec env none error"
 	grep -q								\
 	    "scrypt: Failed to read from \${THIS_ENVVAR_DOES_NOT_EXIST}" \
 	    "${decrypted_no_envvar_log}"
 	echo "$?" > "${c_exitfile}"
 
 	# We should not have created a file.
-	setup_check_variables "scrypt dec env no file"
+	setup_check "scrypt dec env no file"
 	test -e "${decrypted_badpass_file}"
 	expected_exitcode 1 $? > "${c_exitfile}"
 
 	# Attempt to decrypt the reference file with an incorrect passphrase.
 	# We want this command to fail with 1.
-	setup_check_variables "scrypt dec env bad"
+	setup_check "scrypt dec env bad"
 	PASSPHRASE="bad-pass"						\
 	${c_valgrind_cmd} "${bindir}/scrypt"				\
 	    dec --passphrase env:PASSPHRASE				\
@@ -55,11 +55,11 @@ scenario_cmd() {
 	expected_exitcode 1 $? > "${c_exitfile}"
 
 	# We should have received an error message.
-	setup_check_variables "scrypt dec env bad error"
+	setup_check "scrypt dec env bad error"
 	grep -q "scrypt: Passphrase is incorrect" "${decrypted_badpass_log}"
 	echo "$?" > "${c_exitfile}"
 
-	setup_check_variables "scrypt dec env bad no file"
+	setup_check "scrypt dec env bad no file"
 	# We should not have created a file.
 	test -e "${decrypted_badpass_file}"
 	expected_exitcode 1 $? > "${c_exitfile}"
diff --git a/tests/08-passphrase-file.sh b/tests/08-passphrase-file.sh
index 157324e6..1d1de088 100644
--- a/tests/08-passphrase-file.sh
+++ b/tests/08-passphrase-file.sh
@@ -16,20 +16,20 @@ scenario_cmd() {
 	echo "${password}" > "${passphrase_file}"
 
 	# Decrypt a reference file using --passphrase file:FILENAME.
-	setup_check_variables "scrypt dec file"
+	setup_check "scrypt dec file"
 	${c_valgrind_cmd} "${bindir}/scrypt"				\
 	    dec --passphrase file:"${passphrase_file}"			\
 	    "${encrypted_reference_file}" "${decrypted_reference_file}"
 	echo $? > "${c_exitfile}"
 
 	# The decrypted reference file should match the reference.
-	setup_check_variables "scrypt dec file output against reference"
+	setup_check "scrypt dec file output against reference"
 	cmp -s "${decrypted_reference_file}" "${reference_file}"
 	echo $? > "${c_exitfile}"
 
 	# Attempt to decrypt the reference file with a non-existent file.
 	# We want this command to fail with 1.
-	setup_check_variables "scrypt dec file none"
+	setup_check "scrypt dec file none"
 	${c_valgrind_cmd} "${bindir}/scrypt"				\
 	    dec --passphrase file:THIS_FILE_DOES_NOT_EXIST		\
 	    "${encrypted_reference_file}" "${decrypted_reference_file}"	\
@@ -37,19 +37,19 @@ scenario_cmd() {
 	expected_exitcode 1 $? > "${c_exitfile}"
 
 	# We should have received an error message.
-	setup_check_variables "scrypt dec file none error"
+	setup_check "scrypt dec file none error"
 	grep -q	"scrypt: fopen(THIS_FILE_DOES_NOT_EXIST)"		\
 	    "${decrypted_no_file_log}"
 	echo "$?" > "${c_exitfile}"
 
 	# We should not have created a file.
-	setup_check_variables "scrypt dec file none no file"
+	setup_check "scrypt dec file none no file"
 	test -e "${decrypted_badpass_file}"
 	expected_exitcode 1 $? > "${c_exitfile}"
 
 	# Attempt to decrypt the reference file with an incorrect passphrase.
 	# We want this command to fail with 1.
-	setup_check_variables "scrypt dec file bad"
+	setup_check "scrypt dec file bad"
 	echo "bad-pass" > "${bad_passphrase_file}"
 	${c_valgrind_cmd} "${bindir}/scrypt"				\
 	    dec --passphrase file:"${bad_passphrase_file}"		\
@@ -58,12 +58,12 @@ scenario_cmd() {
 	expected_exitcode 1 $? > "${c_exitfile}"
 
 	# We should have received an error message.
-	setup_check_variables "scrypt dec file bad error"
+	setup_check "scrypt dec file bad error"
 	grep -q "scrypt: Passphrase is incorrect" "${decrypted_badpass_log}"
 	echo "$?" > "${c_exitfile}"
 
 	# We should not have created a file.
-	setup_check_variables "scrypt dec file bad no file"
+	setup_check "scrypt dec file bad no file"
 	test -e "${decrypted_badpass_file}"
 	expected_exitcode 1 $? > "${c_exitfile}"
 }
diff --git a/tests/09-explicit-params.sh b/tests/09-explicit-params.sh
index 9a0e410b..7b75b05b 100644
--- a/tests/09-explicit-params.sh
+++ b/tests/09-explicit-params.sh
@@ -10,7 +10,7 @@ stderr_bad="${s_basename}-reference-bad.stderr"
 
 scenario_cmd() {
 	# Encrypt with manually-specified N, r, p.
-	setup_check_variables "scrypt enc Nrp"
+	setup_check "scrypt enc Nrp"
 	echo "${password}" | ${c_valgrind_cmd} "${bindir}/scrypt"	\
 	    enc -v --logN 12 -r 2 -p 3					\
 	    --passphrase dev:stdin-once					\
@@ -19,20 +19,20 @@ scenario_cmd() {
 	echo $? > "${c_exitfile}"
 
 	# Check that the options were used.
-	setup_check_variables "scrypt enc Nrp output N"
+	setup_check "scrypt enc Nrp output N"
 	grep -q "N = 4096" "${stderr}"
 	echo $? > "${c_exitfile}"
 
-	setup_check_variables "scrypt enc Nrp output r"
+	setup_check "scrypt enc Nrp output r"
 	grep -q "r = 2" "${stderr}"
 	echo $? > "${c_exitfile}"
 
-	setup_check_variables "scrypt enc Nrp output p"
+	setup_check "scrypt enc Nrp output p"
 	grep -q "p = 3" "${stderr}"
 	echo $? > "${c_exitfile}"
 
 	# Try to encrypt with badly-specified N, r, p; should fail.
-	setup_check_variables "scrypt enc Nrp bad"
+	setup_check "scrypt enc Nrp bad"
 	echo "${password}" | ${c_valgrind_cmd} "${bindir}/scrypt"	\
 	    enc -v --logN 2 -r 0 -p 0					\
 	    --passphrase dev:stdin-once					\
@@ -41,24 +41,24 @@ scenario_cmd() {
 	expected_exitcode 1 $? > "${c_exitfile}"
 
 	# Check that we got an error.
-	setup_check_variables "scrypt enc Nrp bad output"
+	setup_check "scrypt enc Nrp bad output"
 	grep -q "\--logN must be between 10 and 40 (inclusive)" "${stderr_bad}"
 	echo $? > "${c_exitfile}"
 
 	# Check that we can't partially set explicit parameters.
-	setup_check_variables "scrypt enc --logN only"
+	setup_check "scrypt enc --logN only"
 	${c_valgrind_cmd} "${bindir}/scrypt"				\
 	    enc --logN 12 "${reference_file}" 2>&1 |			\
 	    grep -q "If --logN is set, -r and -p must also be set"
 	echo $? > "${c_exitfile}"
 
-	setup_check_variables "scrypt enc -r only"
+	setup_check "scrypt enc -r only"
 	${c_valgrind_cmd} "${bindir}/scrypt"				\
 	    enc -r 12 "${reference_file}" 2>&1 |			\
 	    grep -q "If -r is set, --logN and -p must also be set"
 	echo $? > "${c_exitfile}"
 
-	setup_check_variables "scrypt enc -p only"
+	setup_check "scrypt enc -p only"
 	${c_valgrind_cmd} "${bindir}/scrypt"				\
 	    enc -p 12 "${reference_file}" 2>&1 |			\
 	    grep -q "If -p is set, --logN and -r must also be set"
diff --git a/tests/shared_test_functions.sh b/tests/shared_test_functions.sh
index ffedc094..d4a12924 100644
--- a/tests/shared_test_functions.sh
+++ b/tests/shared_test_functions.sh
@@ -24,7 +24,7 @@
 #   Look for a ${cmd} in $(ps).
 # - wait_while(func):
 #   Wait until ${func} returns non-zero.
-# - setup_check_variables(description, check_prev):
+# - setup_check(description, check_prev):
 #   Set up the below variables.
 # - expected_exitcode(expected, actual):
 #   Check if ${expected} matches ${actual}.
@@ -76,10 +76,14 @@ bindir=$(CDPATH='' cd -- "$(dirname -- "${1-.}")" && pwd -P)
 # Default value (should be set by tests).
 NO_EXITFILE=/dev/null
 
+# A non-zero value unlikely to be used as an exit code by the programs being
+# tested.
+valgrind_exit_code=108
 
-## _prepare_directory():
+
+## _prepdir():
 # Delete the previous test output directory, and create a new one.
-_prepare_directory() {
+_prepdir() {
 	if [ -d "${out}" ]; then
 		rm -rf "${out}"
 	fi
@@ -92,8 +96,8 @@ _prepare_directory() {
 ## find_system (cmd, args):
 # Look for ${cmd} in the ${PATH}, and ensure that it supports ${args}.
 find_system() {
-	cmd=$1
-	cmd_with_args="$1 ${2:-}"
+	_find_system_cmd=$1
+	_find_system_cmd_with_args="$1 ${2:-}"
 
 	# Sanity check.
 	if [ "$#" -gt "2" ]; then
@@ -102,26 +106,28 @@ find_system() {
 	fi
 
 	# Look for ${cmd}; the "|| true" and -} make this work with set -e.
-	system_binary=$(command -v "${cmd}") || true
-	if [ -z "${system_binary-}" ]; then
-		system_binary=""
-		printf "System %s not found.\n" "${cmd}" 1>&2
+	_find_system_binary=$(command -v "${_find_system_cmd}") || true
+	if [ -z "${_find_system_binary-}" ]; then
+		_find_system_binary=""
+		printf "System %s not found.\n" "${_find_system_cmd}" 1>&2
 	# If the command exists, check it ensures the ${args}.
-	elif ${cmd_with_args} 2>&1 >/dev/null |	\
+	elif ${_find_system_cmd_with_args} 2>&1 >/dev/null |	\
 	    grep -qE "(invalid|illegal) option"; then
-		system_binary=""
-		printf "Cannot use system %s; does not" "${cmd}" 1>&2
+		_find_system_binary=""
+		printf "Cannot use system %s; does not"		\
+		    "${_find_system_cmd}" 1>&2
 		printf " support necessary arguments.\n" 1>&2
 	fi
-	echo "${system_binary}"
+	echo "${_find_system_binary}"
 }
 
 ## has_pid (cmd):
 # Look for ${cmd} in ps; return 0 if ${cmd} exists.
 has_pid() {
-	cmd=$1
-	pid=$(ps -Aopid,args | grep -F "${cmd}" | grep -v "grep") || true
-	if [ -n "${pid}" ]; then
+	_has_pid_cmd=$1
+	_has_pid_pid=$(ps -Aopid,args | grep -F "${_has_pid_cmd}" |	\
+	    grep -v "grep") || true
+	if [ -n "${_has_pid_pid}" ]; then
 		return 0
 	fi
 	return 1
@@ -155,20 +161,20 @@ wait_while() {
 	return 0
 }
 
-## setup_check_variables (description, check_prev=1):
+## setup_check (description, check_prev=1):
 # Set up the "check" variables ${c_exitfile} and ${c_valgrind_cmd}, the
 # latter depending on the previously-defined ${c_valgrind_min}.
 # Advance the number of checks ${c_count_next} so that the next call to this
 # function will set up new filenames.  Write ${description} into a
 # file.  If ${check_prev} is non-zero, check that the previous
 # ${c_exitfile} exists.
-setup_check_variables() {
-	description=$1
-	check_prev=${2:-1}
+setup_check() {
+	_setup_check_description=$1
+	_setup_check_prev=${2:-1}
 
 	# Should we check for the previous exitfile?
 	if [ "${c_exitfile}" != "${NO_EXITFILE}" ] &&			\
-	    [ "${check_prev}" -gt 0 ] ; then
+	    [ "${_setup_check_prev}" -gt 0 ] ; then
 		# Check for the file.
 		if [ ! -f "${c_exitfile}" ] ; then
 			# We should have written the result of the
@@ -184,11 +190,11 @@ setup_check_variables() {
 	c_exitfile="${s_basename}-${c_count_str}.exit"
 
 	# Write the "description" file.
-	printf "%s\n" "${description}" >				\
+	printf "%s\n" "${_setup_check_description}" >			\
 		"${s_basename}-${c_count_str}.desc"
 
 	# Set up the valgrind command (or an empty string).
-	c_valgrind_cmd="$(valgrind_setup_cmd)"
+	c_valgrind_cmd="$(valgrind_setup)"
 
 	# Advances the number of checks.
 	c_count_next=$((c_count_next + 1))
@@ -199,80 +205,84 @@ setup_check_variables() {
 # ${valgrind_exit_code}, return that.  Otherwise, return 1 to indicate
 # failure.
 expected_exitcode() {
-	expected=$1
-	exitcode=$2
+	_expected_exitcode_expected=$1
+	_expected_exitcode_exitcode=$2
 
-	if [ "${exitcode}" -eq "${expected}" ]; then
+	if [ "${_expected_exitcode_exitcode}" -eq		\
+	    "${_expected_exitcode_expected}" ]; then
 		echo "0"
-	elif [ "${exitcode}" -eq "${valgrind_exit_code}" ]; then
+	elif [ "${_expected_exitcode_exitcode}" -eq		\
+	    "${valgrind_exit_code}" ]; then
 		echo "${valgrind_exit_code}"
 	else
 		echo "1"
 	fi
 }
 
-## _notify_success_or_fail (log_basename, val_log_basename):
+## _check (log_basename, val_log_basename):
 # Examine all "exit code" files beginning with ${log_basename} and
 # print "SUCCESS!", "FAILED!", "SKIP!", or "PARTIAL SUCCESS / SKIP!"
 # as appropriate.  Check any valgrind log files associated with the
 # test and print "FAILED!" if appropriate, along with the valgrind
 # logfile.  If the test failed and ${VERBOSE} is non-zero, print
 # the description to stderr.
-_notify_success_or_fail() {
-	log_basename=$1
-	val_log_basename=$2
+_check() {
+	_check_log_basename=$1
+	_check_val_log_basename=$2
 
 	# Bail if there's no exitfiles.
-	exitfiles=$(ls "${log_basename}"-*.exit) || true
-	if [ -z "${exitfiles}" ]; then
+	_check_exitfiles=$(ls "${_check_log_basename}"-*.exit) || true
+	if [ -z "${_check_exitfiles}" ]; then
 		echo "FAILED" 1>&2
 		s_retval=1
 		return
 	fi
 
 	# Count results
-	total_exitfiles=0
-	skip_exitfiles=0
+	_check_total=0
+	_check_skip=0
 
 	# Check each exitfile.
-	for exitfile in $(echo "${exitfiles}" | sort); do
-		ret=$(cat "${exitfile}")
-		total_exitfiles=$(( total_exitfiles + 1 ))
-		if [ "${ret}" -lt 0 ]; then
-			skip_exitfiles=$(( skip_exitfiles + 1 ))
+	for _check_exitfile in $(echo "${_check_exitfiles}" | sort); do
+		_check_ret=$(cat "${_check_exitfile}")
+		_check_total=$(( _check_total + 1 ))
+		if [ "${_check_ret}" -lt 0 ]; then
+			_check_skip=$(( _check_skip + 1 ))
 		fi
 
 		# Check for test failure.
-		descfile=$(echo "${exitfile}" | sed 's/\.exit/\.desc/g')
-		if [ "${ret}" -gt 0 ]; then
+		_check_descfile=$(echo "${_check_exitfile}"		\
+		    | sed 's/\.exit/\.desc/g')
+		if [ "${_check_ret}" -gt 0 ]; then
 			echo "FAILED!" 1>&2
 			if [ "${VERBOSE}" -ne 0 ]; then
-				printf "File %s contains" "${exitfile}" 1>&2
-				printf " exit code %s.\n" "${ret}" 1>&2
+				printf "File %s contains exit code %s.\n" \
+				    "${_check_exitfile}" "${_check_ret}" \
+				    1>&2
 				printf "Test description: " 1>&2
-				cat "${descfile}" 1>&2
+				cat "${_check_descfile}" 1>&2
 			fi
-			s_retval=${ret}
+			s_retval=${_check_ret}
 			return
 		else
 			# If there's no failure, delete the files.
-			rm "${exitfile}"
-			rm "${descfile}"
+			rm "${_check_exitfile}"
+			rm "${_check_descfile}"
 		fi
 
 		# Check valgrind logfile(s).
-		val_failed="$(valgrind_check_basenames "${exitfile}")"
-		if [ -n "${val_failed}" ]; then
+		_check_val_failed="$(valgrind_check "${_check_exitfile}")"
+		if [ -n "${_check_val_failed}" ]; then
 			echo "FAILED!" 1>&2
 			s_retval="${valgrind_exit_code}"
-			cat "${val_failed}" 1>&2
+			cat "${_check_val_failed}" 1>&2
 			return
 		fi
 	done
 
 	# Notify about skip or success.
-	if [ "${skip_exitfiles}" -gt 0 ]; then
-		if [ "${skip_exitfiles}" -eq "${total_exitfiles}" ]; then
+	if [ "${_check_skip}" -gt 0 ]; then
+		if [ "${_check_skip}" -eq "${_check_total}" ]; then
 			echo "SKIP!" 1>&2
 		else
 			echo "PARTIAL SUCCESS / SKIP!" 1>&2
@@ -285,13 +295,13 @@ _notify_success_or_fail() {
 ## _scenario_runner (scenario_filename):
 # Run a test scenario from ${scenario_filename}.
 _scenario_runner() {
-	scenario_filename=$1
-	basename=$(basename "${scenario_filename}" .sh)
-	printf "  %s... " "${basename}" 1>&2
+	_scenario_runner_filename=$1
+	_scenario_runner_basename=$(basename "${_scenario_runner_filename}" .sh)
+	printf "  %s... " "${_scenario_runner_basename}" 1>&2
 
 	# Initialize "scenario" and "check" variables.
-	s_basename=${out}/${basename}
-	s_val_basename=${out_valgrind}/${basename}
+	s_basename=${out}/${_scenario_runner_basename}
+	s_val_basename=${out_valgrind}/${_scenario_runner_basename}
 	c_count_next=0
 	c_exitfile="${NO_EXITFILE}"
 	c_valgrind_min=9
@@ -299,10 +309,10 @@ _scenario_runner() {
 
 	# Load scenario_cmd() from the scenario file.
 	unset scenario_cmd
-	. "${scenario_filename}"
+	. "${_scenario_runner_filename}"
 	if ! command -v scenario_cmd 1>/dev/null ; then
 		printf "ERROR: scenario_cmd() is not defined in\n" 1>&2
-		printf "  %s\n" "${scenario_filename}" 1>&2
+		printf "  %s\n" "${_scenario_runner_filename}" 1>&2
 		exit 1
 	fi
 
@@ -311,7 +321,7 @@ _scenario_runner() {
 
 	# Print PASS or FAIL, and return result.
 	s_retval=0
-	_notify_success_or_fail "${s_basename}" "${s_val_basename}"
+	_check "${s_basename}" "${s_val_basename}"
 
 	return "${s_retval}"
 }
@@ -322,13 +332,14 @@ _scenario_runner() {
 run_scenarios() {
 	# Get the test number(s) to run.
 	if [ "${N:-0}" -gt "0" ]; then
-		test_scenarios="$(printf "${scriptdir}/%02d-*.sh" "${N}")"
+		_run_scenarios_filenames="$(printf			\
+		    "${scriptdir}/%02d-*.sh" "${N}")"
 	else
-		test_scenarios="${scriptdir}/??-*.sh"
+		_run_scenarios_filenames="${scriptdir}/??-*.sh"
 	fi
 
 	# Clean up any previous directory, and create a new one.
-	_prepare_directory
+	_prepdir
 
 	# Clean up any previous valgrind directory, and prepare for new
 	# valgrind tests (if applicable).
@@ -336,13 +347,13 @@ run_scenarios() {
 
 	printf -- "Running tests\n" 1>&2
 	printf -- "-------------\n" 1>&2
-	for scenario in ${test_scenarios}; do
+	for _run_scenarios_filename in ${_run_scenarios_filenames}; do
 		# We can't call this function with $( ... ) because we
 		# want to allow it to echo values to stdout.
-		_scenario_runner "${scenario}"
-		retval=$?
-		if [ "${retval}" -gt 0 ]; then
-			exit "${retval}"
+		_scenario_runner "${_run_scenarios_filename}"
+		_run_scenarios_retval=$?
+		if [ "${_run_scenarios_retval}" -gt 0 ]; then
+			exit "${_run_scenarios_retval}"
 		fi
 	done
 }
diff --git a/tests/shared_valgrind_functions.sh b/tests/shared_valgrind_functions.sh
index 83ad7f35..2cd971b2 100644
--- a/tests/shared_valgrind_functions.sh
+++ b/tests/shared_valgrind_functions.sh
@@ -10,10 +10,10 @@ set -o noclobber -o nounset
 # - valgrind_init():
 #   Clear previous valgrind output, and prepare for running valgrind tests
 #   (if applicable).
-# - valgrind_setup_cmd(str):
+# - valgrind_setup(str):
 #   Set up the valgrind command if ${USE_VALGRIND} is greater than or equal to
 #   ${valgrind_min}.  If ${str} is not blank, include it in the log filename.
-# - valgrind_check_basenames(exitfile):
+# - valgrind_check(exitfile):
 #   Check for any memory leaks recorded in valgrind logfiles associated with a
 #   test exitfile.  Return the filename if there's a leak; otherwise return an
 #   empty string.
@@ -29,14 +29,11 @@ set -o noclobber -o nounset
 # - valgrind_suppressions: filename of valgrind suppressions.
 # - valgrind_fds_log: filename of the log of open file descriptors.
 
-# A non-zero value unlikely to be used as an exit code by the programs being
-# tested.
-valgrind_exit_code=108
 
-## _valgrind_prepare_directory ():
+## _val_prepdir ():
 # Clean up a previous valgrind directory, and prepare for new valgrind tests
 # (if applicable).
-_valgrind_prepare_directory() {
+_val_prepdir() {
 	# If we don't want to generate new suppressions files, move them.
 	if [ "${USE_VALGRIND_NO_REGEN}" -gt 0 ]; then
 		# Bail if the file doesn't exist.
@@ -46,10 +43,10 @@ _valgrind_prepare_directory() {
 		fi
 
 		# Move the files away.
-		supp_tmp="$(mktemp /tmp/valgrind-suppressions.XXXXXX)"
-		fds_tmp="$(mktemp /tmp/valgrind-fds.XXXXXX)"
-		mv "${valgrind_suppressions}" "${supp_tmp}"
-		mv "${valgrind_fds_log}" "${fds_tmp}"
+		_val_prepdir_supp_tmp="$(mktemp /tmp/valgrind-suppressions.XXXXXX)"
+		_val_prepdir_fds_tmp="$(mktemp /tmp/valgrind-fds.XXXXXX)"
+		mv "${valgrind_suppressions}" "${_val_prepdir_supp_tmp}"
+		mv "${valgrind_fds_log}" "${_val_prepdir_fds_tmp}"
 	fi
 
 	# Always delete any previous valgrind directory.
@@ -67,111 +64,124 @@ _valgrind_prepare_directory() {
 	# If we don't want to generate a new suppressions file, restore it.
 	if [ "${USE_VALGRIND_NO_REGEN}" -gt 0 ]; then
 		# Move the files back.
-		mv "${supp_tmp}" "${valgrind_suppressions}"
-		mv "${fds_tmp}" "${valgrind_fds_log}"
+		mv "${_val_prepdir_supp_tmp}" "${valgrind_suppressions}"
+		mv "${_val_prepdir_fds_tmp}" "${valgrind_fds_log}"
 	fi
 
 	# We don't want to back up this directory.
 	[ "$(uname)" = "FreeBSD" ] && chflags nodump "${out_valgrind}"
 }
 
-## _valgrind_check_optional ():
+## _val_checkver ():
 # If ${USE_VALGRIND} is greater than 0, check that valgrind is available in
 # the ${PATH} and is at least version 3.13.
-_valgrind_check_optional() {
-	if [ "${USE_VALGRIND}" -gt 0 ]; then
-		# Look for valgrind in ${PATH}.
-		if ! command -v valgrind >/dev/null 2>&1; then
-			printf "valgrind not found\n" 1>&2
-			exit 1
-		fi
+_val_checkver() {
+	# Quit if we're not using valgrind.
+	if [ ! "${USE_VALGRIND}" -gt 0 ]; then
+		return
+	fi;
+
+	# Look for valgrind in $PATH.
+	if ! command -v valgrind >/dev/null 2>&1; then
+		printf "valgrind not found\n" 1>&2
+		exit 1
+	fi
+
+	# Check the version.
+	_val_checkver_version=$(valgrind --version | cut -d "-" -f 2)
+	_val_checkver_major=$(echo "${_val_checkver_version}" | cut -d "." -f 1)
+	_val_checkver_minor=$(echo "${_val_checkver_version}" | cut -d "." -f 2)
+	if [ "${_val_checkver_major}" -lt "3" ]; then
+		printf "valgrind must be at least version 3.13\n" 1>&2
+		exit 1;
+	fi
+	if [ "${_val_checkver_major}" -eq "3" ] &&			\
+	    [ "${_val_checkver_minor}" -lt "13" ]; then
+		printf "valgrind must be at least version 3.13\n" 1>&2
+		exit 1;
+	fi
+}
 
-		# Check the version.
-		version=$(valgrind --version | cut -d "-" -f 2)
-		major=$(echo "${version}" | cut -d "." -f 1)
-		minor=$(echo "${version}" | cut -d "." -f 2)
-		if [ "${major}" -lt "3" ]; then
-			printf "valgrind must be at least version 3.13\n" 1>&2
-			exit 1;
+## _val_seg(filename):
+# Generalize an already-segmented portion of a valgrind suppressions file;
+# write the result to ${valgrind_suppressions}.
+_val_seg() {
+	_val_seg_filename=$1
+
+	# Find last relevant line.
+	_val_seg_lastline="$(grep -n "}" "${_val_seg_filename}" | cut -f1 -d:)"
+
+	# Cut off anything below the 1st "fun:pl_" (inclusive).
+	_val_seg_funcline="$(grep -n "fun:pl_" "${_val_seg_filename}" |	\
+		cut -f1 -d: |						\
+		head -n1)"
+	if [ -n "${_val_seg_funcline}" ]; then
+		if [ "${_val_seg_lastline}" -gt "${_val_seg_funcline}" ]; then
+			_val_seg_lastline="${_val_seg_funcline}"
 		fi
-		if [ "${major}" -eq "3" ] && [ "${minor}" -lt "13" ]; then
-			printf "valgrind must be at least version 3.13\n" 1>&2
-			exit 1;
+	fi
+
+	# Cut off anything below "fun:main" (including that line).  (Due to
+	# linking and/or optimizations, some memory leaks occur without
+	# "fun:pl_" appearing in the valgrind suppression.)
+	_val_seg_funcline="$(grep -n "fun:main" "${_val_seg_filename}" | \
+	    cut -f1 -d:)"
+	if [ -n "${_val_seg_funcline}" ]; then
+		if [ "${_val_seg_lastline}" -gt "${_val_seg_funcline}" ]; then
+			_val_seg_lastline="${_val_seg_funcline}"
 		fi
 	fi
+
+	# Only keep the beginning of each suppression.
+	_val_seg_lastline="$((_val_seg_lastline - 1))"
+	head -n "${_val_seg_lastline}" "${_val_seg_filename}" >>	\
+	    "${valgrind_suppressions}"
+	printf "}\n" >> "${valgrind_suppressions}"
 }
 
-## _valgrind_process_suppression_file(filename):
+## _val_generalize(filename):
 # Generalize suppressions from a valgrind suppression file by omitting the
 # "fun:pl_*" and "fun:main" lines and anything below them.
-_valgrind_process_suppression_file() {
-	filename=$1
+_val_generalize() {
+	_val_generalize_filename=$1
 
 	# How many segments do we have?
-	num_segments="$(grep -c "^{" "${filename}")"
+	_val_generalize_num_segments="$(grep -c "^{" "${_val_generalize_filename}")"
 
 	# Bail if there's nothing to do.
-	if [ "${num_segments}" -eq "0" ]; then
+	if [ "${_val_generalize_num_segments}" -eq "0" ]; then
 		return
 	fi
 
 	# Sanity check.
-	if [ "${num_segments}" -gt 100 ]; then
+	if [ "${_val_generalize_num_segments}" -gt 100 ]; then
 		printf "More than 100 valgrind suppressions?!\n" 1>&2
 		exit 1
 	fi
 
 	# Split into segments.
-	csplit -f "${filename}" "${filename}" "/{/"		\
-	    "{$((num_segments - 1))}" > /dev/null
+	csplit -f "${_val_generalize_filename}" "${_val_generalize_filename}" \
+	    "/{/" "{$((_val_generalize_num_segments - 1))}" > /dev/null
 
 	# Skip "${filename}00" because that doesn't contain a suppression.
-	i=1
-	while [ "${i}" -le "${num_segments}" ]; do
-		segfilename="$(printf "%s%02i" "${filename}" "${i}")"
-
-		# Find last relevant line.
-		lastline="$(grep -n "}" "${segfilename}" | cut -f1 -d:)"
-
-		# Cut off anything below the 1st "fun:pl_" (inclusive).
-		funcline="$(grep -n "fun:pl_" "${segfilename}" |	\
-			cut -f1 -d: |					\
-			head -n1)"
-		if [ -n "${funcline}" ]; then
-			if [ "${lastline}" -gt "${funcline}" ]; then
-				lastline="${funcline}"
-			fi
-		fi
-
-		# Cut off anything below "fun:main" (including that line).
-		# (Due to linking and/or optimizations, some memory leaks
-		# occur without "fun:pl_" appearing in the valgrind
-		# suppression.)
-		funcline="$(grep -n "fun:main" "${segfilename}" | cut -f1 -d:)"
-		if [ -n "${funcline}" ]; then
-			if [ "${lastline}" -gt "${funcline}" ]; then
-				lastline="${funcline}"
-			fi
-		fi
-
-		# Only keep the beginning of each suppression.
-		lastline="$((lastline - 1))"
-		head -n "${lastline}" "${segfilename}" >>	\
-		    "${valgrind_suppressions}"
-		printf "}\n" >> "${valgrind_suppressions}"
+	_val_generalize_i=1
+	while [ "${_val_generalize_i}" -le "${_val_generalize_num_segments}" ]; do
+		# Process segment
+		_val_seg "$(printf "%s%02i"				\
+		    "${_val_generalize_filename}" "${_val_generalize_i}")"
 
 		# Advance to the next suppression.
-		i=$((i + 1))
+		_val_generalize_i=$((_val_generalize_i + 1))
 	done
 }
 
-## _valgrind_ensure_suppression (potential_memleaks_binary):
+## _val_ensure (potential_memleaks_binary):
 # Run the ${potential_memleaks_binary} through valgrind, keeping
 # track of any apparent memory leak in order to suppress reporting
 # those leaks when testing other binaries.  Record a log file which shows the
 # open file descriptors in ${valgrind_fds_log}.
-_valgrind_ensure_suppression() {
-	potential_memleaks_binary=$1
+_val_ensure() {
+	_val_ensure_potential_memleaks_binary=$1
 
 	# Quit if we're not using valgrind.
 	if [ ! "${USE_VALGRIND}" -gt 0 ]; then
@@ -184,19 +194,20 @@ _valgrind_ensure_suppression() {
 	fi
 
 	printf "Generating valgrind suppressions... " 1>&2
-	valgrind_suppressions_log="${out_valgrind}/suppressions.pre"
+	_val_ensure_log="${out_valgrind}/suppressions.pre"
 
 	# Start off with an empty suppression file
 	touch "${valgrind_suppressions}"
 
 	# Get list of tests and the number of open descriptors at a normal exit
-	valgrind_suppressions_tests="${out_valgrind}/suppressions-names.txt"
+	_val_ensure_names="${out_valgrind}/suppressions-names.txt"
 	valgrind --track-fds=yes --log-file="${valgrind_fds_log}"	\
-	    "${potential_memleaks_binary}" > "${valgrind_suppressions_tests}"
+	    "${_val_ensure_potential_memleaks_binary}"			\
+	    > "${_val_ensure_names}"
 
 	# Generate suppressions for each test
-	while read -r testname; do
-		this_valgrind_supp="${valgrind_suppressions_log}-${testname}"
+	while read -r _val_ensure_testname; do
+		_val_ensure_thisl="${_val_ensure_log}-${_val_ensure_testname}"
 
 		# Run valgrind on the binary, sending it a "\n" so that
 		# a test which uses STDIN will not wait for user input.
@@ -205,29 +216,30 @@ _valgrind_ensure_suppression() {
 		    --gen-suppressions=all				\
 		    --trace-children=yes				\
 		    --suppressions="${valgrind_suppressions}"		\
-		    --log-file="${this_valgrind_supp}"			\
-		    "${potential_memleaks_binary}"			\
-		    "${testname}")					\
+		    --log-file="${_val_ensure_thisl}"			\
+		    "${_val_ensure_potential_memleaks_binary}"		\
+		    "${_val_ensure_testname}")				\
 		    > /dev/null
 
 		# Append name to suppressions file
-		printf "# %s\n" "${testname}" >> "${valgrind_suppressions}"
+		printf "# %s\n" "${_val_ensure_testname}"		\
+		    >> "${valgrind_suppressions}"
 
 		# Strip out useless parts from the log file, and allow the
 		# suppressions to apply to other binaries.
-		_valgrind_process_suppression_file "${this_valgrind_supp}"
-	done < "${valgrind_suppressions_tests}"
+		_val_generalize "${_val_ensure_thisl}"
+	done < "${_val_ensure_names}"
 
 	# Clean up
-	rm -f "${valgrind_suppressions_log}"
+	rm -f "${_val_ensure_log}"
 	printf "done.\n" 1>&2
 }
 
-## valgrind_setup_cmd (str):
+## valgrind_setup (str):
 # Set up the valgrind command if ${USE_VALGRIND} is greater than or equal to
 # ${valgrind_min}.  If ${str} is not blank, include it in the log filename.
-valgrind_setup_cmd() {
-	str=${1:-}
+valgrind_setup() {
+	_valgrind_setup_str=${1:-}
 
 	# Bail if we don't want to use valgrind for this check.
 	if [ "${USE_VALGRIND}" -lt "${c_valgrind_min}" ]; then
@@ -235,21 +247,21 @@ valgrind_setup_cmd() {
 	fi
 
 	# Set up the log filename.
-	if [ -n "${str}" ]; then
-		val_logfilename="${s_val_basename}-${c_count_str}-${str}-%p.log"
+	if [ -n "${_valgrind_setup_str}" ]; then
+		_valgrind_setup_logfilename="${s_val_basename}-${c_count_str}-${_valgrind_setup_str}-%p.log"
 	else
-		val_logfilename="${s_val_basename}-${c_count_str}-%p.log"
+		_valgrind_setup_logfilename="${s_val_basename}-${c_count_str}-%p.log"
 	fi
 
 	# Set up valgrind command.
-	c_valgrind_cmd="valgrind \
-		--log-file=${val_logfilename} \
+	_valgrind_setup_cmd="valgrind \
+		--log-file=${_valgrind_setup_logfilename} \
 		--track-fds=yes \
 		--trace-children=yes \
 		--leak-check=full --show-leak-kinds=all \
 		--errors-for-leak-kinds=all \
 		--suppressions=${valgrind_suppressions}"
-	echo "${c_valgrind_cmd}"
+	echo "${_valgrind_setup_cmd}"
 }
 
 ## valgrind_incomplete:
@@ -264,26 +276,26 @@ valgrind_incomplete() {
 	test -n "${_valgrind_incomplete_logfiles}"
 }
 
-## _valgrind_get_basename (exitfile):
+## _val_getbase (exitfile):
 # Return the filename without ".log" of the valgrind logfile corresponding to
 # ${exitfile}.
-_valgrind_get_basename() {
-	exitfile=$1
-	basename=$(basename "${exitfile}" ".exit")
-	echo "${out_valgrind}/${basename}"
+_val_getbase() {
+	_val_getbase_exitfile=$1
+	_val_getbase_basename=$(basename "${_val_getbase_exitfile}" ".exit")
+	echo "${out_valgrind}/${_val_getbase_basename}"
 }
 
-## _valgrind_check_logfile(logfile)
+## _val_checkl(logfile)
 # Check for any (unsuppressed) memory leaks recorded in a valgrind logfile.
 # Echo the filename if there's a leak; otherwise, echo nothing.
-_valgrind_check_logfile() {
-	logfile=$1
+_val_checkl() {
+	_val_checkl_logfile=$1
 
 	# Bytes in use at exit.
-	in_use=$(grep "in use at exit:" "${logfile}" | awk '{print $6}')
+	_val_checkl_in_use=$(grep "in use at exit:" "${_val_checkl_logfile}" | awk '{print $6}')
 
 	# Sanity check.
-	if [ "$(echo "${in_use}" | wc -w)" -ne "1" ]; then
+	if [ "$(echo "${_val_checkl_in_use}" | wc -w)" -ne "1" ]; then
 		echo "Programmer error: invalid number valgrind outputs" 1>&2
 		exit 1
 	fi
@@ -291,16 +303,16 @@ _valgrind_check_logfile() {
 	# Check for any leaks.  Use string comparison, because valgrind formats
 	# the number with commas, and sh can't convert strings like "1,000"
 	# into an integer.
-	if [ "${in_use}" != "0" ] ; then
+	if [ "${_val_checkl_in_use}" != "0" ] ; then
 		# Check if all of the leaked bytes are suppressed.  The extra
 		# whitespace in " suppressed" is necessary to distinguish
 		# between two instances of "suppressed" in the log file.  Use
 		# string comparison due to the format of the number.
-		suppressed=$(grep " suppressed:" "${logfile}" |	\
+		_val_checkl_suppressed=$(grep " suppressed:" "${_val_checkl_logfile}" |	\
 		    awk '{print $3}')
-		if [ "${in_use}" != "${suppressed}" ]; then
+		if [ "${_val_checkl_in_use}" != "${_val_checkl_suppressed}" ]; then
 			# There is an unsuppressed leak.
-			echo "${logfile}"
+			echo "${_val_checkl_logfile}"
 			return
 		fi
 	fi
@@ -312,77 +324,77 @@ _valgrind_check_logfile() {
 	# descriptors.  The important thing is that the number of fds should
 	# match the simple test case (executing potential_memleaks without
 	# running any actual tests).
-	fds_in_use=$(grep "FILE DESCRIPTORS" "${logfile}" | awk '{print $4}')
-	valgrind_fds=$(grep "FILE DESCRIPTORS" "${valgrind_fds_log}" | \
+	_val_checkl_fds_in_use=$(grep "FILE DESCRIPTORS" "${_val_checkl_logfile}" | awk '{print $4}')
+	_val_checkl_valgrind_fds=$(grep "FILE DESCRIPTORS" "${valgrind_fds_log}" | \
 	    awk '{print $4}')
-	if [ "${fds_in_use}" != "${valgrind_fds}" ] ; then
+	if [ "${_val_checkl_fds_in_use}" != "${_val_checkl_valgrind_fds}" ] ; then
 		# There is an unsuppressed leak.
-		echo "${logfile}"
+		echo "${_val_checkl_logfile}"
 		return
 	fi
 
 	# Check the error summary.
-	num_errors=$(grep "ERROR SUMMARY: " "${logfile}" | awk '{print $4}')
-	if [ "${num_errors}" -gt 0 ]; then
+	_val_checkl_num_errors=$(grep "ERROR SUMMARY: " "${_val_checkl_logfile}" | awk '{print $4}')
+	if [ "${_val_checkl_num_errors}" -gt 0 ]; then
 		# There was some other error(s) -- invalid read or write,
 		# conditional jump based on uninitialized value(s), invalid
 		# free, etc.
-		echo "${logfile}"
+		echo "${_val_checkl_logfile}"
 		return
 	fi
 }
 
-## valgrind_check_basenames (exitfile):
+## valgrind_check (exitfile):
 # Check for any memory leaks recorded in valgrind logfiles associated with a
 # test exitfile.  Return the filename if there's a leak; otherwise return an
 # empty string.
-valgrind_check_basenames() {
-	exitfile="$1"
-	val_basename=$(_valgrind_get_basename "${exitfile}")
+valgrind_check() {
+	_valgrind_check_exitfile="$1"
+	_valgrind_check_basename=$(_val_getbase "$1")
 
 	# Get list of files to check.  (Yes, the star goes outside the quotes.)
-	logfiles=$(ls "${val_basename}"* 2>/dev/null)
-	num_logfiles=$(echo "${logfiles}" | wc -w)
+	_valgrind_check_logfiles=$(ls "${_valgrind_check_basename}"* 2>/dev/null)
+	_valgrind_check_num=$(echo "${_valgrind_check_logfiles}" | wc -w)
 
 	# Bail if we don't have any valgrind logfiles to check.
 	# Use numeric comparison, because wc leaves a tab in the output.
-	if [ "${num_logfiles}" -eq "0" ] ; then
+	if [ "${_valgrind_check_num}" -eq "0" ] ; then
 		return
 	fi
 
 	# Check a single file.
-	if [ "${num_logfiles}" -eq "1" ]; then
-		_valgrind_check_logfile "${logfiles}"
+	if [ "${_valgrind_check_num}" -eq "1" ]; then
+		_val_checkl "${_valgrind_check_logfiles}"
 		return
 	fi
 
 	# If the valgrind logfiles contain "-valgrind-parent-", then we only
 	# want to check the parent (the lowest pid).
-	for logfile in ${logfiles} ; do
-		if [ "${logfile#*-valgrind-parent-}" != "${logfile}" ]; then
+	for _valgrind_check_logfile in ${_valgrind_check_logfiles} ; do
+		if [ "${_valgrind_check_logfile#*-valgrind-parent-}" != "${_valgrind_check_logfile}" ]; then
 			# Only check the parent
-			_valgrind_check_logfile "${logfile}"
+			_val_checkl "${_valgrind_check_logfile}"
 			return "$?"
 		fi
 	done
 
 	# If there's two files, there's a fork() -- likely within
 	# daemonize() -- so only pay attention to the child.
-	if [ "${num_logfiles}" -eq "2" ]; then
+	if [ "${_valgrind_check_num}" -eq "2" ]; then
 		# Find both pids.
-		val_pids=""
-		for logfile in ${logfiles} ; do
-			val_pid=$(head -n 1 "${logfile}" | cut -d "=" -f 3)
-			val_pids="${val_pids} ${val_pid}"
+		_valgrind_check_val_pids=""
+		for _valgrind_check_logfile in ${_valgrind_check_logfiles} ; do
+			_valgrind_check_val_pid=$(head -n 1 "${_valgrind_check_logfile}" | cut -d "=" -f 3)
+			_valgrind_check_val_pids="${_valgrind_check_val_pids} ${_valgrind_check_val_pid}"
 		done
 
 		# Find the logfile which has a parent in the list of pids.
-		for logfile in ${logfiles} ; do
-			val_parent_pid=$(grep "Parent PID:" "${logfile}" | \
+		for _valgrind_check_logfile in ${_valgrind_check_logfiles} ; do
+			_valgrind_check_val_parent_pid=$(grep "Parent PID:" "${_valgrind_check_logfile}" | \
 			    awk '{ print $4 }')
-			if [ "${val_pids#*"${val_parent_pid}"}" !=	\
-			    "${val_pids}" ]; then
-				_valgrind_check_logfile "${logfile}"
+			if [ "${_valgrind_check_val_pids#*"${_valgrind_check_val_parent_pid}"}" !=	\
+			    "${_valgrind_check_val_pids}" ]; then
+				_val_checkl "${_valgrind_check_logfile}"
 				return "$?"
 			fi
 		done
@@ -402,13 +414,12 @@ valgrind_init() {
 	valgrind_fds_log="${out_valgrind}/fds.log"
 
 	# If we want valgrind, check that the version is high enough.
-	_valgrind_check_optional
+	_val_checkver
 
 	# Remove any previous directory, and create a new one.
-	_valgrind_prepare_directory
+	_val_prepdir
 
 	# Generate valgrind suppression file if it is required.  Must be
 	# done after preparing the directory.
-	_valgrind_ensure_suppression				\
-	    "${bindir}/tests/valgrind/potential-memleaks"
+	_val_ensure "${bindir}/tests/valgrind/potential-memleaks"
 }