# Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

# All rights reserved.

# This component and the accompanying materials are made available

# which accompanies this distribution, and is available

# at the URL "http://www.eclipse.org/legal/epl-v10.html".

#

# Initial Contributors:

# Nokia Corporation - initial contribution.

#

# Contributors:

#

# Description:

#

#!/home/guest/vinodp/local/bin/zsh

###################################

# Test cases for internal commands#

###################################

#Inititalise counters for Total tests, passes, fails.

preamble()

{

if [ ! -d chdirtest ] 

then

	mkdir chdirtest

fi

if [ ! -d cdtest ]

then

	mkdir cdtest

fi

if [ ! -d pushdtest ]

then

    mkdir pushdtest

fi

if [ ! -d popdtest ]

then

    mkdir popdtest

fi

if [ ! -d dirstest ]

then

    mkdir dirstest

fi

}

init()

{

let totalno=0;

let passno=0;

let failno=0;

}

#Start test cases

#pwd command print the absolute pathname of the current working directory

test_pwd1()

{

let totalno=totalno+1

echo "Test $totalno: pwd with no argument"

cwd=`pwd`

ret=$?

if [ $ret = 0 ]

	then

	if [ $PWD = $cwd ]

	then

		echo "PASS"

		let passno=passno+1

	else

		echo "FAIL: Expected $PWD, returned $cwd"

		let failno=failno+1

	fi

else

	echo "FAIL: Expected return value 0, but  returned $ret"

	let failno=failno+1

fi

}

# echo command Write each arg on the standard output, with a space separating each one

test_echo1()

{

let totalno=totalno+1

echo "Test $totalno: echo with a string as argument"

echostr=`echo "This is a test string"`

ret=$?

if [ $ret = 0 ]

then

	if [ $echostr = "This is a test string" ]

	then

		echo "PASS"

		let passno=passno+1 

	else

		echo "FAIL: Expected \"This is a test string\", returned \"$echostr\""

		let failno=failno+1

	fi

else

	echo "FAIL: Expected return value 0, but  returned $ret"

	let failno=failno+1

fi

}

# With no flags the arguments are printed on the standard output as described by echo

test_print1()

{

let totalno=totalno+1

echo "Test $totalno: print with a string and a variable as argument"

let var=1+2

printstr=`print "This is a value of a variable: $var"`

ret=$?

if [ $ret = 0 ]

then

	 if [ $printstr = "This is a value of a variable: 3" ]

	 then

		  echo "PASS"

		  let passno=passno+1

	 else

		  echo "FAIL: Expected \"This is a value of a variable: 3\", returned \"$printstr\""

		  let failno=failno+1

	 fi

else

	 echo "FAIL: Expected return value 0, but  returned $ret"

	 let failno=failno+1

fi

}

# Print the arguments according to the format specification. Formatting rules are the same as used in C

test_printf1()

{

let totalno=totalno+1

echo "Test $totalno: printf with a string and a variable as argument"

let var=1+2

printfstr=`printf "This is a value of a variable: $var"`

ret=$?

if [ $ret = 0 ]

then

	 if [ $printfstr = "This is a value of a variable: 3" ]

	 then

		  echo "PASS"

		  let passno=passno+1

	 else

		  echo "FAIL: Expected \"This is a value of a variable: 3\", returned \"$printfstr\""

		  let failno=failno+1

	 fi

else

	 echo "FAIL: Expected return value 0, but  returned $ret"

	 let failno=failno+1

fi

}

# Read one line and break it into fields using the characters 

test_read1()

{

let totalno=totalno+1

echo "Test $totalno: read a value into the argument"

echo Hello > readtest.txt

read readvar < readtest.txt

ret=$?

if [ $ret = 0 ]

then

	 if [ $readvar = "Hello" ]

	 then

		  echo "PASS"

		  let passno=passno+1

	 else

		  echo "FAIL: Expected \"Hello\", read \"$readvar\""

		  let failno=failno+1

	 fi

else

	 echo "FAIL: Expected return value 0, but  returned $ret"

	 let failno=failno+1

fi

}

# change the current directory to arg

test_chdir1()

{

let totalno=totalno+1

echo "Test $totalno: chdir with one argument"

if [ -d chdirtest ] 

then

	 oldcwd=`pwd`

	 chdir chdirtest

	 ret=$?

	 if [ $ret = 0 ]

	 then

		  if [ $PWD = $oldcwd\chdirtest ]

		  then

			   echo "PASS"

			   let passno=passno+1

		  else

			   echo "FAIL: Expected \"$PWD\", returned \"$oldcwd\chdirtest\""

			   let failno=failno+1

			   cd ..

			   return

		  fi

	 else

		  echo "FAIL: Expected return value 0, but  returned $ret"

		  let failno=failno+1

		  cd..

	      return

	 fi

	 chdir ..

else

	 echo "FAIL:chdirtest dir does not exist"

	 let failno=failno+1

fi

}

# change the current directory to arg

test_cd1()

{

let totalno=totalno+1

echo "Test $totalno: cd with one argument"

if [ -d cdtest ]

then

	 oldcwd=`pwd`

	 cd cdtest

	 ret=$?

	 if [ $ret = 0 ]

	 then

		  if [ $PWD = $oldcwd\cdtest ]

		  then

			   echo "PASS"

			   let passno=passno+1

		  else

			   echo "FAIL: Expected \"$PWD\", returned \"$oldcwd\\cdtest\""

			   let failno=failno+1

		  fi

	 else

		  echo "FAIL: Expected return value 0, but  returned $ret"

		  let failno=failno+1

	 fi

	 cd ..

else

	 echo "FAIL:cdtest dir missing"

	 let failno=failno+1

fi

}

# Change the current directory, and push the old current directory onto the directory stack

test_pushd1()

{

let totalno=totalno+1

echo "Test $totalno: pushd with directory name as argument"

if [ -d pushdtest ]

then

	 oldcwd=`pwd`

	 pushd pushdtest

	 ret=$?

	 if [ $ret = 0 ]

	 then

		  if [ $PWD = ${oldcwd}\pushdtest ]

		  then

			   echo "PASS"

			   let passno=passno+1

		  else

			   echo "FAIL: Expected \"$PWD\", returned \"${oldcwd}\pushdtest\""

			   let failno=failno+1

		  fi

	 else

		  echo "FAIL: Expected return value 0, but  returned $ret"

		  let failno=failno+1

 	fi

	popd

else

	 echo  "FAIL: Dir pushdtest does not exist."

	 let failno=failno+1

fi

}

# Remove an entry from the directory stack, and perform a cd to the new top directory

test_popd1()

{

let totalno=totalno+1

echo "Test $totalno: popd with no argument"

if [ -d popdtest ]

then

 	oldcwd=`pwd`

	pushd popdtest

 	popd

	if [ $ret = 0 ]

	then 

		  if [ $PWD = $oldcwd ]

		  then

			   echo "PASS"

			   let passno=passno+1  

		  else

			   echo "FAIL: popd failed: Expected \"$oldcwd\", returned  \"$PWD\""

               let failno=failno+1

  		  fi

	else

  		echo "FAIL: Popd failed: Expected return value 0, but  returned $ret"

	  	let failno=failno+1

	fi

else

 	echo "FAIL: dir popdtest doenot exist."

 	let failno=failno+1

fi

}

# With no arguments, print the contents of the directory stack

test_dirs1()

{

let totalno=totalno+1

echo "Test $totalno: dirs with -l option set"

if [ -d dirstest ]

then

	oldcwd=`pwd`

	pushd dirstest

	ret=$?

	if [ $ret = 0 ]

	then

		dirsarray=(`dirs -l`)

		ret=$?

        if [ $ret != 0 ]

		then

			echo "FAIL: dirs gave nonzero return value: $ret"

			let failno=failno+1

			popd

			return		

		else

			len=${#dirsarray[*]} #Number of elements in stack

			if [ $len != 2 ]

			then 

				echo "FAIL: dirs failed: Expected 2, but is ${len}"

				let failno=failno+1

				popd

				return

			else

				if [ ${dirsarray[1]} != ${oldcwd}\dirstest ] || [ ${dirsarray[2]} != ${oldcwd} ]   

				then

					echo "FAIL: dirs failed: Expected \"${oldcwd}\dirstest\" as the first string, but is \"${dirsarray[1]}\" or expected \"${oldcwd}\" as the second string, but is \"${dirsarray[2]}\""

					let failno=failno+1

					popd

					return

  				fi

			fi

		fi

	else

		echo "FAIL: Pushd failed: Expected return value 0, but  returned $ret"

		let failno=failno+1

	fi

 	popd

	dirsstr=`dirs -l`

	dirsarray=($dirsstr)

	if [ $ret = 0 ]

	then

		if [ ${dirsarray[1]} = $oldcwd ]

		then

 			echo "PASS"

			let passno=passno+1

		else

			echo "FAIL: dirs failed: Expected \"$oldcwd\", returned  \"${dirsarray[1]}\""

			let failno=failno+1

		fi

	else

		echo "FAIL: Popd failed: Expected return value 0, but  returned $ret"

		let failno=failno+1

	fi

	dirstr=`dirs`

else

	echo "FAIL: Dir dirstest does not exist"

	let failno=failno+1

fi

}

# For each name with a corresponding value, define an alias with that value.

test_alias1()

{

let totalno=totalno+1

echo "Test $totalno: alias with a variable name and a command as argument"

alias workdir="pwd"

ret=$?

if [ $ret = 0 ]

then

	 if [ `pwd` = `workdir` ]

	 then

		  echo "PASS"

		  let passno=passno+1

	 else

		  echo "FAIL: Expected \"`pwd`\", returned \"`workdir`\""

		  let failno=failno+1

	 fi

	 unalias workdir

else

	 echo "FAIL: Expected return value 0, but  returned $ret"

	 let failno=failno+1

fi

}

# causes unhash to remove regular or global aliases

test_unalias1()

{

let totalno=totalno+1

echo "Test $totalno: unalias with an existing alias name as argument"

alias workdir="pwd"

unalias workdir

ret=$?

if [ $ret = 0 ]

then

	workdir

    ret=$?

	if [ $ret != 127 ]

	then

		echo "FAIL: Expected cmd not found(127), returned $ret"

		let failno=failno+1

	else

		echo "PASS"

		let passno=passno+1

	fi

else

	 echo "FAIL: Expected return value 0, but  returned $ret"

	 let failno=failno+1

fi

}

# set positional parameters

# @internal test function

util_set1()

{

arg1=$1;arg2=$2;arg3=$3

old=(`echo $@`)

set a b c # Values directly to positional parameters

if [ $1 = a ] && [ $2 = b ] && [ $3 = c ]

then

	 ret=0

else

	 ret=1

	 return $ret

fi

echo "First set returned $ret"

set $old # Value from array to possitional parameters

if [ $1 = $arg1 ] && [ $2 = $arg2 ] && [ $3 = $arg3 ]

then

	 ret=0

else

	 ret=1

fi

echo "second set returned $ret"

return $ret

}

# Set the options for the shell and/or set the positional parameters, or declare and set an array

test_set1()

{

let totalno=totalno+1

echo "Test $totalno: set command to set positional parameters"

util_set1 x y z

ret=$?

if [ $ret = 0 ]

then

	echo "PASS"

	let passno=passno+1

else

	echo "FAIL: Expected 0, returned $ret"

	let failno=failno+1

fi

}

# Each named parameter is unset

test_unset1()

{

let totalno=totalno+1

echo "Test $totalno: unset command to unset array name"

unsetarray=(1 2 3)

unset unsetarray

ret=$?

if [ $ret = 0 ]

then

	if [ ${unsetarray[1]} ] || [ ${unsetarray[2]} ] || [ ${unsetarray[3]} ]

	then

	   	echo "FAIL: Expected empty strings as array elements, but were $unsetarray[1], $unsetarray[2], $unsetarray[3]"

       	let failno=failno+1

	else

		echo "PASS"

		let passno=passno+1

	fi

else

	echo "FAIL: Expected return value 0, returned $ret"

	let failno=failno+1

fi

}

# For each name, indicate how it would be interpreted if used as a command name.

test_which1()

{

let totalno=totalno+1

echo "Test $totalno: which with internal command name as argument"

which pwd

ret=$?

if [ $ret = 0 ]

then

	echo "PASS"

	let passno=passno+1

else

	echo "FAIL: Expected return value 0, returned $ret"

    let failno=failno+1

fi

}

# Read the arguments as input to the shell and execute the resulting command in the current shell process

test_eval1()

{

let totalno=totalno+1

echo "Test $totalno: eval to run a command"

evalvar=pwd

outputvar=`eval $evalvar`

ret=$?

if [ $ret = 0 ]

then

	if [ $PWD = $outputvar ]

    then

		echo "PASS"

    	let passno=passno+1

	else

		echo "FAIL: Expected $PWD, returned $outputvar"

    	let failno=failno+1

	fi

else