tests.repeats.sh

#!/usr/bin/env bash

# $1 test dir suffix (debug / release)

source bash_multithread.sh

# ALGORITHM SETTINGS
TESTCASE_ITERATIONS=30
TESTCASE_TIMEOUT=10
LOGFILE="log_tests.txt"

# RANDOM TREE SETTINGS (./arand2 parameters)
# BEWARE, NOT ALL VALUES MAY WORK TOGETHER
NODES=100
HEIGHT=15
ALPHABET_SIZE=10

EXECUTABLES="aarbology2 acast2 tniceprint arand2 "
TESTS_DIR="`pwd`/examples2/tree"

RES_GOOD=
RES_FAIL=
RES_TIME=
RES_SEGV=
RES_UNKN=


# ----------------------------

for FILE in $EXECUTABLES; do
	if [ ! -f $1/$FILE ]; then
		echo "Executable $FILE is required for testing. Make sure it is in $1 folder."
		exit 1
	fi
done

cd $1/
rm -f $LOGFILE

JOBS=$2
if [ -z "$JOBS" ]; then
	JOBS=1
fi

# ----------------------------

# $1 = file path
# $2 = return code
# $3 = diff out
# $4 = RankedTree xml
# $5 = Naive output
# $6 = Advanced output
function log {
	echo "==========================================================" >> $LOGFILE
	echo "file: " $1 >> $LOGFILE
	echo "ret: " $2 >> $LOGFILE
	echo "problematic tree:" >> $LOGFILE
	cat $4 >> $LOGFILE
	ONE=$(mktemp)
	TWO=$(mktemp)
	echo "Naive : " >> $ONE
	echo "Yours : " >> $TWO
	cat $5 | ./tniceprint >> $ONE
	cat $6 | ./tniceprint >> $TWO
	paste $ONE $TWO | pr -t -e$(awk 'n<length {n=length} END {print n+1}' $ONE) >> $LOGFILE
	rm $ONE $TWO
}

# $1 = file path
# $2 = return code
# $3 = diff out
# $4 = RankedTree
# $5 = RankedTree -> Postfix -> RankedTree
function log2 {
	echo "==========================================================" >> $LOGFILE
	echo "file: " $1 >> $LOGFILE
	echo "ret: " $2 >> $LOGFILE
	ONE=$(mktemp)
	TWO=$(mktemp)
	echo "Simple : " >> $ONE
	echo "After conversions : " >> $TWO
	cat $4 >> $ONE
	cat $5 >> $TWO
	paste $ONE $TWO | pr -t -e$(awk 'n<length {n=length} END {print n+1}' $ONE) >> $LOGFILE
	rm $ONE $TWO
}

# $1 = TREE_FILE
function runPostfix2RankedAlgorithmTest {
	#compares RankedTree to RankedTree -> PostfixRankedTree -> RankedTree

	RANKED2POSTFIX2RANKED=$(mktemp)
	RANKED=$(mktemp)

	./acast2 -t RankedTree -i $1 | ./tniceprint > $RANKED
	./acast2 -t RankedTree -i $1 | ./acast2 -t PostfixRankedTree | ./acast2 -t RankedTree | ./tniceprint > $RANKED2POSTFIX2RANKED

	OUT=`timeout $TESTCASE_TIMEOUT bash -c "diff $RANKED $RANKED2POSTFIX2RANKED"`
	RET=$?

	if [ $RET != 0 ]; then # fail
		log2 "$1" $RET "$OUT" "$RANKED" "$RANKED2POSTFIX2RANKED"
	fi

	rm $1 $RANKED2POSTFIX2RANKED $RANKED

	if [ $RET == 124 ]; then # timeout
		registerResult 2
		return 2
	elif [ $RET -ge 124 ]; then #segv
		registerResult 3
		return 3
	elif [ $RET != 0 ]; then # fail
		registerResult 1
		return 1
	else
		registerResult 0
		return 0
	fi
}


function runNaivePostfixRepeatsTest {

	NAIVE_OUTPUT=$(mktemp)
	ADVANCED_OUTPUT=$(mktemp)

	./aarbology2 -s $1 -a exactSubtreeRepeatsNaive | ./aarbology2 -a normalizeTreeLabels > $NAIVE_OUTPUT
	./acast2 -t PostfixRankedTree -i  $1 | ./aarbology2 -a exactSubtreeRepeatsNaive | ./acast2 -t RankedTree | ./aarbology2 -a normalizeTreeLabels > $ADVANCED_OUTPUT

	OUT=`timeout $TESTCASE_TIMEOUT bash -c "diff $NAIVE_OUTPUT $ADVANCED_OUTPUT"`
	RET=$?

	if [ $RET != 0 ]; then # fail
		log "$1" $RET "$OUT" "$1" "$NAIVE_OUTPUT" "$ADVANCED_OUTPUT"
	fi

	rm $1 $NAIVE_OUTPUT $ADVANCED_OUTPUT

	if [ $RET == 124 ]; then # timeout
		registerResult 2
		return 2
	elif [ $RET -ge 124 ]; then #segv
		registerResult 3
		return 3
	elif [ $RET != 0 ]; then # fail
		registerResult 1
		return 1
	else
		registerResult 0
		return 0
	fi
}

# $1 = TREE_FILE
function runRepeatsAlgorithmTest {

	NAIVE_OUTPUT=$(mktemp)
	ADVANCED_OUTPUT=$(mktemp)
	ARBOLOGY_OUTPUT=$(mktemp)

	./aarbology2 -s $1 -a exactSubtreeRepeatsNaive | ./aarbology2 -a normalizeTreeLabels > $NAIVE_OUTPUT
	./acast2 -t PostfixRankedTree -i $1 | ./aarbology2 -a exactSubtreeRepeats | ./acast2 -t RankedTree | ./aarbology2 -a normalizeTreeLabels > $ADVANCED_OUTPUT
	./acast2 -t PrefixRankedTree -i $1 | ./aarbology2 -a exactSubtreeRepeatsFromSubtreeAutomaton | ./acast2 -t RankedTree | ./aarbology2 -a normalizeTreeLabels > $ARBOLOGY_OUTPUT

	OUT=`timeout $TESTCASE_TIMEOUT bash -c "diff $NAIVE_OUTPUT $ADVANCED_OUTPUT"`
	RET=$?

	if [ $RET != 0 ]; then # fail
		log "$1" $RET "$OUT" "$1" "$NAIVE_OUTPUT" "$ADVANCED_OUTPUT"
	fi

	OUT=`timeout $TESTCASE_TIMEOUT bash -c "diff $NAIVE_OUTPUT $ARBOLOGY_OUTPUT"`
	RET=$?

	if [ $RET != 0 ]; then # fail
		log "$1" $RET "$OUT" "$1" "$NAIVE_OUTPUT" "$ARBOLOGY_OUTPUT"
	fi

	rm $1 $NAIVE_OUTPUT $ADVANCED_OUTPUT $ARBOLOGY_OUTPUT

	if [ $RET == 124 ]; then # timeout
		registerResult 2
		return 2
	elif [ $RET -ge 124 ]; then #segv
		registerResult 3
		return 3
	elif [ $RET != 0 ]; then # fail
		registerResult 1
		return 1
	else
		registerResult 0
		return 0
	fi
}

function registerResult {
	case $1 in
		0)
			echo -n "."
			echo -n "+1" >> $RES_GOOD
			;;
		1)
			echo -n "x"
			echo -n "+1" >> $RES_FAIL
			;;
		2)
			echo -n "T"
			echo -n "+1" >> $RES_TIME
			;;
		3)
			echo -n "E"
			echo -n "+1" >> $RES_SEGV
			;;
		*)
			echo -n "?"
			echo -n "+1" >> $RES_UNKN
			;;
	esac
}

function initResults {
	RES_GOOD=$(mktemp)
	echo -n "0" > $RES_GOOD
	RES_FAIL=$(mktemp)
	echo -n "0" > $RES_FAIL
	RES_TIME=$(mktemp)
	echo -n "0" > $RES_TIME
	RES_SEGV=$(mktemp)
	echo -n "0" > $RES_SEGV
	RES_UNKN=$(mktemp)
	echo -n "0" > $RES_UNKN
}

function clearResults {
	rm $RES_GOOD
	rm $RES_FAIL
	rm $RES_TIME
	rm $RES_SEGV
	rm $RES_UNKN
}

function outputResults {
	echo "" >> $RES_GOOD
	echo "" >> $RES_FAIL
	echo "" >> $RES_TIME
	echo "" >> $RES_SEGV
	echo "" >> $RES_UNKN

	# summary
	echo -ne "\n\t"
	echo "RES: GOOD:" $(bc < $RES_GOOD) ", FAIL:" $(bc < $RES_FAIL) ", TIME:" $(bc < $RES_TIME) ", SEGV:" $(bc < $RES_SEGV), "UNKN:" $(bc < $RES_UNKN)
	echo ""
}

function subtreeRepeatsTest {
	initResults

	echo "subtreeRepeatsTest"

	echo "Testing on predefined trees"
	echo -ne "\t"

	for TREE_FILE in `ls $TESTS_DIR/repeats.test*.xml`; do
	  # echo "Testing tree $(basename $TREE_FILE) "
		TREE_COPY=$(mktemp)
		cat $TREE_FILE > $TREE_COPY
		bgxlimit ${JOBS} runRepeatsAlgorithmTest "$TREE_COPY"
	done
	wait

	outputResults
	clearResults

	initResults

	echo "Testing on randomly generated trees"
	echo -ne "\t"

	for i in $(seq 1 $TESTCASE_ITERATIONS); do
		# echo "Testing tree $(basename $TREE_FILE) "
		TREE_FILE=$(mktemp)
		./arand2 -t RT --nodes $NODES --terminals $(( $RANDOM % $ALPHABET_SIZE + 1 )) --height $HEIGHT > $TREE_FILE
		bgxlimit ${JOBS} runRepeatsAlgorithmTest "$TREE_FILE"
	done
	wait

	outputResults
	clearResults
}

function postfixToRankedTest {
	initResults

	echo "PostfixToRankedTest"

	echo "Testing on predefined trees"
	echo -ne "\t"

	for TREE_FILE in `ls $TESTS_DIR/repeats.test*.xml`; do
	  # echo "Testing tree $(basename $TREE_FILE) "
		TREE_COPY=$(mktemp)
		cat $TREE_FILE > $TREE_COPY
		bgxlimit ${JOBS} runPostfix2RankedAlgorithmTest "$TREE_COPY"
	done
	wait

	outputResults
	clearResults

	initResults

	echo "Testing on randomly generated trees"
	echo -ne "\t"

	for i in $(seq 1 $TESTCASE_ITERATIONS); do
		# echo "Testing tree $(basename $TREE_FILE) "
		TREE_FILE=$(mktemp)
		./arand2 -t RT --nodes $NODES --terminals $(( $RANDOM % $ALPHABET_SIZE + 1 )) --height $HEIGHT > $TREE_FILE
		bgxlimit ${JOBS} runPostfix2RankedAlgorithmTest "$TREE_FILE"
	done
	wait

	outputResults
	clearResults
}

function naivePostfixRepeatsTest {
	initResults

	echo "NaivePostfixRepeatsTest"

	echo "Testing on predefined trees"
	echo -ne "\t"

	for TREE_FILE in `ls $TESTS_DIR/repeats.test*.xml`; do
	  # echo "Testing tree $(basename $TREE_FILE) "
		TREE_COPY=$(mktemp)
		cat $TREE_FILE > $TREE_COPY
		bgxlimit ${JOBS} runNaivePostfixRepeatsTest "$TREE_COPY"
	done
	wait

	outputResults
	clearResults

	initResults

	echo "Testing on randomly generated trees"
	echo -ne "\t"

	for i in $(seq 1 $TESTCASE_ITERATIONS); do
		# echo "Testing tree $(basename $TREE_FILE) "
		TREE_FILE=$(mktemp)
		./arand2 -t RT --nodes $NODES --terminals $(( $RANDOM % $ALPHABET_SIZE + 1 )) --height $HEIGHT > $TREE_FILE
		bgxlimit ${JOBS} runNaivePostfixRepeatsTest "$TREE_FILE"
	done
	wait

	outputResults
	clearResults
}


subtreeRepeatsTest
postfixToRankedTest
naivePostfixRepeatsTest