#!/bin/sh
#
# Copyright (c) 2012 SZEDER Gábor
#

global test_description := ''test git-specific bash prompt functions''

source ./lib-bash.sh

source "$GIT_BUILD_DIR/contrib/completion/git-prompt.sh"

global actual := ""$TRASH_DIRECTORY/actual""
global c_red := ''\\[\\e[31m\\]''
global c_green := ''\\[\\e[32m\\]''
global c_lblue := ''\\[\\e[1;34m\\]''
global c_clear := ''\\[\\e[0m\\]''

test_expect_success 'setup for prompt tests' '
	git init otherrepo &&
	echo 1 >file &&
	git add file &&
	test_tick &&
	git commit -m initial &&
	git tag -a -m msg1 t1 &&
	git checkout -b b1 &&
	echo 2 >file &&
	git commit -m "second b1" file &&
	echo 3 >file &&
	git commit -m "third b1" file &&
	git tag -a -m msg2 t2 &&
	git checkout -b b2 master &&
	echo 0 >file &&
	git commit -m "second b2" file &&
	echo 00 >file &&
	git commit -m "another b2" file &&
	echo 000 >file &&
	git commit -m "yet another b2" file &&
	mkdir ignored_dir &&
	echo "ignored_dir/" >>.gitignore &&
	git checkout master
'

test_expect_success 'prompt - branch name' '
	printf " (master)" >expected &&
	__git_ps1 >"$actual" &&
	test_cmp expected "$actual"
'

test_expect_success SYMLINKS 'prompt - branch name - symlink symref' '
	printf " (master)" >expected &&
	test_when_finished "git checkout master" &&
	test_config core.preferSymlinkRefs true &&
	git checkout master &&
	__git_ps1 >"$actual" &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - unborn branch' '
	printf " (unborn)" >expected &&
	git checkout --orphan unborn &&
	test_when_finished "git checkout master" &&
	__git_ps1 >"$actual" &&
	test_cmp expected "$actual"
'

global repo_with_newline := ''repo
with
newline''

if test_have_prereq !MINGW && mkdir $repo_with_newline !2 >/dev/null
{
	test_set_prereq FUNNYNAMES
} else {
	say 'Your filesystem does not allow newlines in filenames.'
}

test_expect_success FUNNYNAMES 'prompt - with newline in path' '
	printf " (master)" >expected &&
	git init "$repo_with_newline" &&
	test_when_finished "rm -rf \"$repo_with_newline\"" &&
	mkdir "$repo_with_newline"/subdir &&
	(
		cd "$repo_with_newline/subdir" &&
		__git_ps1 >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - detached head' '
	printf " ((%s...))" $(git log -1 --format="%h" --abbrev=13 b1^) >expected &&
	test_config core.abbrev 13 &&
	git checkout b1^ &&
	test_when_finished "git checkout master" &&
	__git_ps1 >"$actual" &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - describe detached head - contains' '
	printf " ((t2~1))" >expected &&
	git checkout b1^ &&
	test_when_finished "git checkout master" &&
	(
		GIT_PS1_DESCRIBE_STYLE=contains &&
		__git_ps1 >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - describe detached head - branch' '
	printf " ((tags/t2~1))" >expected &&
	git checkout b1^ &&
	test_when_finished "git checkout master" &&
	(
		GIT_PS1_DESCRIBE_STYLE=branch &&
		__git_ps1 >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - describe detached head - describe' '
	printf " ((t1-1-g%s))" $(git log -1 --format="%h" b1^) >expected &&
	git checkout b1^ &&
	test_when_finished "git checkout master" &&
	(
		GIT_PS1_DESCRIBE_STYLE=describe &&
		__git_ps1 >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - describe detached head - default' '
	printf " ((t2))" >expected &&
	git checkout --detach b1 &&
	test_when_finished "git checkout master" &&
	__git_ps1 >"$actual" &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - inside .git directory' '
	printf " (GIT_DIR!)" >expected &&
	(
		cd .git &&
		__git_ps1 >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - deep inside .git directory' '
	printf " (GIT_DIR!)" >expected &&
	(
		cd .git/refs/heads &&
		__git_ps1 >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - inside bare repository' '
	printf " (BARE:master)" >expected &&
	git init --bare bare.git &&
	test_when_finished "rm -rf bare.git" &&
	(
		cd bare.git &&
		__git_ps1 >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - interactive rebase' '
	printf " (b1|REBASE-i 2/3)" >expected &&
	write_script fake_editor.sh <<-\EOF &&
		echo "exec echo" >"$1"
		echo "edit $(git log -1 --format="%h")" >>"$1"
		echo "exec echo" >>"$1"
	EOF
	test_when_finished "rm -f fake_editor.sh" &&
	test_set_editor "$TRASH_DIRECTORY/fake_editor.sh" &&
	git checkout b1 &&
	test_when_finished "git checkout master" &&
	git rebase -i HEAD^ &&
	test_when_finished "git rebase --abort" &&
	__git_ps1 >"$actual" &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - rebase merge' '
	printf " (b2|REBASE-m 1/3)" >expected &&
	git checkout b2 &&
	test_when_finished "git checkout master" &&
	test_must_fail git rebase --merge b1 b2 &&
	test_when_finished "git rebase --abort" &&
	__git_ps1 >"$actual" &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - rebase' '
	printf " (b2|REBASE 1/3)" >expected &&
	git checkout b2 &&
	test_when_finished "git checkout master" &&
	test_must_fail git rebase b1 b2 &&
	test_when_finished "git rebase --abort" &&
	__git_ps1 >"$actual" &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - merge' '
	printf " (b1|MERGING)" >expected &&
	git checkout b1 &&
	test_when_finished "git checkout master" &&
	test_must_fail git merge b2 &&
	test_when_finished "git reset --hard" &&
	__git_ps1 >"$actual" &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - cherry-pick' '
	printf " (master|CHERRY-PICKING)" >expected &&
	test_must_fail git cherry-pick b1 &&
	test_when_finished "git reset --hard" &&
	__git_ps1 >"$actual" &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - bisect' '
	printf " (master|BISECTING)" >expected &&
	git bisect start &&
	test_when_finished "git bisect reset" &&
	__git_ps1 >"$actual" &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - dirty status indicator - clean' '
	printf " (master)" >expected &&
	(
		GIT_PS1_SHOWDIRTYSTATE=y &&
		__git_ps1 >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - dirty status indicator - dirty worktree' '
	printf " (master *)" >expected &&
	echo "dirty" >file &&
	test_when_finished "git reset --hard" &&
	(
		GIT_PS1_SHOWDIRTYSTATE=y &&
		__git_ps1 >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - dirty status indicator - dirty index' '
	printf " (master +)" >expected &&
	echo "dirty" >file &&
	test_when_finished "git reset --hard" &&
	git add -u &&
	(
		GIT_PS1_SHOWDIRTYSTATE=y &&
		__git_ps1 >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - dirty status indicator - dirty index and worktree' '
	printf " (master *+)" >expected &&
	echo "dirty index" >file &&
	test_when_finished "git reset --hard" &&
	git add -u &&
	echo "dirty worktree" >file &&
	(
		GIT_PS1_SHOWDIRTYSTATE=y &&
		__git_ps1 >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - dirty status indicator - orphan branch - clean' '
	printf " (orphan #)" >expected &&
	test_when_finished "git checkout master" &&
	git checkout --orphan orphan &&
	git reset --hard &&
	(
		GIT_PS1_SHOWDIRTYSTATE=y &&
		__git_ps1 >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - dirty status indicator - orphan branch - dirty index' '
	printf " (orphan +)" >expected &&
	test_when_finished "git checkout master" &&
	git checkout --orphan orphan &&
	(
		GIT_PS1_SHOWDIRTYSTATE=y &&
		__git_ps1 >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - dirty status indicator - orphan branch - dirty index and worktree' '
	printf " (orphan *+)" >expected &&
	test_when_finished "git checkout master" &&
	git checkout --orphan orphan &&
	>file &&
	(
		GIT_PS1_SHOWDIRTYSTATE=y &&
		__git_ps1 >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - dirty status indicator - shell variable unset with config disabled' '
	printf " (master)" >expected &&
	echo "dirty" >file &&
	test_when_finished "git reset --hard" &&
	test_config bash.showDirtyState false &&
	(
		sane_unset GIT_PS1_SHOWDIRTYSTATE &&
		__git_ps1 >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - dirty status indicator - shell variable unset with config enabled' '
	printf " (master)" >expected &&
	echo "dirty" >file &&
	test_when_finished "git reset --hard" &&
	test_config bash.showDirtyState true &&
	(
		sane_unset GIT_PS1_SHOWDIRTYSTATE &&
		__git_ps1 >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - dirty status indicator - shell variable set with config disabled' '
	printf " (master)" >expected &&
	echo "dirty" >file &&
	test_when_finished "git reset --hard" &&
	test_config bash.showDirtyState false &&
	(
		GIT_PS1_SHOWDIRTYSTATE=y &&
		__git_ps1 >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - dirty status indicator - shell variable set with config enabled' '
	printf " (master *)" >expected &&
	echo "dirty" >file &&
	test_when_finished "git reset --hard" &&
	test_config bash.showDirtyState true &&
	(
		GIT_PS1_SHOWDIRTYSTATE=y &&
		__git_ps1 >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - dirty status indicator - not shown inside .git directory' '
	printf " (GIT_DIR!)" >expected &&
	echo "dirty" >file &&
	test_when_finished "git reset --hard" &&
	(
		GIT_PS1_SHOWDIRTYSTATE=y &&
		cd .git &&
		__git_ps1 >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - stash status indicator - no stash' '
	printf " (master)" >expected &&
	(
		GIT_PS1_SHOWSTASHSTATE=y &&
		__git_ps1 >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - stash status indicator - stash' '
	printf " (master $)" >expected &&
	echo 2 >file &&
	git stash &&
	test_when_finished "git stash drop" &&
	git pack-refs --all &&
	(
		GIT_PS1_SHOWSTASHSTATE=y &&
		__git_ps1 >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - stash status indicator - not shown inside .git directory' '
	printf " (GIT_DIR!)" >expected &&
	echo 2 >file &&
	git stash &&
	test_when_finished "git stash drop" &&
	(
		GIT_PS1_SHOWSTASHSTATE=y &&
		cd .git &&
		__git_ps1 >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - untracked files status indicator - no untracked files' '
	printf " (master)" >expected &&
	(
		GIT_PS1_SHOWUNTRACKEDFILES=y &&
		cd otherrepo &&
		__git_ps1 >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - untracked files status indicator - untracked files' '
	printf " (master %%)" >expected &&
	(
		GIT_PS1_SHOWUNTRACKEDFILES=y &&
		__git_ps1 >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - untracked files status indicator - empty untracked dir' '
	printf " (master)" >expected &&
	mkdir otherrepo/untracked-dir &&
	test_when_finished "rm -rf otherrepo/untracked-dir" &&
	(
		GIT_PS1_SHOWUNTRACKEDFILES=y &&
		cd otherrepo &&
		__git_ps1 >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - untracked files status indicator - non-empty untracked dir' '
	printf " (master %%)" >expected &&
	mkdir otherrepo/untracked-dir &&
	test_when_finished "rm -rf otherrepo/untracked-dir" &&
	>otherrepo/untracked-dir/untracked-file &&
	(
		GIT_PS1_SHOWUNTRACKEDFILES=y &&
		cd otherrepo &&
		__git_ps1 >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - untracked files status indicator - untracked files outside cwd' '
	printf " (master %%)" >expected &&
	(
		mkdir -p ignored_dir &&
		cd ignored_dir &&
		GIT_PS1_SHOWUNTRACKEDFILES=y &&
		__git_ps1 >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - untracked files status indicator - shell variable unset with config disabled' '
	printf " (master)" >expected &&
	test_config bash.showUntrackedFiles false &&
	(
		sane_unset GIT_PS1_SHOWUNTRACKEDFILES &&
		__git_ps1 >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - untracked files status indicator - shell variable unset with config enabled' '
	printf " (master)" >expected &&
	test_config bash.showUntrackedFiles true &&
	(
		sane_unset GIT_PS1_SHOWUNTRACKEDFILES &&
		__git_ps1 >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - untracked files status indicator - shell variable set with config disabled' '
	printf " (master)" >expected &&
	test_config bash.showUntrackedFiles false &&
	(
		GIT_PS1_SHOWUNTRACKEDFILES=y &&
		__git_ps1 >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - untracked files status indicator - shell variable set with config enabled' '
	printf " (master %%)" >expected &&
	test_config bash.showUntrackedFiles true &&
	(
		GIT_PS1_SHOWUNTRACKEDFILES=y &&
		__git_ps1 >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - untracked files status indicator - not shown inside .git directory' '
	printf " (GIT_DIR!)" >expected &&
	(
		GIT_PS1_SHOWUNTRACKEDFILES=y &&
		cd .git &&
		__git_ps1 >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - format string starting with dash' '
	printf -- "-master" >expected &&
	__git_ps1 "-%s" >"$actual" &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - pc mode' '
	printf "BEFORE: (\${__git_ps1_branch_name}):AFTER\\nmaster" >expected &&
	printf "" >expected_output &&
	(
		__git_ps1 "BEFORE:" ":AFTER" >"$actual" &&
		test_cmp expected_output "$actual" &&
		printf "%s\\n%s" "$PS1" "${__git_ps1_branch_name}" >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - bash color pc mode - branch name' '
	printf "BEFORE: (${c_green}\${__git_ps1_branch_name}${c_clear}):AFTER\\nmaster" >expected &&
	(
		GIT_PS1_SHOWCOLORHINTS=y &&
		__git_ps1 "BEFORE:" ":AFTER" >"$actual"
		printf "%s\\n%s" "$PS1" "${__git_ps1_branch_name}" >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - bash color pc mode - detached head' '
	printf "BEFORE: (${c_red}\${__git_ps1_branch_name}${c_clear}):AFTER\\n(%s...)" $(git log -1 --format="%h" b1^) >expected &&
	git checkout b1^ &&
	test_when_finished "git checkout master" &&
	(
		GIT_PS1_SHOWCOLORHINTS=y &&
		__git_ps1 "BEFORE:" ":AFTER" &&
		printf "%s\\n%s" "$PS1" "${__git_ps1_branch_name}" >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - bash color pc mode - dirty status indicator - dirty worktree' '
	printf "BEFORE: (${c_green}\${__git_ps1_branch_name}${c_clear} ${c_red}*${c_clear}):AFTER\\nmaster" >expected &&
	echo "dirty" >file &&
	test_when_finished "git reset --hard" &&
	(
		GIT_PS1_SHOWDIRTYSTATE=y &&
		GIT_PS1_SHOWCOLORHINTS=y &&
		__git_ps1 "BEFORE:" ":AFTER" &&
		printf "%s\\n%s" "$PS1" "${__git_ps1_branch_name}" >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - bash color pc mode - dirty status indicator - dirty index' '
	printf "BEFORE: (${c_green}\${__git_ps1_branch_name}${c_clear} ${c_green}+${c_clear}):AFTER\\nmaster" >expected &&
	echo "dirty" >file &&
	test_when_finished "git reset --hard" &&
	git add -u &&
	(
		GIT_PS1_SHOWDIRTYSTATE=y &&
		GIT_PS1_SHOWCOLORHINTS=y &&
		__git_ps1 "BEFORE:" ":AFTER" &&
		printf "%s\\n%s" "$PS1" "${__git_ps1_branch_name}" >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - bash color pc mode - dirty status indicator - dirty index and worktree' '
	printf "BEFORE: (${c_green}\${__git_ps1_branch_name}${c_clear} ${c_red}*${c_green}+${c_clear}):AFTER\\nmaster" >expected &&
	echo "dirty index" >file &&
	test_when_finished "git reset --hard" &&
	git add -u &&
	echo "dirty worktree" >file &&
	(
		GIT_PS1_SHOWCOLORHINTS=y &&
		GIT_PS1_SHOWDIRTYSTATE=y &&
		__git_ps1 "BEFORE:" ":AFTER" &&
		printf "%s\\n%s" "$PS1" "${__git_ps1_branch_name}" >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - bash color pc mode - dirty status indicator - before root commit' '
	printf "BEFORE: (${c_green}\${__git_ps1_branch_name}${c_clear} ${c_green}#${c_clear}):AFTER\\nmaster" >expected &&
	(
		GIT_PS1_SHOWDIRTYSTATE=y &&
		GIT_PS1_SHOWCOLORHINTS=y &&
		cd otherrepo &&
		__git_ps1 "BEFORE:" ":AFTER" &&
		printf "%s\\n%s" "$PS1" "${__git_ps1_branch_name}" >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - bash color pc mode - inside .git directory' '
	printf "BEFORE: (${c_green}\${__git_ps1_branch_name}${c_clear}):AFTER\\nGIT_DIR!" >expected &&
	echo "dirty" >file &&
	test_when_finished "git reset --hard" &&
	(
		GIT_PS1_SHOWDIRTYSTATE=y &&
		GIT_PS1_SHOWCOLORHINTS=y &&
		cd .git &&
		__git_ps1 "BEFORE:" ":AFTER" &&
		printf "%s\\n%s" "$PS1" "${__git_ps1_branch_name}" >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - bash color pc mode - stash status indicator' '
	printf "BEFORE: (${c_green}\${__git_ps1_branch_name}${c_clear} ${c_lblue}\$${c_clear}):AFTER\\nmaster" >expected &&
	echo 2 >file &&
	git stash &&
	test_when_finished "git stash drop" &&
	(
		GIT_PS1_SHOWSTASHSTATE=y &&
		GIT_PS1_SHOWCOLORHINTS=y &&
		__git_ps1 "BEFORE:" ":AFTER" &&
		printf "%s\\n%s" "$PS1" "${__git_ps1_branch_name}" >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - bash color pc mode - untracked files status indicator' '
	printf "BEFORE: (${c_green}\${__git_ps1_branch_name}${c_clear} ${c_red}%%${c_clear}):AFTER\\nmaster" >expected &&
	(
		GIT_PS1_SHOWUNTRACKEDFILES=y &&
		GIT_PS1_SHOWCOLORHINTS=y &&
		__git_ps1 "BEFORE:" ":AFTER" &&
		printf "%s\\n%s" "$PS1" "${__git_ps1_branch_name}" >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - zsh color pc mode' '
	printf "BEFORE: (%%F{green}master%%f):AFTER" >expected &&
	(
		ZSH_VERSION=5.0.0 &&
		GIT_PS1_SHOWCOLORHINTS=y &&
		__git_ps1 "BEFORE:" ":AFTER" &&
		printf "%s" "$PS1" >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - hide if pwd ignored - env var unset, config disabled' '
	printf " (master)" >expected &&
	test_config bash.hideIfPwdIgnored false &&
	(
		cd ignored_dir &&
		__git_ps1 >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - hide if pwd ignored - env var unset, config disabled, pc mode' '
	printf "BEFORE: (\${__git_ps1_branch_name}):AFTER" >expected &&
	test_config bash.hideIfPwdIgnored false &&
	(
		cd ignored_dir &&
		__git_ps1 "BEFORE:" ":AFTER" &&
		printf "%s" "$PS1" >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - hide if pwd ignored - env var unset, config unset' '
	printf " (master)" >expected &&
	(
		cd ignored_dir &&
		__git_ps1 >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - hide if pwd ignored - env var unset, config unset, pc mode' '
	printf "BEFORE: (\${__git_ps1_branch_name}):AFTER" >expected &&
	(
		cd ignored_dir &&
		__git_ps1 "BEFORE:" ":AFTER" &&
		printf "%s" "$PS1" >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - hide if pwd ignored - env var set, config disabled' '
	printf " (master)" >expected &&
	test_config bash.hideIfPwdIgnored false &&
	(
		cd ignored_dir &&
		GIT_PS1_HIDE_IF_PWD_IGNORED=y &&
		__git_ps1 >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - hide if pwd ignored - env var set, config disabled, pc mode' '
	printf "BEFORE: (\${__git_ps1_branch_name}):AFTER" >expected &&
	test_config bash.hideIfPwdIgnored false &&
	(
		cd ignored_dir &&
		GIT_PS1_HIDE_IF_PWD_IGNORED=y &&
		__git_ps1 "BEFORE:" ":AFTER" &&
		printf "%s" "$PS1" >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - hide if pwd ignored - env var set, config unset' '
	printf "" >expected &&
	(
		cd ignored_dir &&
		GIT_PS1_HIDE_IF_PWD_IGNORED=y &&
		__git_ps1 >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - hide if pwd ignored - env var set, config unset, pc mode' '
	printf "BEFORE::AFTER" >expected &&
	(
		cd ignored_dir &&
		GIT_PS1_HIDE_IF_PWD_IGNORED=y &&
		__git_ps1 "BEFORE:" ":AFTER" &&
		printf "%s" "$PS1" >"$actual"
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - hide if pwd ignored - inside gitdir (stdout)' '
	printf " (GIT_DIR!)" >expected &&
	(
		GIT_PS1_HIDE_IF_PWD_IGNORED=y &&
		cd .git &&
		__git_ps1 >"$actual" 2>/dev/null
	) &&
	test_cmp expected "$actual"
'

test_expect_success 'prompt - hide if pwd ignored - inside gitdir (stderr)' '
	printf "" >expected &&
	(
		GIT_PS1_HIDE_IF_PWD_IGNORED=y &&
		cd .git &&
		__git_ps1 >/dev/null 2>"$actual"
	) &&
	test_cmp expected "$actual"
'

test_done
(CommandList
  children: [
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:test_description)
          op: Equal
          rhs: {(SQ <"test git-specific bash prompt functions">)}
          spids: [13]
        )
      ]
      spids: [13]
    )
    (C {(.)} {(./lib-bash.sh)})
    (C {(.)} {(DQ ($ VSub_Name "$GIT_BUILD_DIR") (/contrib/completion/git-prompt.sh))})
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:actual)
          op: Equal
          rhs: {(DQ ($ VSub_Name "$TRASH_DIRECTORY") (/actual))}
          spids: [32]
        )
      ]
      spids: [32]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:c_red)
          op: Equal
          rhs: {(SQ <"\\\\[\\\\e[31m\\\\]">)}
          spids: [38]
        )
      ]
      spids: [38]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:c_green)
          op: Equal
          rhs: {(SQ <"\\\\[\\\\e[32m\\\\]">)}
          spids: [43]
        )
      ]
      spids: [43]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:c_lblue)
          op: Equal
          rhs: {(SQ <"\\\\[\\\\e[1;34m\\\\]">)}
          spids: [48]
        )
      ]
      spids: [48]
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:c_clear)
          op: Equal
          rhs: {(SQ <"\\\\[\\\\e[0m\\\\]">)}
          spids: [53]
        )
      ]
      spids: [53]
    )
    (C {(test_expect_success)} {(SQ <"setup for prompt tests">)} 
      {
        (SQ <"\n"> <"\tgit init otherrepo &&\n"> <"\techo 1 >file &&\n"> <"\tgit add file &&\n"> 
          <"\ttest_tick &&\n"> <"\tgit commit -m initial &&\n"> <"\tgit tag -a -m msg1 t1 &&\n"> <"\tgit checkout -b b1 &&\n"> 
          <"\techo 2 >file &&\n"> <"\tgit commit -m \"second b1\" file &&\n"> <"\techo 3 >file &&\n"> 
          <"\tgit commit -m \"third b1\" file &&\n"> <"\tgit tag -a -m msg2 t2 &&\n"> <"\tgit checkout -b b2 master &&\n"> <"\techo 0 >file &&\n"> 
          <"\tgit commit -m \"second b2\" file &&\n"> <"\techo 00 >file &&\n"> <"\tgit commit -m \"another b2\" file &&\n"> <"\techo 000 >file &&\n"> 
          <"\tgit commit -m \"yet another b2\" file &&\n"> <"\tmkdir ignored_dir &&\n"> <"\techo \"ignored_dir/\" >>.gitignore &&\n"> <"\tgit checkout master\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"prompt - branch name">)} 
      {
        (SQ <"\n"> <"\tprintf \" (master)\" >expected &&\n"> <"\t__git_ps1 >\"$actual\" &&\n"> 
          <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SYMLINKS)} {(SQ <"prompt - branch name - symlink symref">)} 
      {
        (SQ <"\n"> <"\tprintf \" (master)\" >expected &&\n"> 
          <"\ttest_when_finished \"git checkout master\" &&\n"> <"\ttest_config core.preferSymlinkRefs true &&\n"> <"\tgit checkout master &&\n"> 
          <"\t__git_ps1 >\"$actual\" &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"prompt - unborn branch">)} 
      {
        (SQ <"\n"> <"\tprintf \" (unborn)\" >expected &&\n"> <"\tgit checkout --orphan unborn &&\n"> 
          <"\ttest_when_finished \"git checkout master\" &&\n"> <"\t__git_ps1 >\"$actual\" &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (Assignment
      keyword: Assign_None
      pairs: [
        (assign_pair
          lhs: (LhsName name:repo_with_newline)
          op: Equal
          rhs: {(SQ <"repo\n"> <"with\n"> <newline>)}
          spids: [141]
        )
      ]
      spids: [141]
    )
    (If
      arms: [
        (if_arm
          cond: [
            (AndOr
              children: [
                (C {(test_have_prereq)} {(KW_Bang "!") (MINGW)})
                (SimpleCommand
                  words: [{(mkdir)} {(DQ ($ VSub_Name "$repo_with_newline"))}]
                  redirects: [(Redir op_id:Redir_Great fd:2 arg_word:{(/dev/null)} spids:[164])]
                )
              ]
              op_id: Op_DAmp
            )
          ]
          action: [(C {(test_set_prereq)} {(FUNNYNAMES)})]
          spids: [-1 167]
        )
      ]
      else_action: [(C {(say)} {(SQ <"Your filesystem does not allow newlines in filenames.">)})]
      spids: [174 183]
    )
    (C {(test_expect_success)} {(FUNNYNAMES)} {(SQ <"prompt - with newline in path">)} 
      {
        (SQ <"\n"> <"\tprintf \" (master)\" >expected &&\n"> <"\tgit init \"$repo_with_newline\" &&\n"> 
          <"\ttest_when_finished \"rm -rf \\\"$repo_with_newline\\\"\" &&\n"> <"\tmkdir \"$repo_with_newline\"/subdir &&\n"> <"\t(\n"> <"\t\tcd \"$repo_with_newline/subdir\" &&\n"> 
          <"\t\t__git_ps1 >\"$actual\"\n"> <"\t) &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"prompt - detached head">)} 
      {
        (SQ <"\n"> 
          <"\tprintf \" ((%s...))\" $(git log -1 --format=\"%h\" --abbrev=13 b1^) >expected &&\n"> <"\ttest_config core.abbrev 13 &&\n"> <"\tgit checkout b1^ &&\n"> 
          <"\ttest_when_finished \"git checkout master\" &&\n"> <"\t__git_ps1 >\"$actual\" &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"prompt - describe detached head - contains">)} 
      {
        (SQ <"\n"> <"\tprintf \" ((t2~1))\" >expected &&\n"> <"\tgit checkout b1^ &&\n"> 
          <"\ttest_when_finished \"git checkout master\" &&\n"> <"\t(\n"> <"\t\tGIT_PS1_DESCRIBE_STYLE=contains &&\n"> <"\t\t__git_ps1 >\"$actual\"\n"> <"\t) &&\n"> 
          <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"prompt - describe detached head - branch">)} 
      {
        (SQ <"\n"> <"\tprintf \" ((tags/t2~1))\" >expected &&\n"> <"\tgit checkout b1^ &&\n"> 
          <"\ttest_when_finished \"git checkout master\" &&\n"> <"\t(\n"> <"\t\tGIT_PS1_DESCRIBE_STYLE=branch &&\n"> <"\t\t__git_ps1 >\"$actual\"\n"> <"\t) &&\n"> 
          <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"prompt - describe detached head - describe">)} 
      {
        (SQ <"\n"> <"\tprintf \" ((t1-1-g%s))\" $(git log -1 --format=\"%h\" b1^) >expected &&\n"> 
          <"\tgit checkout b1^ &&\n"> <"\ttest_when_finished \"git checkout master\" &&\n"> <"\t(\n"> 
          <"\t\tGIT_PS1_DESCRIBE_STYLE=describe &&\n"> <"\t\t__git_ps1 >\"$actual\"\n"> <"\t) &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"prompt - describe detached head - default">)} 
      {
        (SQ <"\n"> <"\tprintf \" ((t2))\" >expected &&\n"> <"\tgit checkout --detach b1 &&\n"> 
          <"\ttest_when_finished \"git checkout master\" &&\n"> <"\t__git_ps1 >\"$actual\" &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"prompt - inside .git directory">)} 
      {
        (SQ <"\n"> <"\tprintf \" (GIT_DIR!)\" >expected &&\n"> <"\t(\n"> <"\t\tcd .git &&\n"> 
          <"\t\t__git_ps1 >\"$actual\"\n"> <"\t) &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"prompt - deep inside .git directory">)} 
      {
        (SQ <"\n"> <"\tprintf \" (GIT_DIR!)\" >expected &&\n"> <"\t(\n"> <"\t\tcd .git/refs/heads &&\n"> 
          <"\t\t__git_ps1 >\"$actual\"\n"> <"\t) &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"prompt - inside bare repository">)} 
      {
        (SQ <"\n"> <"\tprintf \" (BARE:master)\" >expected &&\n"> <"\tgit init --bare bare.git &&\n"> 
          <"\ttest_when_finished \"rm -rf bare.git\" &&\n"> <"\t(\n"> <"\t\tcd bare.git &&\n"> <"\t\t__git_ps1 >\"$actual\"\n"> <"\t) &&\n"> 
          <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"prompt - interactive rebase">)} 
      {
        (SQ <"\n"> <"\tprintf \" (b1|REBASE-i 2/3)\" >expected &&\n"> 
          <"\twrite_script fake_editor.sh <<-\\EOF &&\n"> <"\t\techo \"exec echo\" >\"$1\"\n"> <"\t\techo \"edit $(git log -1 --format=\"%h\")\" >>\"$1\"\n"> 
          <"\t\techo \"exec echo\" >>\"$1\"\n"> <"\tEOF\n"> <"\ttest_when_finished \"rm -f fake_editor.sh\" &&\n"> 
          <"\ttest_set_editor \"$TRASH_DIRECTORY/fake_editor.sh\" &&\n"> <"\tgit checkout b1 &&\n"> <"\ttest_when_finished \"git checkout master\" &&\n"> 
          <"\tgit rebase -i HEAD^ &&\n"> <"\ttest_when_finished \"git rebase --abort\" &&\n"> <"\t__git_ps1 >\"$actual\" &&\n"> 
          <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"prompt - rebase merge">)} 
      {
        (SQ <"\n"> <"\tprintf \" (b2|REBASE-m 1/3)\" >expected &&\n"> <"\tgit checkout b2 &&\n"> 
          <"\ttest_when_finished \"git checkout master\" &&\n"> <"\ttest_must_fail git rebase --merge b1 b2 &&\n"> 
          <"\ttest_when_finished \"git rebase --abort\" &&\n"> <"\t__git_ps1 >\"$actual\" &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"prompt - rebase">)} 
      {
        (SQ <"\n"> <"\tprintf \" (b2|REBASE 1/3)\" >expected &&\n"> <"\tgit checkout b2 &&\n"> 
          <"\ttest_when_finished \"git checkout master\" &&\n"> <"\ttest_must_fail git rebase b1 b2 &&\n"> <"\ttest_when_finished \"git rebase --abort\" &&\n"> 
          <"\t__git_ps1 >\"$actual\" &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"prompt - merge">)} 
      {
        (SQ <"\n"> <"\tprintf \" (b1|MERGING)\" >expected &&\n"> <"\tgit checkout b1 &&\n"> 
          <"\ttest_when_finished \"git checkout master\" &&\n"> <"\ttest_must_fail git merge b2 &&\n"> <"\ttest_when_finished \"git reset --hard\" &&\n"> 
          <"\t__git_ps1 >\"$actual\" &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"prompt - cherry-pick">)} 
      {
        (SQ <"\n"> <"\tprintf \" (master|CHERRY-PICKING)\" >expected &&\n"> 
          <"\ttest_must_fail git cherry-pick b1 &&\n"> <"\ttest_when_finished \"git reset --hard\" &&\n"> <"\t__git_ps1 >\"$actual\" &&\n"> 
          <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"prompt - bisect">)} 
      {
        (SQ <"\n"> <"\tprintf \" (master|BISECTING)\" >expected &&\n"> <"\tgit bisect start &&\n"> 
          <"\ttest_when_finished \"git bisect reset\" &&\n"> <"\t__git_ps1 >\"$actual\" &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"prompt - dirty status indicator - clean">)} 
      {
        (SQ <"\n"> <"\tprintf \" (master)\" >expected &&\n"> <"\t(\n"> 
          <"\t\tGIT_PS1_SHOWDIRTYSTATE=y &&\n"> <"\t\t__git_ps1 >\"$actual\"\n"> <"\t) &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"prompt - dirty status indicator - dirty worktree">)} 
      {
        (SQ <"\n"> <"\tprintf \" (master *)\" >expected &&\n"> <"\techo \"dirty\" >file &&\n"> 
          <"\ttest_when_finished \"git reset --hard\" &&\n"> <"\t(\n"> <"\t\tGIT_PS1_SHOWDIRTYSTATE=y &&\n"> <"\t\t__git_ps1 >\"$actual\"\n"> <"\t) &&\n"> 
          <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"prompt - dirty status indicator - dirty index">)} 
      {
        (SQ <"\n"> <"\tprintf \" (master +)\" >expected &&\n"> <"\techo \"dirty\" >file &&\n"> 
          <"\ttest_when_finished \"git reset --hard\" &&\n"> <"\tgit add -u &&\n"> <"\t(\n"> <"\t\tGIT_PS1_SHOWDIRTYSTATE=y &&\n"> <"\t\t__git_ps1 >\"$actual\"\n"> 
          <"\t) &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"prompt - dirty status indicator - dirty index and worktree">)} 
      {
        (SQ <"\n"> <"\tprintf \" (master *+)\" >expected &&\n"> <"\techo \"dirty index\" >file &&\n"> 
          <"\ttest_when_finished \"git reset --hard\" &&\n"> <"\tgit add -u &&\n"> <"\techo \"dirty worktree\" >file &&\n"> <"\t(\n"> 
          <"\t\tGIT_PS1_SHOWDIRTYSTATE=y &&\n"> <"\t\t__git_ps1 >\"$actual\"\n"> <"\t) &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"prompt - dirty status indicator - orphan branch - clean">)} 
      {
        (SQ <"\n"> <"\tprintf \" (orphan #)\" >expected &&\n"> 
          <"\ttest_when_finished \"git checkout master\" &&\n"> <"\tgit checkout --orphan orphan &&\n"> <"\tgit reset --hard &&\n"> <"\t(\n"> 
          <"\t\tGIT_PS1_SHOWDIRTYSTATE=y &&\n"> <"\t\t__git_ps1 >\"$actual\"\n"> <"\t) &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"prompt - dirty status indicator - orphan branch - dirty index">)} 
      {
        (SQ <"\n"> <"\tprintf \" (orphan +)\" >expected &&\n"> 
          <"\ttest_when_finished \"git checkout master\" &&\n"> <"\tgit checkout --orphan orphan &&\n"> <"\t(\n"> <"\t\tGIT_PS1_SHOWDIRTYSTATE=y &&\n"> 
          <"\t\t__git_ps1 >\"$actual\"\n"> <"\t) &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} 
      {(SQ <"prompt - dirty status indicator - orphan branch - dirty index and worktree">)} 
      {
        (SQ <"\n"> <"\tprintf \" (orphan *+)\" >expected &&\n"> 
          <"\ttest_when_finished \"git checkout master\" &&\n"> <"\tgit checkout --orphan orphan &&\n"> <"\t>file &&\n"> <"\t(\n"> <"\t\tGIT_PS1_SHOWDIRTYSTATE=y &&\n"> 
          <"\t\t__git_ps1 >\"$actual\"\n"> <"\t) &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} 
      {(SQ <"prompt - dirty status indicator - shell variable unset with config disabled">)} 
      {
        (SQ <"\n"> <"\tprintf \" (master)\" >expected &&\n"> <"\techo \"dirty\" >file &&\n"> 
          <"\ttest_when_finished \"git reset --hard\" &&\n"> <"\ttest_config bash.showDirtyState false &&\n"> <"\t(\n"> 
          <"\t\tsane_unset GIT_PS1_SHOWDIRTYSTATE &&\n"> <"\t\t__git_ps1 >\"$actual\"\n"> <"\t) &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} 
      {(SQ <"prompt - dirty status indicator - shell variable unset with config enabled">)} 
      {
        (SQ <"\n"> <"\tprintf \" (master)\" >expected &&\n"> <"\techo \"dirty\" >file &&\n"> 
          <"\ttest_when_finished \"git reset --hard\" &&\n"> <"\ttest_config bash.showDirtyState true &&\n"> <"\t(\n"> 
          <"\t\tsane_unset GIT_PS1_SHOWDIRTYSTATE &&\n"> <"\t\t__git_ps1 >\"$actual\"\n"> <"\t) &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} 
      {(SQ <"prompt - dirty status indicator - shell variable set with config disabled">)} 
      {
        (SQ <"\n"> <"\tprintf \" (master)\" >expected &&\n"> <"\techo \"dirty\" >file &&\n"> 
          <"\ttest_when_finished \"git reset --hard\" &&\n"> <"\ttest_config bash.showDirtyState false &&\n"> <"\t(\n"> <"\t\tGIT_PS1_SHOWDIRTYSTATE=y &&\n"> 
          <"\t\t__git_ps1 >\"$actual\"\n"> <"\t) &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} 
      {(SQ <"prompt - dirty status indicator - shell variable set with config enabled">)} 
      {
        (SQ <"\n"> <"\tprintf \" (master *)\" >expected &&\n"> <"\techo \"dirty\" >file &&\n"> 
          <"\ttest_when_finished \"git reset --hard\" &&\n"> <"\ttest_config bash.showDirtyState true &&\n"> <"\t(\n"> <"\t\tGIT_PS1_SHOWDIRTYSTATE=y &&\n"> 
          <"\t\t__git_ps1 >\"$actual\"\n"> <"\t) &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} 
      {(SQ <"prompt - dirty status indicator - not shown inside .git directory">)} 
      {
        (SQ <"\n"> <"\tprintf \" (GIT_DIR!)\" >expected &&\n"> <"\techo \"dirty\" >file &&\n"> 
          <"\ttest_when_finished \"git reset --hard\" &&\n"> <"\t(\n"> <"\t\tGIT_PS1_SHOWDIRTYSTATE=y &&\n"> <"\t\tcd .git &&\n"> <"\t\t__git_ps1 >\"$actual\"\n"> 
          <"\t) &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"prompt - stash status indicator - no stash">)} 
      {
        (SQ <"\n"> <"\tprintf \" (master)\" >expected &&\n"> <"\t(\n"> 
          <"\t\tGIT_PS1_SHOWSTASHSTATE=y &&\n"> <"\t\t__git_ps1 >\"$actual\"\n"> <"\t) &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"prompt - stash status indicator - stash">)} 
      {
        (SQ <"\n"> <"\tprintf \" (master $)\" >expected &&\n"> <"\techo 2 >file &&\n"> 
          <"\tgit stash &&\n"> <"\ttest_when_finished \"git stash drop\" &&\n"> <"\tgit pack-refs --all &&\n"> <"\t(\n"> 
          <"\t\tGIT_PS1_SHOWSTASHSTATE=y &&\n"> <"\t\t__git_ps1 >\"$actual\"\n"> <"\t) &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} 
      {(SQ <"prompt - stash status indicator - not shown inside .git directory">)} 
      {
        (SQ <"\n"> <"\tprintf \" (GIT_DIR!)\" >expected &&\n"> <"\techo 2 >file &&\n"> 
          <"\tgit stash &&\n"> <"\ttest_when_finished \"git stash drop\" &&\n"> <"\t(\n"> <"\t\tGIT_PS1_SHOWSTASHSTATE=y &&\n"> 
          <"\t\tcd .git &&\n"> <"\t\t__git_ps1 >\"$actual\"\n"> <"\t) &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"prompt - untracked files status indicator - no untracked files">)} 
      {
        (SQ <"\n"> <"\tprintf \" (master)\" >expected &&\n"> <"\t(\n"> 
          <"\t\tGIT_PS1_SHOWUNTRACKEDFILES=y &&\n"> <"\t\tcd otherrepo &&\n"> <"\t\t__git_ps1 >\"$actual\"\n"> <"\t) &&\n"> 
          <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"prompt - untracked files status indicator - untracked files">)} 
      {
        (SQ <"\n"> <"\tprintf \" (master %%)\" >expected &&\n"> <"\t(\n"> 
          <"\t\tGIT_PS1_SHOWUNTRACKEDFILES=y &&\n"> <"\t\t__git_ps1 >\"$actual\"\n"> <"\t) &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} 
      {(SQ <"prompt - untracked files status indicator - empty untracked dir">)} 
      {
        (SQ <"\n"> <"\tprintf \" (master)\" >expected &&\n"> <"\tmkdir otherrepo/untracked-dir &&\n"> 
          <"\ttest_when_finished \"rm -rf otherrepo/untracked-dir\" &&\n"> <"\t(\n"> <"\t\tGIT_PS1_SHOWUNTRACKEDFILES=y &&\n"> <"\t\tcd otherrepo &&\n"> 
          <"\t\t__git_ps1 >\"$actual\"\n"> <"\t) &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} 
      {(SQ <"prompt - untracked files status indicator - non-empty untracked dir">)} 
      {
        (SQ <"\n"> <"\tprintf \" (master %%)\" >expected &&\n"> 
          <"\tmkdir otherrepo/untracked-dir &&\n"> <"\ttest_when_finished \"rm -rf otherrepo/untracked-dir\" &&\n"> 
          <"\t>otherrepo/untracked-dir/untracked-file &&\n"> <"\t(\n"> <"\t\tGIT_PS1_SHOWUNTRACKEDFILES=y &&\n"> <"\t\tcd otherrepo &&\n"> 
          <"\t\t__git_ps1 >\"$actual\"\n"> <"\t) &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} 
      {(SQ <"prompt - untracked files status indicator - untracked files outside cwd">)} 
      {
        (SQ <"\n"> <"\tprintf \" (master %%)\" >expected &&\n"> <"\t(\n"> 
          <"\t\tmkdir -p ignored_dir &&\n"> <"\t\tcd ignored_dir &&\n"> <"\t\tGIT_PS1_SHOWUNTRACKEDFILES=y &&\n"> <"\t\t__git_ps1 >\"$actual\"\n"> 
          <"\t) &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} 
      {
        (SQ <"prompt - untracked files status indicator - shell variable unset with config disabled">)
      } 
      {
        (SQ <"\n"> <"\tprintf \" (master)\" >expected &&\n"> 
          <"\ttest_config bash.showUntrackedFiles false &&\n"> <"\t(\n"> <"\t\tsane_unset GIT_PS1_SHOWUNTRACKEDFILES &&\n"> <"\t\t__git_ps1 >\"$actual\"\n"> 
          <"\t) &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} 
      {(SQ <"prompt - untracked files status indicator - shell variable unset with config enabled">)} 
      {
        (SQ <"\n"> <"\tprintf \" (master)\" >expected &&\n"> 
          <"\ttest_config bash.showUntrackedFiles true &&\n"> <"\t(\n"> <"\t\tsane_unset GIT_PS1_SHOWUNTRACKEDFILES &&\n"> <"\t\t__git_ps1 >\"$actual\"\n"> 
          <"\t) &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} 
      {(SQ <"prompt - untracked files status indicator - shell variable set with config disabled">)} 
      {
        (SQ <"\n"> <"\tprintf \" (master)\" >expected &&\n"> 
          <"\ttest_config bash.showUntrackedFiles false &&\n"> <"\t(\n"> <"\t\tGIT_PS1_SHOWUNTRACKEDFILES=y &&\n"> <"\t\t__git_ps1 >\"$actual\"\n"> <"\t) &&\n"> 
          <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} 
      {(SQ <"prompt - untracked files status indicator - shell variable set with config enabled">)} 
      {
        (SQ <"\n"> <"\tprintf \" (master %%)\" >expected &&\n"> 
          <"\ttest_config bash.showUntrackedFiles true &&\n"> <"\t(\n"> <"\t\tGIT_PS1_SHOWUNTRACKEDFILES=y &&\n"> <"\t\t__git_ps1 >\"$actual\"\n"> <"\t) &&\n"> 
          <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} 
      {(SQ <"prompt - untracked files status indicator - not shown inside .git directory">)} 
      {
        (SQ <"\n"> <"\tprintf \" (GIT_DIR!)\" >expected &&\n"> <"\t(\n"> 
          <"\t\tGIT_PS1_SHOWUNTRACKEDFILES=y &&\n"> <"\t\tcd .git &&\n"> <"\t\t__git_ps1 >\"$actual\"\n"> <"\t) &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"prompt - format string starting with dash">)} 
      {
        (SQ <"\n"> <"\tprintf -- \"-master\" >expected &&\n"> <"\t__git_ps1 \"-%s\" >\"$actual\" &&\n"> 
          <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"prompt - pc mode">)} 
      {
        (SQ <"\n"> 
          <"\tprintf \"BEFORE: (\\${__git_ps1_branch_name}):AFTER\\\\nmaster\" >expected &&\n"> <"\tprintf \"\" >expected_output &&\n"> <"\t(\n"> 
          <"\t\t__git_ps1 \"BEFORE:\" \":AFTER\" >\"$actual\" &&\n"> <"\t\ttest_cmp expected_output \"$actual\" &&\n"> 
          <"\t\tprintf \"%s\\\\n%s\" \"$PS1\" \"${__git_ps1_branch_name}\" >\"$actual\"\n"> <"\t) &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"prompt - bash color pc mode - branch name">)} 
      {
        (SQ <"\n"> 
          <
"\tprintf \"BEFORE: (${c_green}\\${__git_ps1_branch_name}${c_clear}):AFTER\\\\nmaster\" >expected &&\n"
          > <"\t(\n"> <"\t\tGIT_PS1_SHOWCOLORHINTS=y &&\n"> <"\t\t__git_ps1 \"BEFORE:\" \":AFTER\" >\"$actual\"\n"> 
          <"\t\tprintf \"%s\\\\n%s\" \"$PS1\" \"${__git_ps1_branch_name}\" >\"$actual\"\n"> <"\t) &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"prompt - bash color pc mode - detached head">)} 
      {
        (SQ <"\n"> 
          <
"\tprintf \"BEFORE: (${c_red}\\${__git_ps1_branch_name}${c_clear}):AFTER\\\\n(%s...)\" $(git log -1 --format=\"%h\" b1^) >expected &&\n"
          > <"\tgit checkout b1^ &&\n"> <"\ttest_when_finished \"git checkout master\" &&\n"> <"\t(\n"> 
          <"\t\tGIT_PS1_SHOWCOLORHINTS=y &&\n"> <"\t\t__git_ps1 \"BEFORE:\" \":AFTER\" &&\n"> 
          <"\t\tprintf \"%s\\\\n%s\" \"$PS1\" \"${__git_ps1_branch_name}\" >\"$actual\"\n"> <"\t) &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} 
      {(SQ <"prompt - bash color pc mode - dirty status indicator - dirty worktree">)} 
      {
        (SQ <"\n"> 
          <
"\tprintf \"BEFORE: (${c_green}\\${__git_ps1_branch_name}${c_clear} ${c_red}*${c_clear}):AFTER\\\\nmaster\" >expected &&\n"
          > <"\techo \"dirty\" >file &&\n"> <"\ttest_when_finished \"git reset --hard\" &&\n"> <"\t(\n"> 
          <"\t\tGIT_PS1_SHOWDIRTYSTATE=y &&\n"> <"\t\tGIT_PS1_SHOWCOLORHINTS=y &&\n"> <"\t\t__git_ps1 \"BEFORE:\" \":AFTER\" &&\n"> 
          <"\t\tprintf \"%s\\\\n%s\" \"$PS1\" \"${__git_ps1_branch_name}\" >\"$actual\"\n"> <"\t) &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} 
      {(SQ <"prompt - bash color pc mode - dirty status indicator - dirty index">)} 
      {
        (SQ <"\n"> 
          <
"\tprintf \"BEFORE: (${c_green}\\${__git_ps1_branch_name}${c_clear} ${c_green}+${c_clear}):AFTER\\\\nmaster\" >expected &&\n"
          > <"\techo \"dirty\" >file &&\n"> <"\ttest_when_finished \"git reset --hard\" &&\n"> 
          <"\tgit add -u &&\n"> <"\t(\n"> <"\t\tGIT_PS1_SHOWDIRTYSTATE=y &&\n"> <"\t\tGIT_PS1_SHOWCOLORHINTS=y &&\n"> 
          <"\t\t__git_ps1 \"BEFORE:\" \":AFTER\" &&\n"> <"\t\tprintf \"%s\\\\n%s\" \"$PS1\" \"${__git_ps1_branch_name}\" >\"$actual\"\n"> <"\t) &&\n"> 
          <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} 
      {(SQ <"prompt - bash color pc mode - dirty status indicator - dirty index and worktree">)} 
      {
        (SQ <"\n"> 
          <
"\tprintf \"BEFORE: (${c_green}\\${__git_ps1_branch_name}${c_clear} ${c_red}*${c_green}+${c_clear}):AFTER\\\\nmaster\" >expected &&\n"
          > <"\techo \"dirty index\" >file &&\n"> <"\ttest_when_finished \"git reset --hard\" &&\n"> 
          <"\tgit add -u &&\n"> <"\techo \"dirty worktree\" >file &&\n"> <"\t(\n"> <"\t\tGIT_PS1_SHOWCOLORHINTS=y &&\n"> 
          <"\t\tGIT_PS1_SHOWDIRTYSTATE=y &&\n"> <"\t\t__git_ps1 \"BEFORE:\" \":AFTER\" &&\n"> 
          <"\t\tprintf \"%s\\\\n%s\" \"$PS1\" \"${__git_ps1_branch_name}\" >\"$actual\"\n"> <"\t) &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} 
      {(SQ <"prompt - bash color pc mode - dirty status indicator - before root commit">)} 
      {
        (SQ <"\n"> 
          <
"\tprintf \"BEFORE: (${c_green}\\${__git_ps1_branch_name}${c_clear} ${c_green}#${c_clear}):AFTER\\\\nmaster\" >expected &&\n"
          > <"\t(\n"> <"\t\tGIT_PS1_SHOWDIRTYSTATE=y &&\n"> <"\t\tGIT_PS1_SHOWCOLORHINTS=y &&\n"> 
          <"\t\tcd otherrepo &&\n"> <"\t\t__git_ps1 \"BEFORE:\" \":AFTER\" &&\n"> 
          <"\t\tprintf \"%s\\\\n%s\" \"$PS1\" \"${__git_ps1_branch_name}\" >\"$actual\"\n"> <"\t) &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"prompt - bash color pc mode - inside .git directory">)} 
      {
        (SQ <"\n"> 
          <
"\tprintf \"BEFORE: (${c_green}\\${__git_ps1_branch_name}${c_clear}):AFTER\\\\nGIT_DIR!\" >expected &&\n"
          > <"\techo \"dirty\" >file &&\n"> <"\ttest_when_finished \"git reset --hard\" &&\n"> <"\t(\n"> 
          <"\t\tGIT_PS1_SHOWDIRTYSTATE=y &&\n"> <"\t\tGIT_PS1_SHOWCOLORHINTS=y &&\n"> <"\t\tcd .git &&\n"> 
          <"\t\t__git_ps1 \"BEFORE:\" \":AFTER\" &&\n"> <"\t\tprintf \"%s\\\\n%s\" \"$PS1\" \"${__git_ps1_branch_name}\" >\"$actual\"\n"> <"\t) &&\n"> 
          <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"prompt - bash color pc mode - stash status indicator">)} 
      {
        (SQ <"\n"> 
          <
"\tprintf \"BEFORE: (${c_green}\\${__git_ps1_branch_name}${c_clear} ${c_lblue}\\$${c_clear}):AFTER\\\\nmaster\" >expected &&\n"
          > <"\techo 2 >file &&\n"> <"\tgit stash &&\n"> <"\ttest_when_finished \"git stash drop\" &&\n"> <"\t(\n"> 
          <"\t\tGIT_PS1_SHOWSTASHSTATE=y &&\n"> <"\t\tGIT_PS1_SHOWCOLORHINTS=y &&\n"> <"\t\t__git_ps1 \"BEFORE:\" \":AFTER\" &&\n"> 
          <"\t\tprintf \"%s\\\\n%s\" \"$PS1\" \"${__git_ps1_branch_name}\" >\"$actual\"\n"> <"\t) &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"prompt - bash color pc mode - untracked files status indicator">)} 
      {
        (SQ <"\n"> 
          <
"\tprintf \"BEFORE: (${c_green}\\${__git_ps1_branch_name}${c_clear} ${c_red}%%${c_clear}):AFTER\\\\nmaster\" >expected &&\n"
          > <"\t(\n"> <"\t\tGIT_PS1_SHOWUNTRACKEDFILES=y &&\n"> <"\t\tGIT_PS1_SHOWCOLORHINTS=y &&\n"> 
          <"\t\t__git_ps1 \"BEFORE:\" \":AFTER\" &&\n"> <"\t\tprintf \"%s\\\\n%s\" \"$PS1\" \"${__git_ps1_branch_name}\" >\"$actual\"\n"> <"\t) &&\n"> 
          <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"prompt - zsh color pc mode">)} 
      {
        (SQ <"\n"> <"\tprintf \"BEFORE: (%%F{green}master%%f):AFTER\" >expected &&\n"> <"\t(\n"> 
          <"\t\tZSH_VERSION=5.0.0 &&\n"> <"\t\tGIT_PS1_SHOWCOLORHINTS=y &&\n"> <"\t\t__git_ps1 \"BEFORE:\" \":AFTER\" &&\n"> 
          <"\t\tprintf \"%s\" \"$PS1\" >\"$actual\"\n"> <"\t) &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"prompt - hide if pwd ignored - env var unset, config disabled">)} 
      {
        (SQ <"\n"> <"\tprintf \" (master)\" >expected &&\n"> 
          <"\ttest_config bash.hideIfPwdIgnored false &&\n"> <"\t(\n"> <"\t\tcd ignored_dir &&\n"> <"\t\t__git_ps1 >\"$actual\"\n"> <"\t) &&\n"> 
          <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} 
      {(SQ <"prompt - hide if pwd ignored - env var unset, config disabled, pc mode">)} 
      {
        (SQ <"\n"> <"\tprintf \"BEFORE: (\\${__git_ps1_branch_name}):AFTER\" >expected &&\n"> 
          <"\ttest_config bash.hideIfPwdIgnored false &&\n"> <"\t(\n"> <"\t\tcd ignored_dir &&\n"> <"\t\t__git_ps1 \"BEFORE:\" \":AFTER\" &&\n"> 
          <"\t\tprintf \"%s\" \"$PS1\" >\"$actual\"\n"> <"\t) &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"prompt - hide if pwd ignored - env var unset, config unset">)} 
      {
        (SQ <"\n"> <"\tprintf \" (master)\" >expected &&\n"> <"\t(\n"> <"\t\tcd ignored_dir &&\n"> 
          <"\t\t__git_ps1 >\"$actual\"\n"> <"\t) &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} 
      {(SQ <"prompt - hide if pwd ignored - env var unset, config unset, pc mode">)} 
      {
        (SQ <"\n"> <"\tprintf \"BEFORE: (\\${__git_ps1_branch_name}):AFTER\" >expected &&\n"> <"\t(\n"> 
          <"\t\tcd ignored_dir &&\n"> <"\t\t__git_ps1 \"BEFORE:\" \":AFTER\" &&\n"> <"\t\tprintf \"%s\" \"$PS1\" >\"$actual\"\n"> 
          <"\t) &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"prompt - hide if pwd ignored - env var set, config disabled">)} 
      {
        (SQ <"\n"> <"\tprintf \" (master)\" >expected &&\n"> 
          <"\ttest_config bash.hideIfPwdIgnored false &&\n"> <"\t(\n"> <"\t\tcd ignored_dir &&\n"> <"\t\tGIT_PS1_HIDE_IF_PWD_IGNORED=y &&\n"> 
          <"\t\t__git_ps1 >\"$actual\"\n"> <"\t) &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} 
      {(SQ <"prompt - hide if pwd ignored - env var set, config disabled, pc mode">)} 
      {
        (SQ <"\n"> <"\tprintf \"BEFORE: (\\${__git_ps1_branch_name}):AFTER\" >expected &&\n"> 
          <"\ttest_config bash.hideIfPwdIgnored false &&\n"> <"\t(\n"> <"\t\tcd ignored_dir &&\n"> <"\t\tGIT_PS1_HIDE_IF_PWD_IGNORED=y &&\n"> 
          <"\t\t__git_ps1 \"BEFORE:\" \":AFTER\" &&\n"> <"\t\tprintf \"%s\" \"$PS1\" >\"$actual\"\n"> <"\t) &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"prompt - hide if pwd ignored - env var set, config unset">)} 
      {
        (SQ <"\n"> <"\tprintf \"\" >expected &&\n"> <"\t(\n"> <"\t\tcd ignored_dir &&\n"> 
          <"\t\tGIT_PS1_HIDE_IF_PWD_IGNORED=y &&\n"> <"\t\t__git_ps1 >\"$actual\"\n"> <"\t) &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} 
      {(SQ <"prompt - hide if pwd ignored - env var set, config unset, pc mode">)} 
      {
        (SQ <"\n"> <"\tprintf \"BEFORE::AFTER\" >expected &&\n"> <"\t(\n"> <"\t\tcd ignored_dir &&\n"> 
          <"\t\tGIT_PS1_HIDE_IF_PWD_IGNORED=y &&\n"> <"\t\t__git_ps1 \"BEFORE:\" \":AFTER\" &&\n"> <"\t\tprintf \"%s\" \"$PS1\" >\"$actual\"\n"> 
          <"\t) &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"prompt - hide if pwd ignored - inside gitdir (stdout)">)} 
      {
        (SQ <"\n"> <"\tprintf \" (GIT_DIR!)\" >expected &&\n"> <"\t(\n"> 
          <"\t\tGIT_PS1_HIDE_IF_PWD_IGNORED=y &&\n"> <"\t\tcd .git &&\n"> <"\t\t__git_ps1 >\"$actual\" 2>/dev/null\n"> <"\t) &&\n"> 
          <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_expect_success)} {(SQ <"prompt - hide if pwd ignored - inside gitdir (stderr)">)} 
      {
        (SQ <"\n"> <"\tprintf \"\" >expected &&\n"> <"\t(\n"> <"\t\tGIT_PS1_HIDE_IF_PWD_IGNORED=y &&\n"> 
          <"\t\tcd .git &&\n"> <"\t\t__git_ps1 >/dev/null 2>\"$actual\"\n"> <"\t) &&\n"> <"\ttest_cmp expected \"$actual\"\n">
        )
      }
    )
    (C {(test_done)})
  ]
)