Eric Lee / smarc-uboot | Embedian Git Server

Commit 6c016485a685b5cdac28edb25147311a3e88d51f

Authored by Suriyan Ramasami 2014-11-18 06:39:39 +0800

Committed by Tom Rini 2014-11-23 19:49:05 +0800

Exists in v2017.01-smarct4x and in 37 other branches

sandbox: script for testing sandbox/ext4/fat/fs commands

Test size/read/write commands in a sandbox environment.

Signed-off-by: Suriyan Ramasami <suriyan.r@gmail.com>

Acked-by: Simon Glass <sjg@chromium.org>

Showing 1 changed file with 561 additions and 0 deletions Side-by-side Diff

test/fs/fs-test.sh

test/fs/fs-test.sh

Diff comments View file @ 6c01648

	1	+#!/bin/bash
	2	+#
	3	+# (C) Copyright 2014 Suriyan Ramasami
	4	+#
	5	+# SPDX-License-Identifier: GPL-2.0+
	6	+#
	7	+
	8	+# Invoke this test script from U-Boot base directory as ./test/fs/fs-test.sh
	9	+# It currently tests the fs/sb and native commands for ext4 and fat partitions
	10	+# Expected results are as follows:
	11	+# EXT4 tests:
	12	+# fs-test.sb.ext4.out: Summary: PASS: 17 FAIL: 2
	13	+# fs-test.ext4.out: Summary: PASS: 11 FAIL: 8
	14	+# fs-test.fs.ext4.out: Summary: PASS: 11 FAIL: 8
	15	+# FAT tests:
	16	+# fs-test.sb.fat.out: Summary: PASS: 17 FAIL: 2
	17	+# fs-test.fat.out: Summary: PASS: 19 FAIL: 0
	18	+# fs-test.fs.fat.out: Summary: PASS: 19 FAIL: 0
	19	+# Total Summary: TOTAL PASS: 94 TOTAL FAIL: 20
	20	+
	21	+# pre-requisite binaries list.
	22	+PREREQ_BINS="md5sum mkfs mount umount dd fallocate mkdir"
	23	+
	24	+# All generated output files from this test will be in $OUT_DIR
	25	+# Hence everything is sandboxed.
	26	+OUT_DIR="sandbox/test/fs"
	27	+
	28	+# Location of generated sandbox u-boot
	29	+UBOOT="./sandbox/u-boot"
	30	+
	31	+# Our mount directory will be in the sandbox
	32	+MOUNT_DIR="${OUT_DIR}/mnt"
	33	+
	34	+# The file system image we create will have the $IMG prefix.
	35	+IMG="${OUT_DIR}/3GB"
	36	+
	37	+# $SMALL_FILE is the name of the 1MB file in the file system image
	38	+SMALL_FILE="1MB.file"
	39	+
	40	+# $BIG_FILE is the name of the 2.5GB file in the file system image
	41	+BIG_FILE="2.5GB.file"
	42	+
	43	+# $MD5_FILE will have the expected md5s when we do the test
	44	+# They shall have a suffix which represents their file system (ext4/fat)
	45	+MD5_FILE="${OUT_DIR}/md5s.list"
	46	+
	47	+# $OUT shall be the prefix of the test output. Their suffix will be .out
	48	+OUT="${OUT_DIR}/fs-test"
	49	+
	50	+# Full Path of the 1 MB file that shall be created in the fs image.
	51	+MB1="${MOUNT_DIR}/${SMALL_FILE}"
	52	+GB2p5="${MOUNT_DIR}/${BIG_FILE}"
	53	+
	54	+# ************************
	55	+# * Functions start here *
	56	+# ************************
	57	+
	58	+# Check if the prereq binaries exist, or exit
	59	+function check_prereq() {
	60	+ for prereq in $PREREQ_BINS; do
	61	+ if [ ! -x `which $prereq` ]; then
	62	+ echo "Missing $prereq binary. Exiting!"
	63	+ exit
	64	+ fi
	65	+ done
	66	+
	67	+ # We use /dev/urandom to create files. Check if it exists.
	68	+ if [ ! -c /dev/urandom ]; then
	69	+ echo "Missing character special /dev/urandom. Exiting!"
	70	+ exit
	71	+ fi
	72	+}
	73	+
	74	+# If 1st param is "clean", then clean out the generated files and exit
	75	+function check_clean() {
	76	+ if [ "$1" = "clean" ]; then
	77	+ rm -rf "$OUT_DIR"
	78	+ echo "Cleaned up generated files. Exiting"
	79	+ exit
	80	+ fi
	81	+}
	82	+
	83	+# Generate sandbox U-Boot - gleaned from /test/dm/test-dm.sh
	84	+function compile_sandbox() {
	85	+ unset CROSS_COMPILE
	86	+ NUM_CPUS=$(cat /proc/cpuinfo \|grep -c processor)
	87	+ make O=sandbox sandbox_config
	88	+ make O=sandbox -s -j${NUM_CPUS}
	89	+
	90	+ # Check if U-Boot exists
	91	+ if [ ! -x "$UBOOT" ]; then
	92	+ echo "$UBOOT does not exist or is not executable"
	93	+ echo "Build error?"
	94	+ echo "Please run this script as ./test/fs/`basename $0`"
	95	+ exit
	96	+ fi
	97	+}
	98	+
	99	+# Clean out all generated files other than the file system images
	100	+# We save time by not deleting and recreating the file system images
	101	+function prepare_env() {
	102	+ rm -f ${MD5_FILE}.* ${OUT}.*
	103	+ mkdir ${OUT_DIR}
	104	+}
	105	+
	106	+# 1st parameter is the name of the image file to be created
	107	+# 2nd parameter is the filesystem - fat ext4 etc
	108	+# -F cant be used with fat as it means something else.
	109	+function create_image() {
	110	+ # Create image if not already present - saves time, while debugging
	111	+ if [ "$2" = "ext4" ]; then
	112	+ MKFS_OPTION="-F"
	113	+ else
	114	+ MKFS_OPTION=""
	115	+ fi
	116	+ if [ ! -f "$1" ]; then
	117	+ fallocate -l 3G "$1" &> /dev/null
	118	+ mkfs -t "$2" $MKFS_OPTION "$1" &> /dev/null
	119	+ if [ $? -ne 0 -a "$2" = "fat" ]; then
	120	+ # If we fail and we did fat, try vfat.
	121	+ mkfs -t vfat $MKFS_OPTION "$1" &> /dev/null
	122	+ fi
	123	+ fi
	124	+}
	125	+
	126	+# 1st parameter is the FS type: fat/ext4
	127	+# 2nd parameter is the name of small file
	128	+# Returns filename which can be used for fat or ext4 for writing
	129	+function fname_for_write() {
	130	+ case $1 in
	131	+ ext4)
	132	+ # ext4 needs absolute path name of file
	133	+ echo /${2}.w
	134	+ ;;
	135	+
	136	+ *)
	137	+ echo ${2}.w
	138	+ ;;
	139	+ esac
	140	+}
	141	+
	142	+# 1st parameter is image file
	143	+# 2nd parameter is file system type - fat/ext4
	144	+# 3rd parameter is name of small file
	145	+# 4th parameter is name of big file
	146	+# 5th parameter is fs/nonfs/sb - to dictate generic fs commands or
	147	+# otherwise or sb hostfs
	148	+# 6th parameter is the directory path for the files. Its "" for generic
	149	+# fs and ext4/fat and full patch for sb hostfs
	150	+# UBOOT is set in env
	151	+function test_image() {
	152	+ addr="0x01000008"
	153	+ length="0x00100000"
	154	+
	155	+ case "$2" in
	156	+ fat)
	157	+ PREFIX="fat"
	158	+ WRITE="write"
	159	+ ;;
	160	+
	161	+ ext4)
	162	+ PREFIX="ext4"
	163	+ WRITE="write"
	164	+ ;;
	165	+
	166	+ *)
	167	+ echo "Unhandled filesystem $2. Exiting!"
	168	+ exit
	169	+ ;;
	170	+ esac
	171	+
	172	+ case "$5" in
	173	+ fs)
	174	+ PREFIX=""
	175	+ WRITE="save"
	176	+ SUFFIX=" 0:0"
	177	+ ;;
	178	+
	179	+ nonfs)
	180	+ SUFFIX=" 0:0"
	181	+ ;;
	182	+
	183	+ sb)
	184	+ PREFIX="sb "
	185	+ WRITE="save"
	186	+ SUFFIX="fs -"
	187	+ ;;
	188	+
	189	+ *)
	190	+ echo "Unhandled mode $5. Exiting!"
	191	+ exit
	192	+ ;;
	193	+
	194	+ esac
	195	+
	196	+ if [ -z "$6" ]; then
	197	+ FILE_WRITE=`fname_for_write $2 $3`
	198	+ FILE_SMALL=$3
	199	+ FILE_BIG=$4
	200	+ else
	201	+ FILE_WRITE=$6/`fname_for_write $2 $3`
	202	+ FILE_SMALL=$6/$3
	203	+ FILE_BIG=$6/$4
	204	+ fi
	205	+
	206	+ # In u-boot commands, <interface> stands for host or hostfs
	207	+ # hostfs maps to the host fs.
	208	+ # host maps to the "sb bind" that we do
	209	+
	210	+ $UBOOT << EOF
	211	+sb=$5
	212	+setenv bind 'if test "\$sb" != sb; then sb bind 0 "$1"; fi'
	213	+run bind
	214	+# Test Case 1 - ls
	215	+${PREFIX}ls host${SUFFIX} $6
	216	+#
	217	+# We want ${PREFIX}size host 0:0 $3 for host commands and
	218	+# sb size hostfs - $3 for hostfs commands.
	219	+# 1MB is 0x0010 0000
	220	+# Test Case 2 - size of small file
	221	+${PREFIX}size host${SUFFIX} $FILE_SMALL
	222	+printenv filesize
	223	+setenv filesize
	224	+
	225	+# 2.5GB (102410242500) is 0x9C40 0000
	226	+# Test Case 3 - size of big file
	227	+${PREFIX}size host${SUFFIX} $FILE_BIG
	228	+printenv filesize
	229	+setenv filesize
	230	+
	231	+# Notes about load operation
	232	+# If I use 0x01000000 I get DMA misaligned error message
	233	+# Last two parameters are size and offset.
	234	+
	235	+# Test Case 4a - Read full 1MB of small file
	236	+${PREFIX}load host${SUFFIX} $addr $FILE_SMALL
	237	+printenv filesize
	238	+# Test Case 4b - Read full 1MB of small file
	239	+md5sum $addr \$filesize
	240	+setenv filesize
	241	+
	242	+# Test Case 5a - First 1MB of big file
	243	+${PREFIX}load host${SUFFIX} $addr $FILE_BIG $length 0x0
	244	+printenv filesize
	245	+# Test Case 5b - First 1MB of big file
	246	+md5sum $addr \$filesize
	247	+setenv filesize
	248	+
	249	+# fails for ext as no offset support
	250	+# Test Case 6a - Last 1MB of big file
	251	+${PREFIX}load host${SUFFIX} $addr $FILE_BIG $length 0x9C300000
	252	+printenv filesize
	253	+# Test Case 6b - Last 1MB of big file
	254	+md5sum $addr \$filesize
	255	+setenv filesize
	256	+
	257	+# fails for ext as no offset support
	258	+# Test Case 7a - One from the last 1MB chunk of 2GB
	259	+${PREFIX}load host${SUFFIX} $addr $FILE_BIG $length 0x7FF00000
	260	+printenv filesize
	261	+# Test Case 7b - One from the last 1MB chunk of 2GB
	262	+md5sum $addr \$filesize
	263	+setenv filesize
	264	+
	265	+# fails for ext as no offset support
	266	+# Test Case 8a - One from the start 1MB chunk from 2GB
	267	+${PREFIX}load host${SUFFIX} $addr $FILE_BIG $length 0x80000000
	268	+printenv filesize
	269	+# Test Case 8b - One from the start 1MB chunk from 2GB
	270	+md5sum $addr \$filesize
	271	+setenv filesize
	272	+
	273	+# fails for ext as no offset support
	274	+# Test Case 9a - One 1MB chunk crossing the 2GB boundary
	275	+${PREFIX}load host${SUFFIX} $addr $FILE_BIG $length 0x7FF80000
	276	+printenv filesize
	277	+# Test Case 9b - One 1MB chunk crossing the 2GB boundary
	278	+md5sum $addr \$filesize
	279	+setenv filesize
	280	+
	281	+# Generic failure case
	282	+# Test Case 10 - 2MB chunk from the last 1MB of big file
	283	+${PREFIX}load host${SUFFIX} $addr $FILE_BIG 0x00200000 0x9C300000
	284	+printenv filesize
	285	+#
	286	+
	287	+# Read 1MB from small file
	288	+${PREFIX}load host${SUFFIX} $addr $FILE_SMALL
	289	+# Write it back to test the writes
	290	+# Test Case 11a - Check that the write succeeded
	291	+${PREFIX}${WRITE} host${SUFFIX} $addr $FILE_WRITE \$filesize
	292	+mw.b $addr 00 100
	293	+${PREFIX}load host${SUFFIX} $addr $FILE_WRITE
	294	+# Test Case 11b - Check md5 of written to is same as the one read from
	295	+md5sum $addr \$filesize
	296	+setenv filesize
	297	+#
	298	+reset
	299	+
	300	+EOF
	301	+}
	302	+
	303	+# 1st argument is the name of the image file.
	304	+# 2nd argument is the file where we generate the md5s of the files
	305	+# generated with the appropriate start and length that we use to test.
	306	+# It creates the necessary files in the image to test.
	307	+# $GB2p5 is the path of the big file (2.5 GB)
	308	+# $MB1 is the path of the small file (1 MB)
	309	+# $MOUNT_DIR is the path we can use to mount the image file.
	310	+function create_files() {
	311	+ # Mount the image so we can populate it.
	312	+ mkdir -p "$MOUNT_DIR"
	313	+ sudo mount -o loop,rw "$1" "$MOUNT_DIR"
	314	+
	315	+ # Create big file in this image.
	316	+ # Note that we work only on the start 1MB, couple MBs in the 2GB range
	317	+ # and the last 1 MB of the huge 2.5GB file.
	318	+ # So, just put random values only in those areas.
	319	+ if [ ! -f "${GB2p5}" ]; then
	320	+ sudo dd if=/dev/urandom of="${GB2p5}" bs=1M count=1 \
	321	+ &> /dev/null
	322	+ sudo dd if=/dev/urandom of="${GB2p5}" bs=1M count=2 seek=2047 \
	323	+ &> /dev/null
	324	+ sudo dd if=/dev/urandom of="${GB2p5}" bs=1M count=1 seek=2499 \
	325	+ &> /dev/null
	326	+ fi
	327	+
	328	+ # Create a small file in this image.
	329	+ if [ ! -f "${MB1}" ]; then
	330	+ sudo dd if=/dev/urandom of="${MB1}" bs=1M count=1 \
	331	+ &> /dev/null
	332	+ fi
	333	+
	334	+ # Delete the small file which possibly is written as part of a
	335	+ # previous test.
	336	+ sudo rm -f "${MB1}.w"
	337	+
	338	+ # Generate the md5sums of reads that we will test against small file
	339	+ dd if="${MB1}" bs=1M skip=0 count=1 2> /dev/null \| md5sum > "$2"
	340	+
	341	+ # Generate the md5sums of reads that we will test against big file
	342	+ # One from beginning of file.
	343	+ dd if="${GB2p5}" bs=1M skip=0 count=1 \
	344	+ 2> /dev/null \| md5sum >> "$2"
	345	+
	346	+ # One from end of file.
	347	+ dd if="${GB2p5}" bs=1M skip=2499 count=1 \
	348	+ 2> /dev/null \| md5sum >> "$2"
	349	+
	350	+ # One from the last 1MB chunk of 2GB
	351	+ dd if="${GB2p5}" bs=1M skip=2047 count=1 \
	352	+ 2> /dev/null \| md5sum >> "$2"
	353	+
	354	+ # One from the start 1MB chunk from 2GB
	355	+ dd if="${GB2p5}" bs=1M skip=2048 count=1 \
	356	+ 2> /dev/null \| md5sum >> "$2"
	357	+
	358	+ # One 1MB chunk crossing the 2GB boundary
	359	+ dd if="${GB2p5}" bs=512K skip=4095 count=2 \
	360	+ 2> /dev/null \| md5sum >> "$2"
	361	+
	362	+ sync
	363	+ sudo umount "$MOUNT_DIR"
	364	+ rmdir "$MOUNT_DIR"
	365	+}
	366	+
	367	+# 1st parameter is the text to print
	368	+# if $? is 0 its a pass, else a fail
	369	+# As a side effect it shall update env variable PASS and FAIL
	370	+function pass_fail() {
	371	+ if [ $? -eq 0 ]; then
	372	+ echo pass - "$1"
	373	+ PASS=$((PASS + 1))
	374	+ else
	375	+ echo FAIL - "$1"
	376	+ FAIL=$((FAIL + 1))
	377	+ fi
	378	+}
	379	+
	380	+# 1st parameter is the string which leads to an md5 generation
	381	+# 2nd parameter is the file we grep, for that string
	382	+# 3rd parameter is the name of the file which has md5s in it
	383	+# 4th parameter is the line # in the md5 file that we match it against
	384	+# This function checks if the md5 of the file in the sandbox matches
	385	+# that calculated while generating the file
	386	+# 5th parameter is the string to print with the result
	387	+check_md5() {
	388	+ # md5sum in u-boot has output of form:
	389	+ # md5 for 01000008 ... 01100007 ==> <md5>
	390	+ # the 7th field is the actual md5
	391	+ md5_src=`grep -A3 "$1" "$2" \| grep "md5 for"`
	392	+ md5_src=($md5_src)
	393	+ md5_src=${md5_src[6]}
	394	+
	395	+ # The md5 list, each line is of the form:
	396	+ # - <md5>
	397	+ # the 2nd field is the actual md5
	398	+ md5_dst=`sed -n $4p $3`
	399	+ md5_dst=($md5_dst)
	400	+ md5_dst=${md5_dst[0]}
	401	+
	402	+ # For a pass they should match.
	403	+ [ "$md5_src" = "$md5_dst" ]
	404	+ pass_fail "$5"
	405	+}
	406	+
	407	+# 1st parameter is the name of the output file to check
	408	+# 2nd parameter is the name of the file containing the md5 expected
	409	+# 3rd parameter is the name of the small file
	410	+# 4th parameter is the name of the big file
	411	+# 5th paramter is the name of the written file
	412	+# This function checks the output file for correct results.
	413	+function check_results() {
	414	+ echo "** Start $1"
	415	+
	416	+ PASS=0
	417	+ FAIL=0
	418	+
	419	+ # Check if the ls is showing correct results for 2.5 gb file
	420	+ grep -A6 "Test Case 1 " "$1" \| egrep -iq "2621440000 *$4"
	421	+ pass_fail "TC1: ls of $4"
	422	+
	423	+ # Check if the ls is showing correct results for 1 mb file
	424	+ grep -A6 "Test Case 1 " "$1" \| egrep -iq "1048576 *$3"
	425	+ pass_fail "TC1: ls of $3"
	426	+
	427	+ # Check size command on 1MB.file
	428	+ egrep -A3 "Test Case 2 " "$1" \| grep -q "filesize=100000"
	429	+ pass_fail "TC2: size of $3"
	430	+
	431	+ # Check size command on 2.5GB.file
	432	+ egrep -A3 "Test Case 3 " "$1" \| grep -q "filesize=9c400000"
	433	+ pass_fail "TC3: size of $4"
	434	+
	435	+ # Check read full mb of 1MB.file
	436	+ grep -A6 "Test Case 4a " "$1" \| grep -q "filesize=100000"
	437	+ pass_fail "TC4: load of $3 size"
	438	+ check_md5 "Test Case 4b " "$1" "$2" 1 "TC4: load from $3"
	439	+
	440	+ # Check first mb of 2.5GB.file
	441	+ grep -A6 "Test Case 5a " "$1" \| grep -q "filesize=100000"
	442	+ pass_fail "TC5: load of 1st MB from $4 size"
	443	+ check_md5 "Test Case 5b " "$1" "$2" 2 "TC5: load of 1st MB from $4"
	444	+
	445	+ # Check last mb of 2.5GB.file
	446	+ grep -A6 "Test Case 6a " "$1" \| grep -q "filesize=100000"
	447	+ pass_fail "TC6: load of last MB from $4 size"
	448	+ check_md5 "Test Case 6b " "$1" "$2" 3 "TC6: load of last MB from $4"
	449	+
	450	+ # Check last 1mb chunk of 2gb from 2.5GB file
	451	+ grep -A6 "Test Case 7a " "$1" \| grep -q "filesize=100000"
	452	+ pass_fail "TC7: load of last 1mb chunk of 2GB from $4 size"
	453	+ check_md5 "Test Case 7b " "$1" "$2" 4 \
	454	+ "TC7: load of last 1mb chunk of 2GB from $4"
	455	+
	456	+ # Check first 1mb chunk after 2gb from 2.5GB file
	457	+ grep -A6 "Test Case 8a " "$1" \| grep -q "filesize=100000"
	458	+ pass_fail "TC8: load 1st MB chunk after 2GB from $4 size"
	459	+ check_md5 "Test Case 8b " "$1" "$2" 5 \
	460	+ "TC8: load 1st MB chunk after 2GB from $4"
	461	+
	462	+ # Check 1mb chunk crossing the 2gb boundary from 2.5GB file
	463	+ grep -A6 "Test Case 9a " "$1" \| grep -q "filesize=100000"
	464	+ pass_fail "TC9: load 1MB chunk crossing 2GB boundary from $4 size"
	465	+ check_md5 "Test Case 9b " "$1" "$2" 6 \
	466	+ "TC9: load 1MB chunk crossing 2GB boundary from $4"
	467	+
	468	+ # Check 2mb chunk from the last 1MB of 2.5GB file - generic failure case
	469	+ grep -A6 "Test Case 10 " "$1" \| grep -q 'Error: "filesize" not defined'
	470	+ pass_fail "TC10: load 2MB from the last 1MB of $4 - generic fail case"
	471	+
	472	+ # Check 1mb chunk write
	473	+ grep -A3 "Test Case 11a " "$1" \| \
	474	+ egrep -q '1048576 bytes written\|update journal'
	475	+ pass_fail "TC11: 1MB write to $5 - write succeeded"
	476	+ check_md5 "Test Case 11b " "$1" "$2" 1 \
	477	+ "TC11: 1MB write to $5 - content verified"
	478	+ echo "** End $1"
	479	+}
	480	+
	481	+# Takes in one parameter which is "fs" or "nonfs", which then dictates
	482	+# if a fs test (size/load/save) or a nonfs test (fatread/extread) needs to
	483	+# be performed.
	484	+function test_fs_nonfs() {
	485	+ echo "Creating files in $fs image if not already present."
	486	+ create_files $IMAGE $MD5_FILE_FS
	487	+
	488	+ OUT_FILE="${OUT}.fs.${fs}.out"
	489	+ test_image $IMAGE $fs $SMALL_FILE $BIG_FILE $1 "" \
	490	+ > ${OUT_FILE}
	491	+ check_results $OUT_FILE $MD5_FILE_FS $SMALL_FILE $BIG_FILE \
	492	+ $WRITE_FILE
	493	+ TOTAL_FAIL=$((TOTAL_FAIL + FAIL))
	494	+ TOTAL_PASS=$((TOTAL_PASS + PASS))
	495	+ echo "Summary: PASS: $PASS FAIL: $FAIL"
	496	+ echo "--------------------------------------------"
	497	+}
	498	+
	499	+# ********************
	500	+# * End of functions *
	501	+# ********************
	502	+
	503	+check_clean "$1"
	504	+check_prereq
	505	+compile_sandbox
	506	+prepare_env
	507	+
	508	+# Track TOTAL_FAIL and TOTAL_PASS
	509	+TOTAL_FAIL=0
	510	+TOTAL_PASS=0
	511	+
	512	+# In each loop, for a given file system image, we test both the
	513	+# fs command, like load/size/write, the file system specific command
	514	+# like: ext4load/ext4size/ext4write and the sb load/ls/save commands.
	515	+for fs in ext4 fat; do
	516	+
	517	+ echo "Creating $fs image if not already present."
	518	+ IMAGE=${IMG}.${fs}.img
	519	+ MD5_FILE_FS="${MD5_FILE}.${fs}"
	520	+ create_image $IMAGE $fs
	521	+
	522	+ # sb commands test
	523	+ echo "Creating files in $fs image if not already present."
	524	+ create_files $IMAGE $MD5_FILE_FS
	525	+
	526	+ # Lets mount the image and test sb hostfs commands
	527	+ mkdir -p "$MOUNT_DIR"
	528	+ if [ "$fs" = "fat" ]; then
	529	+ uid="uid=`id -u`"
	530	+ else
	531	+ uid=""
	532	+ fi
	533	+ sudo mount -o loop,rw,$uid "$IMAGE" "$MOUNT_DIR"
	534	+ sudo chmod 777 "$MOUNT_DIR"
	535	+
	536	+ OUT_FILE="${OUT}.sb.${fs}.out"
	537	+ test_image $IMAGE $fs $SMALL_FILE $BIG_FILE sb `pwd`/$MOUNT_DIR \
	538	+ > ${OUT_FILE}
	539	+ sudo umount "$MOUNT_DIR"
	540	+ rmdir "$MOUNT_DIR"
	541	+
	542	+ check_results $OUT_FILE $MD5_FILE_FS $SMALL_FILE $BIG_FILE \
	543	+ $WRITE_FILE
	544	+ TOTAL_FAIL=$((TOTAL_FAIL + FAIL))
	545	+ TOTAL_PASS=$((TOTAL_PASS + PASS))
	546	+ echo "Summary: PASS: $PASS FAIL: $FAIL"
	547	+ echo "--------------------------------------------"
	548	+
	549	+ test_fs_nonfs nonfs
	550	+ test_fs_nonfs fs
	551	+done
	552	+
	553	+echo "Total Summary: TOTAL PASS: $TOTAL_PASS TOTAL FAIL: $TOTAL_FAIL"
	554	+echo "--------------------------------------------"
	555	+if [ $TOTAL_FAIL -eq 0 ]; then
	556	+ echo "PASSED"
	557	+ exit 0
	558	+else
	559	+ echo "FAILED"
	560	+ exit 1
	561	+fi