#!/bin/bash

# Author: Iain Douglas <centos@1n6.org.uk>

# Tests for diff

# Basic Tests

ExitFail() {

    t_Log "FAIL"

    exit $FAIL

}

t_Log "Running $0 - diff tests"

diff -v &>/dev/null 

t_CheckExitStatus $?

F1=/var/tmp/testf1.txt

F2=/var/tmp/testf2.txt

# Most of the following tests are taken from the examples in the info 

# documentation for diffutils.

# 

# Create a couple of files to work with. We'll use sed to make changes as we

# go.

TEXT="Here lyeth  muche rychnesse  in lytell space.   -- John Heywood" 

echo $TEXT >$F1

cp $F1 $F2

# Start by checking the options that determine how whitespace and case are

# handled -E -b -w -B -i -I -q and their long form variants

# Baseline check to ensure diff sees the files are the same.

echo "Check files are the same"

diff $F1 $F2

t_CheckExitStatus $?

# Convert a <space> to <space><tab> in F2 then check that diff sees the change

# as it should.

sed -i 's/ / \t/' $F2

echo "Check different files"

diff $F1 $F2  &>/dev/null && ExitFail

t_Log "PASS"

# Convert the first space in $F1 to 4 spaces and check that -E and  

# --ignore-tab-expansion works and sees no difference between the 

# two files.

echo "Check diff -E"

sed -i 's/ /    /' $F1

diff -E $F1 $F2

t_CheckExitStatus $?

echo "Check diff --ignore-tab-expansion"

diff --ignore-tab-expansion $F1 $F2

t_CheckExitStatus $?

# reduce the 4 spaces to 3 and check diff -E sees a difference

echo "Check diff -E sees a difference in whitespace"

sed -i 's/    /   /' $F1

diff -E $F1 $F2 &>/dev/null && ExitFail

t_Log "PASS"

# Check -b --ignore-space-change add some spaces to the end of the line

# to make sure.

sed -i 's/$/    /' $F1

echo "Check diff -b"  

diff -b $F1 $F2

t_CheckExitStatus $?

echo "Check diff --ignore-space-change"

diff --ignore-space-change $F1 $F2

t_CheckExitStatus $?

# The -b option ignotes difference in whitespace where it already exists.

# Check that whitespace added in $F1 where non exists in $F2 is caught by 

# -b

echo "Check diff -b sees whitespace where non exists"

sed -i 's/ss/s s/' $F1

diff -b $F1 $F2 &>/dev/null && ExitFail

t_Log "PASS"

# Check -w --ignore-all-space

echo "Check diff -w"

diff -w $F1 $F2

t_CheckExitStatus $?

echo "Check diff --ignore-all-space"

diff --ignore-all-space $F1 $F2

t_CheckExitStatus $?

# Check -B --ignore blank lines, create some new files to work with first.

echo $TEXT>$F1

echo $TEXT>>$F1

echo $TEXT>$F2

echo "" >>$F2

echo $TEXT>>$F2

# Check that diff sees the new test files are different.

echo "-B --ignore blank lines, pre check files are different"

diff $F1 $F2 &>/dev/null && ExitFail

t_Log "PASS"

echo "Check diff -B"

diff -B $F1 $F2

t_CheckExitStatus $?

echo "Check diff --ignore-blank-lines"

diff --ignore-blank-lines $F1 $F2

t_CheckExitStatus $? 

# Check -i --ignore-case, first ensure that diff sees a difference in case,

# as we're using the files from the earlier test we need to use the -B option

# too.

echo "Check test file is different"

sed -i 's/l/L/g' $F1

diff -B $F1 $F2 &>/dev/null && ExitFail

t_Log "PASS"

# Check that -i causes  diff to ignore the difference in case.

echo "Check diff -i"

diff -B -i $F1 $F2

t_CheckExitStatus $?

echo "Check diff --ignore-case"

diff -B --ignore-case $F1 $F2

t_CheckExitStatus $?

# Check -I --ignore-matching-lines=regexp

echo $TEXT >$F1

echo "1"$TEXT"1" >>$F1

echo "1"$TEXT >$F2

echo $TEXT >>$F2

echo "Check test files are different"

diff $F1 $F2 &>/dev/null && ExitFail

t_Log "PASS"

echo "Check -I"

diff -I '^[[:digit:]]'  $F1 $F2

t_CheckExitStatus $?

echo "Check --ignore-matching-lines=regexp"

diff --ignore-matching-lines='^[[:digit:]]' $F1 $F2

t_CheckExitStatus $?

# Check -q --brief

echo "Check diff -q"

diff -q $F1 $F2 | grep -q "Files /var/tmp/testf1.txt and /var/tmp/testf2.txt differ" 

t_CheckExitStatus $?

echo "diff --brief"

diff --brief $F1 $F2 | grep -q "Files /var/tmp/testf1.txt and /var/tmp/testf2.txt differ"

t_CheckExitStatus $?

# Check output formats are correct, again the examples from the info docs are

# used in the tests as are the lao and tzu texts. As we've previously testes 

# cmp it should be safe to use to compare the generated output against known 

# correct output.

#

# start with normal format

echo "Check diff output formats"

DIR=./tests/p_diffutils

FILES="$DIR"/files

echo "Check normal output format"

diff "$FILES"/lao "$FILES"/tzu | cmp "$FILES"/normal_format -

t_CheckExitStatus $?

# Check contxt format - note that this outputs time information that we will

# ignore by skipping the first 3 lines

echo Check default context format -c

diff -c "$FILES"/lao "$FILES"/tzu | tail -n +3 | cmp "$FILES"/context_format -

t_CheckExitStatus $? 

# Check contect format with only 1 line 

echo "Check context format with Less Context -C 1"

diff  -C 1 "$FILES"/lao "$FILES"/tzu | tail -n +3 | cmp "$FILES"/context_format-1 -

t_CheckExitStatus $?

# Check unified format again there are timestams which we will ignore

echo "Check unified format "

diff  -u "$FILES"/lao "$FILES"/tzu | tail -n +3 | cmp "$FILES"/unified_format -

t_CheckExitStatus $?

# Check unified shortend format -U lines and the long form option 

# --unified=lines, in both cases we'll use 1 for lines.

echo "Check unified output with less context -U 1"

diff  -U 1 "$FILES"/lao "$FILES"/tzu | tail -n +3 | cmp "$FILES"/unified_format-1 -

t_CheckExitStatus $?

echo "Check unified output with less context --unified=1"

diff  --unified=1 "$FILES"/lao "$FILES"/tzu | tail -n +3 | cmp "$FILES"/unified_format-1 -

t_CheckExitStatus $?

# Check we can change the labels

echo "Check the --label option"

diff -C 2 --label=original --label=modified "$FILES"/lao "$FILES"/tzu | cmp "$FILES"/label-change

t_CheckExitStatus $?

# Check side-by-side output width = 72

echo "Check side-by-side" output -y -W 72

diff -t -y -W 72 "$FILES"/lao "$FILES"/tzu | cmp "$FILES"/side-by-side-W72 -

t_CheckExitStatus $?

# Check side-by-side with left column suppression

echo "Check left column suppression in side-by-side output"

diff --width=72 -y --left-column "$FILES"/lao "$FILES"/tzu | cmp "$FILES"/left_column -t_CheckExitStatus $?

# Check side-by-side with common line  suppression

echo "Check left column suppression in side-by-side output"

diff --width=72 -y --suppress-common-lines "$FILES"/lao "$FILES"/tzu | cmp "$FILES"/supress_common_lines -

t_CheckExitStatus $?

# Check an ed script is correctly generated

echo "Check an ed script is correctly generated diff -e"

diff -e "$FILES"/lao "$FILES"/tzu | cmp "$FILES"/ed_script -

t_CheckExitStatus $?

# Check diff -f --forward-ed works

echo "Check that a forward ed script is generated -f "

diff -f "$FILES"/lao "$FILES"/tzu | cmp "$FILES"/ed_script-f -

t_CheckExitStatus $?

echo "Check that a forward ed script is generated --forward-ed "

diff --forward-ed "$FILES"/lao "$FILES"/tzu | cmp "$FILES"/ed_script-f -

t_CheckExitStatus $?

# Check RCS script generation -n --rcs

echo "Check RCS scripts are generated -n"

diff -n "$FILES"/lao "$FILES"/tzu | cmp "$FILES"/rcs_script -

t_CheckExitStatus $?

echo "Check RCS scripts are generated --rcs"

diff --rcs "$FILES"/lao "$FILES"/tzu | cmp "$FILES"/rcs_script -

t_CheckExitStatus $?

# Check if-then-else output diff -D --ifdef

echo "Check -D output"

diff -DTWO "$FILES"/lao "$FILES"/tzu | cmp "$FILES"/if_then_else -

t_CheckExitStatus $? 

echo "Check --ifdef output"

diff --ifdef=TWO "$FILES"/lao "$FILES"/tzu | cmp "$FILES"/if_then_else -

t_CheckExitStatus $?

# Check Incomplete last line (no \n)

echo "Checking incomplete last line - normal"

diff "$FILES"/F "$FILES"/G | cmp "$FILES"/F-G -

t_CheckExitStatus $?

echo "Checking incomplete last line -n"

diff -n "$FILES"/F "$FILES"/G | cmp "$FILES"/n_F-G -

t_CheckExitStatus $?

echo "Checking incomplete last line -e"

diff -e "$FILES"/F "$FILES"/G 2>&1  | cmp "$FILES"/e_F-G

t_CheckExitStatus $?

# Check diff output to -l --paginate, the header is variable so skip over it

echo "Check diff output to pager -l"

diff -l "$FILES"/lao "$FILES"/tzu |tail -n +4 | cmp "$FILES"/paginate -

t_CheckExitStatus $?

echo "Check diff output to pager -l"

diff -l "$FILES"/lao "$FILES"/tzu | tail -n +4 | cmp "$FILES"/paginate -

t_CheckExitStatus $?

# Directories tested from here down

# Setup a directory structure and populate it with files to work with

#

DIRTEST=/var/tmp/difftest

[[ -d "$DIRTEST" ]] && rm -r "$DIRTEST"

mkdir "$DIRTEST"

mkdir -p "$DIRTEST"/a/1

mkdir -p "$DIRTEST"/b/1

cp "$FILES"/lao "$DIRTEST"/a 

cp "$FILES"/lao "$DIRTEST"/b

cp "$FILES"/tzu "$DIRTEST"/a

cp "$FILES"/tao "$DIRTEST"/a/1

# Check plain diff of 2 directories

echo "Check basic directory comparison"

diff "$DIRTEST"/a "$DIRTEST"/b | cmp "$FILES"/dir -

t_CheckExitStatus $?

# Check -s --report-identical-files

echo "Check identical files reported -s"

diff -s "$DIRTEST"/a "$DIRTEST"/b | cmp "$FILES"/dir_s -

t_CheckExitStatus $?

echo "Check identical files reported --report-identical-files"

diff --report-identical-files "$DIRTEST"/a "$DIRTEST"/b | cmp "$FILES"/dir_s -

t_CheckExitStatus $?

# Check recursive directory diff

echo "Check recursive directory diff -r"

diff -sr "$DIRTEST"/a "$DIRTEST"/b | cmp "$FILES"/dir_r -

t_CheckExitStatus $?

echo "Check recursive directory diff --recursive"

diff -s --recursive "$DIRTEST"/a "$DIRTEST"/b | cmp "$FILES"/dir_r -

t_CheckExitStatus $?

# Check -N --new-file output

echo "Check directory diff -N"

diff -Nsr "$DIRTEST"/a "$DIRTEST"/b | cmp "$FILES"/dir_N -

t_CheckExitStatus $?

echo "Check directory diff --new-file"

diff --new-file -sr "$DIRTEST"/a "$DIRTEST"/b | cmp  "$FILES"/dir_new_file -

t_CheckExitStatus $? 

# Check diff --unidirectional-new-file. Swap the command line arguments

# around to make this work 

echo "Check directory diff --unidirectional-new-file"

diff --unidirectional-new-file "$DIRTEST"/b "$DIRTEST"/a | cmp  "$FILES"/dir_unidirectional -

t_CheckExitStatus $?

# Check we can ignore patterns with diff in directory mode -x 

echo "Check diff -x excludes file patterns"

diff -x tz* "$DIRTEST"/a "$DIRTEST"/b | cmp  "$FILES"/dir_x -

t_CheckExitStatus $?

# Check we can ignore patterns read from a file with diff in directory mode 

# -X --exclude-from=

echo "Check diff -X excludes file patterns"

diff -X "$FILES"/exclude "$DIRTEST"/a "$DIRTEST"/b | cmp  "$FILES"/dir_x -

t_CheckExitStatus $?

echo "Check diff --exclude-from excludes file patterns"

diff --exclude-from="$FILES"/exclude "$DIRTEST"/a "$DIRTEST"/b | cmp  "$FILES"/dir_x -

t_CheckExitStatus $?

# Check we can exclude differences based on file name case

# https://bugzilla.redhat.com/show_bug.cgi?id=719001

# 

mv "$DIRTEST"/a/lao "$DIRTEST"/a/LAO

echo "Checking --ignore-file-name-case"

echo "see https://bugzilla.redhat.com/show_bug.cgi?id=719001"

echo "If this fails then the bug has been fixed"

diff --ignore-file-name-case "$DIRTEST"/a "$DIRTEST"/b | cmp "$FILES"/dir_case

t_CheckExitStatus $?

# Check the --to-file option

echo "Checking the --to-file option against a file"

diff --to-file $FILES/lao $DIRTEST/a/LAO

t_CheckExitStatus $?

echo "Checking the --to-file option against a directory"

diff --to-file $FILES/lao $DIRTEST/b

t_CheckExitStatus $?

rm -f "$F1"

rm -f "$F2"

rm -r "$DIRTEST"