Gatla Vishweshwar ReddyJul 6, 2026, 20:50 UTC on lorePiping git commands directly to wc -l suppresses the exit code of git, hiding potential failures from the test suite. Capture the output to a temporary file first, then count the lines separately to preserve the exit code.
Signed-off-by: Gatla Vishweshwar Reddy <gatlavishweshwarreddy26@gmail.com>
---
t/t1410-reflog.sh | 29 +++++++++++++++++++++--------
1 file changed, 21 insertions(+), 8 deletions(-)
Show changes to t/t1410-reflog.sh +21 −8
diff --git a/t/t1410-reflog.sh b/t/t1410-reflog.sh
index ce71f9a30a..397f94b039 100755
--- a/t/t1410-reflog.sh
+++ b/t/t1410-reflog.sh
@@ -244,8 +244,10 @@ test_expect_success 'delete' '
test_tick &&
git commit -m tiger C &&
- HEAD_entry_count=$(git reflog | wc -l) &&
- main_entry_count=$(git reflog show main | wc -l) &&
+ git reflog >reflog_output &&
+ HEAD_entry_count=$(wc -l <reflog_output) &&
+ git reflog show main >reflog_main_output &&
+ main_entry_count=$(wc -l <reflog_main_output) &&
test $HEAD_entry_count = 5 &&
test $main_entry_count = 5 &&
@@ -254,16 +256,23 @@ test_expect_success 'delete' '
git reflog delete main@{1} &&
git reflog show main > output &&
test_line_count = $(($main_entry_count - 1)) output &&
- test $HEAD_entry_count = $(git reflog | wc -l) &&
+ git reflog >reflog_output &&
+ test $HEAD_entry_count = $(wc -l <reflog_output) &&
! grep ox < output &&
main_entry_count=$(wc -l < output) &&
git reflog delete HEAD@{1} &&
- test $(($HEAD_entry_count -1)) = $(git reflog | wc -l) &&
- test $main_entry_count = $(git reflog show main | wc -l) &&
+ git reflog >reflog_output &&
+ test $(($HEAD_entry_count -1)) = $(wc -l <reflog_output) &&
+ git reflog show main >reflog_main_output &&
+ test $main_entry_count = $(wc -l <reflog_main_output) &&
+
+
+ git reflog >reflog_output &&
+ HEAD_entry_count=$(wc -l <reflog_output) &&
+
- HEAD_entry_count=$(git reflog | wc -l) &&
git reflog delete main@{07.04.2005.15:15:00.-0700} &&
git reflog show main > output &&
@@ -321,11 +330,15 @@ test_expect_success 'git reflog expire unknown reference' '
'
test_expect_success 'checkout should not delete log for packed ref' '
- test $(git reflog main | wc -l) = 4 &&
+ git reflog main >reflog_output &&
+ test $(wc -l <reflog_output) = 4 &&
git branch foo &&
git pack-refs --all &&
git checkout foo &&
- test $(git reflog main | wc -l) = 4
+ git reflog main >reflog_output &&
+ test $(wc -l <reflog_output) = 4
+
+
'
test_expect_success 'stale dirs do not cause d/f conflicts (reflogs on)' '
--
2.54.0
Re: [PATCH] t1410-reflog.sh: avoid suppressing git's exit code in pipelines
Gatla Vishweshwar Reddy <gatlavishweshwarreddy26@gmail.com> writes:
Show 27 quoted lines
> Piping git commands directly to wc -l suppresses the exit code of
> git, hiding potential failures from the test suite. Capture the
> output to a temporary file first, then count the lines separately
> to preserve the exit code.
>
> Signed-off-by: Gatla Vishweshwar Reddy <gatlavishweshwarreddy26@gmail.com>
> ---
> t/t1410-reflog.sh | 29 +++++++++++++++++++++--------
> 1 file changed, 21 insertions(+), 8 deletions(-)
>
> diff --git a/t/t1410-reflog.sh b/t/t1410-reflog.sh
> index ce71f9a30a..397f94b039 100755
> --- a/t/t1410-reflog.sh
> +++ b/t/t1410-reflog.sh
> @@ -244,8 +244,10 @@ test_expect_success 'delete' '
> test_tick &&
> git commit -m tiger C &&
>
> - HEAD_entry_count=$(git reflog | wc -l) &&
> - main_entry_count=$(git reflog show main | wc -l) &&
> + git reflog >reflog_output &&
> + HEAD_entry_count=$(wc -l <reflog_output) &&
> + git reflog show main >reflog_main_output &&
> + main_entry_count=$(wc -l <reflog_main_output) &&
>
> test $HEAD_entry_count = 5 &&
> test $main_entry_count = 5 &&
If you _know_ output from certain command must be 5 lines, would it make more sense to use test_stdout_line_count, perhaps like
test_stdout_line_count = 5 git reflog
or something?
Show 27 quoted lines
> @@ -254,16 +256,23 @@ test_expect_success 'delete' '
> git reflog delete main@{1} &&
> git reflog show main > output &&
> test_line_count = $(($main_entry_count - 1)) output &&
> - test $HEAD_entry_count = $(git reflog | wc -l) &&
> + git reflog >reflog_output &&
> + test $HEAD_entry_count = $(wc -l <reflog_output) &&
> ! grep ox < output &&
>
> main_entry_count=$(wc -l < output) &&
>
> git reflog delete HEAD@{1} &&
> - test $(($HEAD_entry_count -1)) = $(git reflog | wc -l) &&
> - test $main_entry_count = $(git reflog show main | wc -l) &&
> + git reflog >reflog_output &&
> + test $(($HEAD_entry_count -1)) = $(wc -l <reflog_output) &&
> + git reflog show main >reflog_main_output &&
> + test $main_entry_count = $(wc -l <reflog_main_output) &&
> +
> +
> + git reflog >reflog_output &&
> + HEAD_entry_count=$(wc -l <reflog_output) &&
> +
>
> - HEAD_entry_count=$(git reflog | wc -l) &&
>
> git reflog delete main@{07.04.2005.15:15:00.-0700} &&Can you explain the addition of these consecutive blank lines? The same question applies to the blank lines at the end of the test in the next hunk. I ask because formatting issues like this often resemble unedited AI-generated code that hasn't been properly cleaned up before submission.
Show 19 quoted lines
> git reflog show main > output &&
> @@ -321,11 +330,15 @@ test_expect_success 'git reflog expire unknown reference' '
> '
>
> test_expect_success 'checkout should not delete log for packed ref' '
> - test $(git reflog main | wc -l) = 4 &&
> + git reflog main >reflog_output &&
> + test $(wc -l <reflog_output) = 4 &&
> git branch foo &&
> git pack-refs --all &&
> git checkout foo &&
> - test $(git reflog main | wc -l) = 4
> + git reflog main >reflog_output &&
> + test $(wc -l <reflog_output) = 4
> +
> +
> '
>
> test_expect_success 'stale dirs do not cause d/f conflicts (reflogs on)' '
[PATCH v2] t1410-reflog.sh: avoid suppressing git's exit code in pipelines
Piping git commands directly to wc -l suppresses the exit code of git, hiding potential failures from the test suite. Capture the output to a temporary file first, then count the lines separately to preserve the exit code. Where the expected count is known ahead of time, use test_stdout_line_count instead.
Signed-off-by: Gatla Vishweshwar Reddy <gatlavishweshwarreddy26@gmail.com>
---
t/t1410-reflog.sh | 29 ++++++++++++++++-------------
1 file changed, 16 insertions(+), 13 deletions(-)
Show changes to t/t1410-reflog.sh +16 −13
diff --git a/t/t1410-reflog.sh b/t/t1410-reflog.sh
index ce71f9a30a..8e018d172b 100755
--- a/t/t1410-reflog.sh
+++ b/t/t1410-reflog.sh
@@ -244,26 +244,30 @@ test_expect_success 'delete' '
test_tick &&
git commit -m tiger C &&
- HEAD_entry_count=$(git reflog | wc -l) &&
- main_entry_count=$(git reflog show main | wc -l) &&
-
- test $HEAD_entry_count = 5 &&
- test $main_entry_count = 5 &&
-
+ test_stdout_line_count = 5 git reflog &&
+ git reflog >reflog_output &&
+ HEAD_entry_count=$(wc -l <reflog_output) &&
+ test_stdout_line_count = 5 git reflog show main &&
+ git reflog show main >reflog_main_output &&
+ main_entry_count=$(wc -l <reflog_main_output) &&
git reflog delete main@{1} &&
git reflog show main > output &&
test_line_count = $(($main_entry_count - 1)) output &&
- test $HEAD_entry_count = $(git reflog | wc -l) &&
+ git reflog >reflog_output &&
+ test $HEAD_entry_count = $(wc -l <reflog_output) &&
! grep ox < output &&
main_entry_count=$(wc -l < output) &&
git reflog delete HEAD@{1} &&
- test $(($HEAD_entry_count -1)) = $(git reflog | wc -l) &&
- test $main_entry_count = $(git reflog show main | wc -l) &&
+ git reflog >reflog_output &&
+ test $(($HEAD_entry_count -1)) = $(wc -l <reflog_output) &&
+ git reflog show main >reflog_main_output &&
+ test $main_entry_count = $(wc -l <reflog_main_output) &&
- HEAD_entry_count=$(git reflog | wc -l) &&
+ git reflog >reflog_output &&
+ HEAD_entry_count=$(wc -l <reflog_output) &&
git reflog delete main@{07.04.2005.15:15:00.-0700} &&
git reflog show main > output &&
@@ -319,13 +323,12 @@ test_expect_success 'git reflog expire unknown reference' '
test_must_fail git reflog expire does-not-exist 2>stderr &&
test_grep "error: reflog could not be found: ${SQ}does-not-exist${SQ}" stderr
'
-
test_expect_success 'checkout should not delete log for packed ref' '
- test $(git reflog main | wc -l) = 4 &&
+ test_stdout_line_count = 4 git reflog main &&
git branch foo &&
git pack-refs --all &&
git checkout foo &&
- test $(git reflog main | wc -l) = 4
+ test_stdout_line_count = 4 git reflog main
'
test_expect_success 'stale dirs do not cause d/f conflicts (reflogs on)' '
--
2.54.0
Re: [PATCH v2] t1410-reflog.sh: avoid suppressing git's exit code in pipelines
Gatla Vishweshwar Reddy <gatlavishweshwarreddy26@gmail.com> writes:
Show 10 quoted lines
> Piping git commands directly to wc -l suppresses the exit code of
> git, hiding potential failures from the test suite. Capture the
> output to a temporary file first, then count the lines separately
> to preserve the exit code. Where the expected count is known ahead
> of time, use test_stdout_line_count instead.
>
> Signed-off-by: Gatla Vishweshwar Reddy <gatlavishweshwarreddy26@gmail.com>
> ---
> t/t1410-reflog.sh | 29 ++++++++++++++++-------------
> 1 file changed, 16 insertions(+), 13 deletions(-)
The above descripotion looks reasonble.
By the way, Documentation/SubmittingPatches has this:
Before sending another version, make sure you have answered
meaningful review comments in the existing discussion. Also
give reviewers enough time to comment before sending another
version.Show 28 quoted lines
> diff --git a/t/t1410-reflog.sh b/t/t1410-reflog.sh
> index ce71f9a30a..8e018d172b 100755
> --- a/t/t1410-reflog.sh
> +++ b/t/t1410-reflog.sh
> @@ -244,26 +244,30 @@ test_expect_success 'delete' '
> test_tick &&
> git commit -m tiger C &&
>
> - HEAD_entry_count=$(git reflog | wc -l) &&
> - main_entry_count=$(git reflog show main | wc -l) &&
> -
> - test $HEAD_entry_count = 5 &&
> - test $main_entry_count = 5 &&
> -
> + test_stdout_line_count = 5 git reflog &&
> + git reflog >reflog_output &&
> + HEAD_entry_count=$(wc -l <reflog_output) &&
> + test_stdout_line_count = 5 git reflog show main &&
> + git reflog show main >reflog_main_output &&
> + main_entry_count=$(wc -l <reflog_main_output) &&
>
> git reflog delete main@{1} &&
> git reflog show main > output &&
> test_line_count = $(($main_entry_count - 1)) output &&
> - test $HEAD_entry_count = $(git reflog | wc -l) &&
> + git reflog >reflog_output &&
> + test $HEAD_entry_count = $(wc -l <reflog_output) &&
> ! grep ox < output &&Now, you no longer have new consecutive blank lines in the above, but the above shares the same "what did the author meant to convey with this blank line?" puzzlement.
The updated code somehow wanders around in many directions like a drunken man. Let's comment on each line.
> + test_stdout_line_count = 5 git reflog &&
This is "Does the reflog for HEAD have exactly 5 entries?" test.
> + git reflog >reflog_output &&
> + HEAD_entry_count=$(wc -l <reflog_output) &&
As we already saw that HEAD_entry_count variable is exactly equal to 5, it is puzzling why we want to perform this computation again and assign the result to the variable.
> + test_stdout_line_count = 5 git reflog show main &&
And then we check "Does the reflog for 'main' have exactly 5 entries?"
> + git reflog show main >reflog_main_output &&
> + main_entry_count=$(wc -l <reflog_main_output) &&
And recompute what we already know and asssign to main_entry_count variable, which shares the same puzzlement.
>
> git reflog delete main@{1} &&
> git reflog show main > output &&
> test_line_count = $(($main_entry_count - 1)) output &&Now, after a blank line, it goes on to test a completely different thing, which is "after deleting an entry in main's reflog, can we count how many there is, and does it match what we expect, which is the previous count minus 1"? Why should we even need to do so, when
git reflog delete main@{1} &&
test_stdout_line_count = 4 git reflog show main &&would do just fine?
> - test $HEAD_entry_count = $(git reflog | wc -l) &&
> + git reflog >reflog_output &&
> + test $HEAD_entry_count = $(wc -l <reflog_output) &&
And then it comes back to test what we already know, i.e. "does the reflog for HEAD have 5 entries?". Which we tested earlier already.
Are we interested in checking that "reflog delete main@{1}" does not affect the reflog for HEAD? If so, doing
test_stdout_line_count = 5 git reflog &&
again here would be simpler, no? That way, there is no need to recompute and assign to the {HEAD,main}_entry_count variables in the earlier part of the tests.
I guess the same comment applies to the remainder of this test, where it is checked that a removal from HEAD reflog does not affect the reflog of main.
Show 32 quoted lines
> main_entry_count=$(wc -l < output) &&
>
> git reflog delete HEAD@{1} &&
> - test $(($HEAD_entry_count -1)) = $(git reflog | wc -l) &&
> - test $main_entry_count = $(git reflog show main | wc -l) &&
> + git reflog >reflog_output &&
> + test $(($HEAD_entry_count -1)) = $(wc -l <reflog_output) &&
> + git reflog show main >reflog_main_output &&
> + test $main_entry_count = $(wc -l <reflog_main_output) &&
>
> - HEAD_entry_count=$(git reflog | wc -l) &&
> + git reflog >reflog_output &&
> + HEAD_entry_count=$(wc -l <reflog_output) &&
>
> git reflog delete main@{07.04.2005.15:15:00.-0700} &&
> git reflog show main > output &&
> @@ -319,13 +323,12 @@ test_expect_success 'git reflog expire unknown reference' '
> test_must_fail git reflog expire does-not-exist 2>stderr &&
> test_grep "error: reflog could not be found: ${SQ}does-not-exist${SQ}" stderr
> '
> -
> test_expect_success 'checkout should not delete log for packed ref' '
> - test $(git reflog main | wc -l) = 4 &&
> + test_stdout_line_count = 4 git reflog main &&
> git branch foo &&
> git pack-refs --all &&
> git checkout foo &&
> - test $(git reflog main | wc -l) = 4
> + test_stdout_line_count = 4 git reflog main
> '
>
> test_expect_success 'stale dirs do not cause d/f conflicts (reflogs on)' '[PATCH v3] t1410-reflog.sh: avoid suppressing git's exit code in pipelines
Piping git commands directly to wc -l suppresses the exit code of git, hiding potential failures from the test suite. Capture the output to a temporary file first, then count the lines separately to preserve the exit code. Where the expected count is known ahead of time, use test_stdout_line_count instead.
Signed-off-by: Gatla Vishweshwar Reddy <gatlavishweshwarreddy26@gmail.com>
---
Changes in v3:
- Removed all variables (HEAD_entry_count, main_entry_count) entirely
- Removed all temporary file captures (reflog_output, reflog_main_output)
- Used test_stdout_line_count with hardcoded counts throughout
- The counts are known ahead of time: HEAD=5, main=5 initially,decreasing as entries are deleted
t/t1410-reflog.sh | 27 +++++++++------------------
1 file changed, 9 insertions(+), 18 deletions(-)
Show changes to t/t1410-reflog.sh +9 −19
diff --git a/t/t1410-reflog.sh b/t/t1410-reflog.sh
index ce71f9a30a..3f2e36cf33 100755
--- a/t/t1410-reflog.sh
+++ b/t/t1410-reflog.sh
@@ -244,30 +244,22 @@ test_expect_success 'delete' '
test_tick &&
git commit -m tiger C &&
- HEAD_entry_count=$(git reflog | wc -l) &&
- main_entry_count=$(git reflog show main | wc -l) &&
-
- test $HEAD_entry_count = 5 &&
- test $main_entry_count = 5 &&
-
+ test_stdout_line_count = 5 git reflog &&
+ test_stdout_line_count = 5 git reflog show main &&
git reflog delete main@{1} &&
+ test_stdout_line_count = 4 git reflog show main &&
+ test_stdout_line_count = 5 git reflog &&
git reflog show main > output &&
- test_line_count = $(($main_entry_count - 1)) output &&
- test $HEAD_entry_count = $(git reflog | wc -l) &&
! grep ox < output &&
- main_entry_count=$(wc -l < output) &&
-
git reflog delete HEAD@{1} &&
- test $(($HEAD_entry_count -1)) = $(git reflog | wc -l) &&
- test $main_entry_count = $(git reflog show main | wc -l) &&
-
- HEAD_entry_count=$(git reflog | wc -l) &&
+ test_stdout_line_count = 4 git reflog &&
+ test_stdout_line_count = 4 git reflog show main &&
git reflog delete main@{07.04.2005.15:15:00.-0700} &&
+ test_stdout_line_count = 3 git reflog show main &&
git reflog show main > output &&
- test_line_count = $(($main_entry_count - 1)) output &&
! grep dragon < output
'
@@ -319,13 +311,12 @@ test_expect_success 'git reflog expire unknown reference' '
test_must_fail git reflog expire does-not-exist 2>stderr &&
test_grep "error: reflog could not be found: ${SQ}does-not-exist${SQ}" stderr
'
-
test_expect_success 'checkout should not delete log for packed ref' '
- test $(git reflog main | wc -l) = 4 &&
+ test_stdout_line_count = 4 git reflog main &&
git branch foo &&
git pack-refs --all &&
git checkout foo &&
- test $(git reflog main | wc -l) = 4
+ test_stdout_line_count = 4 git reflog main
'
test_expect_success 'stale dirs do not cause d/f conflicts (reflogs on)' '
--
2.54.0
Re: [PATCH v3] t1410-reflog.sh: avoid suppressing git's exit code in pipelines
Gatla Vishweshwar Reddy <gatlavishweshwarreddy26@gmail.com> writes:
> Piping git commands directly to wc -l suppresses the exit code of
> git, hiding potential failures from the test suite.
> Capture the
> output to a temporary file first, then count the lines separately
> to preserve the exit code. Where the expected count is known ahead
> of time, use test_stdout_line_count instead.
Technically, the description is not telling any lies about the solution, but the patch no longer does the caputuring or counting itself at all. Rather, it exclusively uses test_stdout_line_count, which internally does the saving to a temporary and counting the lines ;-)
The changes in the patch are mostly good, except for the loss of a blank line that separates two test pieces in the last hunk (below).
Show 16 quoted lines
> @@ -319,13 +311,12 @@ test_expect_success 'git reflog expire unknown reference' '
> test_must_fail git reflog expire does-not-exist 2>stderr &&
> test_grep "error: reflog could not be found: ${SQ}does-not-exist${SQ}" stderr
> '
> -
> test_expect_success 'checkout should not delete log for packed ref' '
> - test $(git reflog main | wc -l) = 4 &&
> + test_stdout_line_count = 4 git reflog main &&
> git branch foo &&
> git pack-refs --all &&
> git checkout foo &&
> - test $(git reflog main | wc -l) = 4
> + test_stdout_line_count = 4 git reflog main
> '
>
> test_expect_success 'stale dirs do not cause d/f conflicts (reflogs on)' '[PATCH v4] t1410-reflog.sh: avoid suppressing git's exit code in pipelines
Piping git commands directly to wc -l suppresses the exit code of git, hiding potential failures from the test suite. Use test_stdout_line_count instead, which handles exit code preservation internally while keeping the test logic clean and readable.
Signed-off-by: Gatla Vishweshwar Reddy <gatlavishweshwarreddy26@gmail.com>
---
Changes in v4:
- Restored blank line between test_expect_success blocks that was
accidentally removed in v2
- Updated commit message to accurately describe the solution
Thank you for the detailed review!
t/t1410-reflog.sh | 26 +++++++++-----------------
1 file changed, 9 insertions(+), 17 deletions(-)
Show changes to t/t1410-reflog.sh +9 −18
diff --git a/t/t1410-reflog.sh b/t/t1410-reflog.sh
index ce71f9a30a..5a40a62ba2 100755
--- a/t/t1410-reflog.sh
+++ b/t/t1410-reflog.sh
@@ -244,30 +244,22 @@ test_expect_success 'delete' '
test_tick &&
git commit -m tiger C &&
- HEAD_entry_count=$(git reflog | wc -l) &&
- main_entry_count=$(git reflog show main | wc -l) &&
-
- test $HEAD_entry_count = 5 &&
- test $main_entry_count = 5 &&
-
+ test_stdout_line_count = 5 git reflog &&
+ test_stdout_line_count = 5 git reflog show main &&
git reflog delete main@{1} &&
+ test_stdout_line_count = 4 git reflog show main &&
+ test_stdout_line_count = 5 git reflog &&
git reflog show main > output &&
- test_line_count = $(($main_entry_count - 1)) output &&
- test $HEAD_entry_count = $(git reflog | wc -l) &&
! grep ox < output &&
- main_entry_count=$(wc -l < output) &&
-
git reflog delete HEAD@{1} &&
- test $(($HEAD_entry_count -1)) = $(git reflog | wc -l) &&
- test $main_entry_count = $(git reflog show main | wc -l) &&
-
- HEAD_entry_count=$(git reflog | wc -l) &&
+ test_stdout_line_count = 4 git reflog &&
+ test_stdout_line_count = 4 git reflog show main &&
git reflog delete main@{07.04.2005.15:15:00.-0700} &&
+ test_stdout_line_count = 3 git reflog show main &&
git reflog show main > output &&
- test_line_count = $(($main_entry_count - 1)) output &&
! grep dragon < output
'
@@ -321,11 +313,11 @@ test_expect_success 'git reflog expire unknown reference' '
'
test_expect_success 'checkout should not delete log for packed ref' '
- test $(git reflog main | wc -l) = 4 &&
+ test_stdout_line_count = 4 git reflog main &&
git branch foo &&
git pack-refs --all &&
git checkout foo &&
- test $(git reflog main | wc -l) = 4
+ test_stdout_line_count = 4 git reflog main
'
test_expect_success 'stale dirs do not cause d/f conflicts (reflogs on)' '
--
2.54.0
Re: [PATCH v4] t1410-reflog.sh: avoid suppressing git's exit code in pipelines
Gatla Vishweshwar Reddy <gatlavishweshwarreddy26@gmail.com> writes:
Show 12 quoted lines
> Piping git commands directly to wc -l suppresses the exit code of
> git, hiding potential failures from the test suite. Use
> test_stdout_line_count instead, which handles exit code preservation
> internally while keeping the test logic clean and readable.
>
> Signed-off-by: Gatla Vishweshwar Reddy <gatlavishweshwarreddy26@gmail.com>
> ---
>
> Changes in v4:
> - Restored blank line between test_expect_success blocks that was
> accidentally removed in v2
> - Updated commit message to accurately describe the solution
This version looks good to me.
Will queue and mark the topic for 'next'.
Thanks.
Show 62 quoted lines
>
> Thank you for the detailed review!
>
> t/t1410-reflog.sh | 26 +++++++++-----------------
> 1 file changed, 9 insertions(+), 17 deletions(-)
>
> diff --git a/t/t1410-reflog.sh b/t/t1410-reflog.sh
> index ce71f9a30a..5a40a62ba2 100755
> --- a/t/t1410-reflog.sh
> +++ b/t/t1410-reflog.sh
> @@ -244,30 +244,22 @@ test_expect_success 'delete' '
> test_tick &&
> git commit -m tiger C &&
>
> - HEAD_entry_count=$(git reflog | wc -l) &&
> - main_entry_count=$(git reflog show main | wc -l) &&
> -
> - test $HEAD_entry_count = 5 &&
> - test $main_entry_count = 5 &&
> -
> + test_stdout_line_count = 5 git reflog &&
> + test_stdout_line_count = 5 git reflog show main &&
>
> git reflog delete main@{1} &&
> + test_stdout_line_count = 4 git reflog show main &&
> + test_stdout_line_count = 5 git reflog &&
> git reflog show main > output &&
> - test_line_count = $(($main_entry_count - 1)) output &&
> - test $HEAD_entry_count = $(git reflog | wc -l) &&
> ! grep ox < output &&
>
> - main_entry_count=$(wc -l < output) &&
> -
> git reflog delete HEAD@{1} &&
> - test $(($HEAD_entry_count -1)) = $(git reflog | wc -l) &&
> - test $main_entry_count = $(git reflog show main | wc -l) &&
> -
> - HEAD_entry_count=$(git reflog | wc -l) &&
> + test_stdout_line_count = 4 git reflog &&
> + test_stdout_line_count = 4 git reflog show main &&
>
> git reflog delete main@{07.04.2005.15:15:00.-0700} &&
> + test_stdout_line_count = 3 git reflog show main &&
> git reflog show main > output &&
> - test_line_count = $(($main_entry_count - 1)) output &&
> ! grep dragon < output
>
> '
> @@ -321,11 +313,11 @@ test_expect_success 'git reflog expire unknown reference' '
> '
>
> test_expect_success 'checkout should not delete log for packed ref' '
> - test $(git reflog main | wc -l) = 4 &&
> + test_stdout_line_count = 4 git reflog main &&
> git branch foo &&
> git pack-refs --all &&
> git checkout foo &&
> - test $(git reflog main | wc -l) = 4
> + test_stdout_line_count = 4 git reflog main
> '
>
> test_expect_success 'stale dirs do not cause d/f conflicts (reflogs on)' '