Skip to contentSkip to conversation

unit-tests: do show relative file paths on non-Windows, too

PATCH Superseded Junio C Hamano 3 participants 9 messages Feb 11, 2024 – Feb 13, 2024

lore
Share & tools
lore
#0 lore raw

PATCH 1/1 unit-tests: do show relative file paths on non-Windows, too

There are compilers other than Visual C that want to show absolute paths. Generalize the helper introduced by a2c5e294 (unit-tests: do show relative file paths, 2023-09-25) so that it can also work with a path that uses slash as the directory separator, and becomes almost no-op once one-time preparation finds out that we are using a compiler that already gives relative paths. Incidentally, this also should do the right thing on Windows with a compiler that shows relative paths but with backslash as the directory separator (if such a thing exists and is used to build git).

---

* Another change I made, which is not described in the proposed commit log message, is that we now use fspathcmp() instead of strcmp() to precompute the prefix length using a known needle[] string, to be consistent with the runtime check done for each and every path.

This is a belated follow-up on <f0b804129e8a21449cbb6f346473d3570182ddfa.1695640837.git.gitgitgadget@gmail.com>

 t/unit-tests/test-lib.c | 60 ++++++++++++++++++++++++++++++++---------
 1 file changed, 47 insertions(+), 13 deletions(-)
t/unit-tests/test-lib.c +47 -13
index 7bf9dfdb95..83c9eb8c59 100644
@@ -21,12 +21,11 @@ static struct {
 	.result = RESULT_NONE,
 };
 
-#ifndef _MSC_VER
-#define make_relative(location) location
-#else
 /*
  * Visual C interpolates the absolute Windows path for `__FILE__`,
  * but we want to see relative paths, as verified by t0080.
+ * There are other compilers that do the same, and are not for
+ * Windows.
  */
 #include "dir.h"
 
@@ -34,32 +33,67 @@ static const char *make_relative(const char *location)
 {
 	static char prefix[] = __FILE__, buf[PATH_MAX], *p;
 	static size_t prefix_len;
+	static int need_bs_to_fs = -1;
 
-	if (!prefix_len) {
+	/* one-time preparation */
+	if (need_bs_to_fs < 0) {
 		size_t len = strlen(prefix);
-		const char *needle = "\\t\\unit-tests\\test-lib.c";
+		char needle[] = "t\\unit-tests\\test-lib.c";
 		size_t needle_len = strlen(needle);
 
-		if (len < needle_len || strcmp(needle, prefix + len - needle_len))
+		if (len < needle_len)
+			die("unexpected prefix '%s'", prefix);
+
+		/*
+		 * The path could be relative (t/unit-tests/test-lib.c)
+		 * or full (/home/user/git/t/unit-tests/test-lib.c).
+		 * Check the slash between "t" and "unit-tests".
+		 */
+		prefix_len = len - needle_len;
+		if (prefix[prefix_len + 1] == '/') {
+			/* Oh, we're not Windows */
+			for (size_t i = 0; i < needle_len; i++)
+				if (needle[i] == '\\')
+					needle[i] = '/';
+			need_bs_to_fs = 0;
+		} else {
+			need_bs_to_fs = 1;
+		}
+
+		/*
+		 * prefix_len == 0 if the compiler gives paths relative
+		 * to the root of the working tree.  Otherwise, we want
+		 * to see that we did find the needle[] at a directory
+		 * boundary.
+		 */
+		if (fspathcmp(needle, prefix + prefix_len) ||
+		    (prefix_len &&
+		     prefix[prefix_len - 1] != '/' &&
+		     prefix[prefix_len - 1] != '\\'))
 			die("unexpected suffix of '%s'", prefix);
 
-		/* let it end in a directory separator */
-		prefix_len = len - needle_len + 1;
 	}
 
+	/*
+	 * If our compiler gives relative paths and we do not need
+	 * to munge directory separator, we can return location as-is.
+	 */
+	if (!prefix_len && !need_bs_to_fs)
+		return location;
+
 	/* Does it not start with the expected prefix? */
 	if (fspathncmp(location, prefix, prefix_len))
 		return location;
 
 	strlcpy(buf, location + prefix_len, sizeof(buf));
 	/* convert backslashes to forward slashes */
-	for (p = buf; *p; p++)
-		if (*p == '\\')
-			*p = '/';
-
+	if (need_bs_to_fs) {
+		for (p = buf; *p; p++)
+			if (*p == '\\')
+				*p = '/';
+	}
 	return buf;
 }
-#endif
 
 static void msg_with_prefix(const char *prefix, const char *format, va_list ap)
 {
Signature · 1 line
2.44.0-rc0
#1 lore raw

Hi Junio

Quoted 14 lines · Junio C Hamano

There are compilers other than Visual C that want to show absolute paths. Generalize the helper introduced by a2c5e294 (unit-tests: do show relative file paths, 2023-09-25) so that it can also work with a path that uses slash as the directory separator, and becomes almost no-op once one-time preparation finds out that we are using a compiler that already gives relative paths. Incidentally, this also should do the right thing on Windows with a compiler that shows relative paths but with backslash as the directory separator (if such a thing exists and is used to build git).

---

Quoted 7 lines

* Another change I made, which is not described in the proposed commit log message, is that we now use fspathcmp() instead of strcmp() to precompute the prefix length using a known needle[] string, to be consistent with the runtime check done for each and every path.

This is a belated follow-up on <f0b804129e8a21449cbb6f346473d3570182ddfa.1695640837.git.gitgitgadget@gmail.com>

Thanks for putting this together - I was about to sit down and write something similar when I saw your patch. I've left one comment below but I don't think it is worth a re-roll, this looks good to me.

t/unit-tests/test-lib.c static const char *make_relative(const char *location) · line 72

Quoted 10 lines
t/unit-tests/test-lib.c +10 -0
+		/*
+		 * prefix_len == 0 if the compiler gives paths relative
+		 * to the root of the working tree.  Otherwise, we want
+		 * to see that we did find the needle[] at a directory
+		 * boundary.
+		 */
+		if (fspathcmp(needle, prefix + prefix_len) ||
+		    (prefix_len &&
+		     prefix[prefix_len - 1] != '/' &&
+		     prefix[prefix_len - 1] != '\\'))

We know which separator we're expecting so we could replace the last two comparisons with

		prefix[prefix_len -1] != needle[1]

but as I say I'm not sure that is worth re-rolling for

Best Wishes

Phillip

#2 lore raw

PATCH v2 1/1 unit-tests: do show relative file paths on non-Windows, too

Quoted 7 lines

We know which separator we're expecting so we could replace the last two comparisons with

		prefix[prefix_len -1] != needle[1]

but as I say I'm not sure that is worth re-rolling for

There is a larger clean-up opportunity to drop the need for making a copy, which probably is worth doing, so I folded the above into this version.

------- >8 ------------- >8 ------------- >8 ------------- >8 -------

There are compilers other than Visual C that want to show absolute paths. Generalize the helper introduced by a2c5e294 (unit-tests: do show relative file paths, 2023-09-25) so that it can also work with a path that uses slash as the directory separator, and becomes almost no-op once one-time preparation finds out that we are using a compiler that already gives relative paths. Incidentally, this also should do the right thing on Windows with a compiler that shows relative paths but with backslash as the directory separator (if such a thing exists and is used to build git).

---

* I found that the diff relative to the result of applying v1 was easier to follow than the range-diff, so here it is.

diff --git c/t/unit-tests/test-lib.c w/t/unit-tests/test-lib.c index 83c9eb8c59..66d6980ffb 100644
--- c/t/unit-tests/test-lib.c
+++ w/t/unit-tests/test-lib.c
@@ -64,34 +64,33 @@ static const char *make_relative(const char *location)
* prefix_len == 0 if the compiler gives paths relative
* to the root of the working tree. Otherwise, we want
* to see that we did find the needle[] at a directory
- * boundary.
+ * boundary. Again we rely on that needle[] begins with
+ * "t" followed by the directory separator.
*/
if (fspathcmp(needle, prefix + prefix_len) ||
- (prefix_len &&
- prefix[prefix_len - 1] != '/' &&
- prefix[prefix_len - 1] != '\\'))
+ (prefix_len && prefix[prefix_len - 1] != needle[1]))
die("unexpected suffix of '%s'", prefix);
-
}

/*
- * If our compiler gives relative paths and we do not need
- * to munge directory separator, we can return location as-is.
+ * Does it not start with the expected prefix?
+ * Return it as-is without making it worse.
*/
- if (!prefix_len && !need_bs_to_fs)
+ if (prefix_len && fspathncmp(location, prefix, prefix_len))
return location;

- /* Does it not start with the expected prefix? */
- if (fspathncmp(location, prefix, prefix_len))
- return location;
+ /*
+ * If we do not need to munge directory separator, we can return
+ * the substring at the tail of the location.
+ */
+ if (!need_bs_to_fs)
+ return location + prefix_len;

  -	strlcpy(buf, location + prefix_len, sizeof(buf));
   	/* convert backslashes to forward slashes */
  -	if (need_bs_to_fs) {
  -		for (p = buf; *p; p++)
  -			if (*p == '\\')
  -				*p = '/';
  -	}
  +	strlcpy(buf, location + prefix_len, sizeof(buf));
  +	for (p = buf; *p; p++)
  +		if (*p == '\\')
  +			*p = '/';
   	return buf;
   }
 t/unit-tests/test-lib.c | 61 +++++++++++++++++++++++++++++++----------
 1 file changed, 47 insertions(+), 14 deletions(-)
t/unit-tests/test-lib.c +47 -14
index 7bf9dfdb95..66d6980ffb 100644
@@ -21,12 +21,11 @@ static struct {
 	.result = RESULT_NONE,
 };
 
-#ifndef _MSC_VER
-#define make_relative(location) location
-#else
 /*
  * Visual C interpolates the absolute Windows path for `__FILE__`,
  * but we want to see relative paths, as verified by t0080.
+ * There are other compilers that do the same, and are not for
+ * Windows.
  */
 #include "dir.h"
 
@@ -34,32 +33,66 @@ static const char *make_relative(const char *location)
 {
 	static char prefix[] = __FILE__, buf[PATH_MAX], *p;
 	static size_t prefix_len;
+	static int need_bs_to_fs = -1;
 
-	if (!prefix_len) {
+	/* one-time preparation */
+	if (need_bs_to_fs < 0) {
 		size_t len = strlen(prefix);
-		const char *needle = "\\t\\unit-tests\\test-lib.c";
+		char needle[] = "t\\unit-tests\\test-lib.c";
 		size_t needle_len = strlen(needle);
 
-		if (len < needle_len || strcmp(needle, prefix + len - needle_len))
-			die("unexpected suffix of '%s'", prefix);
+		if (len < needle_len)
+			die("unexpected prefix '%s'", prefix);
+
+		/*
+		 * The path could be relative (t/unit-tests/test-lib.c)
+		 * or full (/home/user/git/t/unit-tests/test-lib.c).
+		 * Check the slash between "t" and "unit-tests".
+		 */
+		prefix_len = len - needle_len;
+		if (prefix[prefix_len + 1] == '/') {
+			/* Oh, we're not Windows */
+			for (size_t i = 0; i < needle_len; i++)
+				if (needle[i] == '\\')
+					needle[i] = '/';
+			need_bs_to_fs = 0;
+		} else {
+			need_bs_to_fs = 1;
+		}
 
-		/* let it end in a directory separator */
-		prefix_len = len - needle_len + 1;
+		/*
+		 * prefix_len == 0 if the compiler gives paths relative
+		 * to the root of the working tree.  Otherwise, we want
+		 * to see that we did find the needle[] at a directory
+		 * boundary.  Again we rely on that needle[] begins with
+		 * "t" followed by the directory separator.
+		 */
+		if (fspathcmp(needle, prefix + prefix_len) ||
+		    (prefix_len && prefix[prefix_len - 1] != needle[1]))
+			die("unexpected suffix of '%s'", prefix);
 	}
 
-	/* Does it not start with the expected prefix? */
-	if (fspathncmp(location, prefix, prefix_len))
+	/*
+	 * Does it not start with the expected prefix?
+	 * Return it as-is without making it worse.
+	 */
+	if (prefix_len && fspathncmp(location, prefix, prefix_len))
 		return location;
 
-	strlcpy(buf, location + prefix_len, sizeof(buf));
+	/*
+	 * If we do not need to munge directory separator, we can return
+	 * the substring at the tail of the location.
+	 */
+	if (!need_bs_to_fs)
+		return location + prefix_len;
+
 	/* convert backslashes to forward slashes */
+	strlcpy(buf, location + prefix_len, sizeof(buf));
 	for (p = buf; *p; p++)
 		if (*p == '\\')
 			*p = '/';
-
 	return buf;
 }
-#endif
 
 static void msg_with_prefix(const char *prefix, const char *format, va_list ap)
 {
Signature · 1 line
2.44.0-rc0
#3 lore raw

Hi Junio

Quoted 11 lines · Junio C Hamano
Quoted 7 lines

We know which separator we're expecting so we could replace the last two comparisons with

		prefix[prefix_len -1] != needle[1]

but as I say I'm not sure that is worth re-rolling for

There is a larger clean-up opportunity to drop the need for making a copy, which probably is worth doing, so I folded the above into this version.

Ooh, that's nice. This version looks good, I found the code comments very helpful

Best Wishes

Phillip

Quoted 176 lines

------- >8 ------------- >8 ------------- >8 ------------- >8 -------

There are compilers other than Visual C that want to show absolute paths. Generalize the helper introduced by a2c5e294 (unit-tests: do show relative file paths, 2023-09-25) so that it can also work with a path that uses slash as the directory separator, and becomes almost no-op once one-time preparation finds out that we are using a compiler that already gives relative paths. Incidentally, this also should do the right thing on Windows with a compiler that shows relative paths but with backslash as the directory separator (if such a thing exists and is used to build git).

---

   * I found that the diff relative to the result of applying v1 was
     easier to follow than the range-diff, so here it is.

   diff --git c/t/unit-tests/test-lib.c w/t/unit-tests/test-lib.c
   index 83c9eb8c59..66d6980ffb 100644
   --- c/t/unit-tests/test-lib.c
   +++ w/t/unit-tests/test-lib.c
   @@ -64,34 +64,33 @@ static const char *make_relative(const char *location)
    		 * prefix_len == 0 if the compiler gives paths relative
    		 * to the root of the working tree.  Otherwise, we want
    		 * to see that we did find the needle[] at a directory
   -		 * boundary.
   +		 * boundary.  Again we rely on that needle[] begins with
   +		 * "t" followed by the directory separator.
    		 */
    		if (fspathcmp(needle, prefix + prefix_len) ||
   -		    (prefix_len &&
   -		     prefix[prefix_len - 1] != '/' &&
   -		     prefix[prefix_len - 1] != '\\'))
   +		    (prefix_len && prefix[prefix_len - 1] != needle[1]))
    			die("unexpected suffix of '%s'", prefix);
   -
    	}
    
    	/*
   -	 * If our compiler gives relative paths and we do not need
   -	 * to munge directory separator, we can return location as-is.
   +	 * Does it not start with the expected prefix?
   +	 * Return it as-is without making it worse.
    	 */
   -	if (!prefix_len && !need_bs_to_fs)
   +	if (prefix_len && fspathncmp(location, prefix, prefix_len))
    		return location;
    
   -	/* Does it not start with the expected prefix? */
   -	if (fspathncmp(location, prefix, prefix_len))
   -		return location;
   +	/*
   +	 * If we do not need to munge directory separator, we can return
   +	 * the substring at the tail of the location.
   +	 */
   +	if (!need_bs_to_fs)
   +		return location + prefix_len;
    
   -	strlcpy(buf, location + prefix_len, sizeof(buf));
    	/* convert backslashes to forward slashes */
   -	if (need_bs_to_fs) {
   -		for (p = buf; *p; p++)
   -			if (*p == '\\')
   -				*p = '/';
   -	}
   +	strlcpy(buf, location + prefix_len, sizeof(buf));
   +	for (p = buf; *p; p++)
   +		if (*p == '\\')
   +			*p = '/';
    	return buf;
    }
  t/unit-tests/test-lib.c | 61 +++++++++++++++++++++++++++++++----------
  1 file changed, 47 insertions(+), 14 deletions(-)
t/unit-tests/test-lib.c +47 -14
index 7bf9dfdb95..66d6980ffb 100644
@@ -21,12 +21,11 @@ static struct {
  	.result = RESULT_NONE,
  };
 
-#ifndef _MSC_VER
-#define make_relative(location) location
-#else
  /*
   * Visual C interpolates the absolute Windows path for `__FILE__`,
   * but we want to see relative paths, as verified by t0080.
+ * There are other compilers that do the same, and are not for
+ * Windows.
   */
  #include "dir.h"
 
@@ -34,32 +33,66 @@ static const char *make_relative(const char *location)
  {
  	static char prefix[] = __FILE__, buf[PATH_MAX], *p;
  	static size_t prefix_len;
+	static int need_bs_to_fs = -1;
 
-	if (!prefix_len) {
+	/* one-time preparation */
+	if (need_bs_to_fs < 0) {
  		size_t len = strlen(prefix);
-		const char *needle = "\\t\\unit-tests\\test-lib.c";
+		char needle[] = "t\\unit-tests\\test-lib.c";
  		size_t needle_len = strlen(needle);
 
-		if (len < needle_len || strcmp(needle, prefix + len - needle_len))
-			die("unexpected suffix of '%s'", prefix);
+		if (len < needle_len)
+			die("unexpected prefix '%s'", prefix);
+
+		/*
+		 * The path could be relative (t/unit-tests/test-lib.c)
+		 * or full (/home/user/git/t/unit-tests/test-lib.c).
+		 * Check the slash between "t" and "unit-tests".
+		 */
+		prefix_len = len - needle_len;
+		if (prefix[prefix_len + 1] == '/') {
+			/* Oh, we're not Windows */
+			for (size_t i = 0; i < needle_len; i++)
+				if (needle[i] == '\\')
+					needle[i] = '/';
+			need_bs_to_fs = 0;
+		} else {
+			need_bs_to_fs = 1;
+		}
 
-		/* let it end in a directory separator */
-		prefix_len = len - needle_len + 1;
+		/*
+		 * prefix_len == 0 if the compiler gives paths relative
+		 * to the root of the working tree.  Otherwise, we want
+		 * to see that we did find the needle[] at a directory
+		 * boundary.  Again we rely on that needle[] begins with
+		 * "t" followed by the directory separator.
+		 */
+		if (fspathcmp(needle, prefix + prefix_len) ||
+		    (prefix_len && prefix[prefix_len - 1] != needle[1]))
+			die("unexpected suffix of '%s'", prefix);
  	}
 
-	/* Does it not start with the expected prefix? */
-	if (fspathncmp(location, prefix, prefix_len))
+	/*
+	 * Does it not start with the expected prefix?
+	 * Return it as-is without making it worse.
+	 */
+	if (prefix_len && fspathncmp(location, prefix, prefix_len))
  		return location;
 
-	strlcpy(buf, location + prefix_len, sizeof(buf));
+	/*
+	 * If we do not need to munge directory separator, we can return
+	 * the substring at the tail of the location.
+	 */
+	if (!need_bs_to_fs)
+		return location + prefix_len;
+
  	/* convert backslashes to forward slashes */
+	strlcpy(buf, location + prefix_len, sizeof(buf));
  	for (p = buf; *p; p++)
  		if (*p == '\\')
  			*p = '/';
-
  	return buf;
  }
-#endif
 
  static void msg_with_prefix(const char *prefix, const char *format, va_list ap)
  {
#4 lore raw
Quoted 6 lines · Phillip Wood
Quoted 3 lines

There is a larger clean-up opportunity to drop the need for making a copy, which probably is worth doing, so I folded the above into this version.

Ooh, that's nice. This version looks good, I found the code comments very helpful

Thanks.

Judging from https://github.com/git/git/actions/runs/7878254534/job/21496314393#step:5:142
I do not seen to have broken Windows with this change, so let's
fast-track and merge it down to 'master' before -rc1.

Quoted 166 lines

Best Wishes

Phillip

Quoted 162 lines

------- >8 ------------- >8 ------------- >8 ------------- >8 ------- There are compilers other than Visual C that want to show absolute paths. Generalize the helper introduced by a2c5e294 (unit-tests: do show relative file paths, 2023-09-25) so that it can also work with a path that uses slash as the directory separator, and becomes almost no-op once one-time preparation finds out that we are using a compiler that already gives relative paths. Incidentally, this also should do the right thing on Windows with a compiler that shows relative paths but with backslash as the directory separator (if such a thing exists and is used to build git).

---
* I found that the diff relative to the result of applying v1 was easier to follow than the range-diff, so here it is.
diff --git c/t/unit-tests/test-lib.c w/t/unit-tests/test-lib.c index 83c9eb8c59..66d6980ffb 100644
--- c/t/unit-tests/test-lib.c
+++ w/t/unit-tests/test-lib.c
@@ -64,34 +64,33 @@ static const char *make_relative(const char *location)
* prefix_len == 0 if the compiler gives paths relative
* to the root of the working tree. Otherwise, we want
* to see that we did find the needle[] at a directory
- * boundary.
+ * boundary. Again we rely on that needle[] begins with
+ * "t" followed by the directory separator.

    		 */
    		if (fspathcmp(needle, prefix + prefix_len) ||
   -		    (prefix_len &&
   -		     prefix[prefix_len - 1] != '/' &&
   -		     prefix[prefix_len - 1] != '\\'))
   +		    (prefix_len && prefix[prefix_len - 1] != needle[1]))
    			die("unexpected suffix of '%s'", prefix);
   -
    	}
        	/*
   -	 * If our compiler gives relative paths and we do not need
   -	 * to munge directory separator, we can return location as-is.
   +	 * Does it not start with the expected prefix?
   +	 * Return it as-is without making it worse.
    	 */
   -	if (!prefix_len && !need_bs_to_fs)
   +	if (prefix_len && fspathncmp(location, prefix, prefix_len))
    		return location;
       -	/* Does it not start with the expected prefix? */
   -	if (fspathncmp(location, prefix, prefix_len))
   -		return location;
   +	/*
   +	 * If we do not need to munge directory separator, we can return
   +	 * the substring at the tail of the location.
   +	 */
   +	if (!need_bs_to_fs)
   +		return location + prefix_len;
       -	strlcpy(buf, location + prefix_len, sizeof(buf));
    	/* convert backslashes to forward slashes */
   -	if (need_bs_to_fs) {
   -		for (p = buf; *p; p++)
   -			if (*p == '\\')
   -				*p = '/';
   -	}
   +	strlcpy(buf, location + prefix_len, sizeof(buf));
   +	for (p = buf; *p; p++)
   +		if (*p == '\\')
   +			*p = '/';
    	return buf;
    }
      t/unit-tests/test-lib.c | 61
+++++++++++++++++++++++++++++++----------
  1 file changed, 47 insertions(+), 14 deletions(-)
t/unit-tests/test-lib.c +2 -2
index 7bf9dfdb95..66d6980ffb 100644
@@ -21,12 +21,11 @@ static struct {
  	.result = RESULT_NONE,
  };
  -#ifndef _MSC_VER
-#define make_relative(location) location
-#else
  /*
   * Visual C interpolates the absolute Windows path for `__FILE__`,
   * but we want to see relative paths, as verified by t0080.
+ * There are other compilers that do the same, and are not for
+ * Windows.
   */
  #include "dir.h"
  @@ -34,32 +33,66 @@ static const char *make_relative(const char

*location)
{
static char prefix[] = __FILE__, buf[PATH_MAX], *p; static size_t prefix_len;

t/unit-tests/test-lib.c +4 -1
+	static int need_bs_to_fs = -1;
  -	if (!prefix_len) {
+	/* one-time preparation */
+	if (need_bs_to_fs < 0) {
  		size_t len = strlen(prefix);
-		const char *needle = "\\t\\unit-tests\\test-lib.c";
+		char needle[] = "t\\unit-tests\\test-lib.c";
  		size_t needle_len = strlen(needle);
  -		if (len < needle_len || strcmp(needle, prefix + len -

needle_len))

t/unit-tests/test-lib.c +41 -5
-			die("unexpected suffix of '%s'", prefix);
+		if (len < needle_len)
+			die("unexpected prefix '%s'", prefix);
+
+		/*
+		 * The path could be relative (t/unit-tests/test-lib.c)
+		 * or full (/home/user/git/t/unit-tests/test-lib.c).
+		 * Check the slash between "t" and "unit-tests".
+		 */
+		prefix_len = len - needle_len;
+		if (prefix[prefix_len + 1] == '/') {
+			/* Oh, we're not Windows */
+			for (size_t i = 0; i < needle_len; i++)
+				if (needle[i] == '\\')
+					needle[i] = '/';
+			need_bs_to_fs = 0;
+		} else {
+			need_bs_to_fs = 1;
+		}
  -		/* let it end in a directory separator */
-		prefix_len = len - needle_len + 1;
+		/*
+		 * prefix_len == 0 if the compiler gives paths relative
+		 * to the root of the working tree.  Otherwise, we want
+		 * to see that we did find the needle[] at a directory
+		 * boundary.  Again we rely on that needle[] begins with
+		 * "t" followed by the directory separator.
+		 */
+		if (fspathcmp(needle, prefix + prefix_len) ||
+		    (prefix_len && prefix[prefix_len - 1] != needle[1]))
+			die("unexpected suffix of '%s'", prefix);
  	}
  -	/* Does it not start with the expected prefix? */
-	if (fspathncmp(location, prefix, prefix_len))
+	/*
+	 * Does it not start with the expected prefix?
+	 * Return it as-is without making it worse.
+	 */
+	if (prefix_len && fspathncmp(location, prefix, prefix_len))
  		return location;
  -	strlcpy(buf, location + prefix_len, sizeof(buf));
+	/*
+	 * If we do not need to munge directory separator, we can return
+	 * the substring at the tail of the location.
+	 */
+	if (!need_bs_to_fs)
+		return location + prefix_len;
+
  	/* convert backslashes to forward slashes */
+	strlcpy(buf, location + prefix_len, sizeof(buf));
  	for (p = buf; *p; p++)
  		if (*p == '\\')
  			*p = '/';
-
  	return buf;
  }
-#endif
    static void msg_with_prefix(const char *prefix, const char

*format, va_list ap)
{

#5 lore raw
Quoted 6 lines · Junio C Hamano
Quoted 4 lines · Phillip Wood
Quoted 3 lines

There is a larger clean-up opportunity to drop the need for making a copy, which probably is worth doing, so I folded the above into this version.

Quoted 8 lines
Quoted 2 lines

Ooh, that's nice. This version looks good, I found the code comments very helpful

Thanks.

Judging from https://github.com/git/git/actions/runs/7878254534/job/21496314393#step:5:142
I do not seen to have broken Windows with this change, so let's
fast-track and merge it down to 'master' before -rc1.

I think it was only the MSVC that needed the paths munging which we don't test by default. I have tweaked our github actions to run those tests and they pass https://github.com/phillipwood/git/actions/runs/7885144920/job/21515922057#step:5:146

Best Wishes

Phillip

Quoted 166 lines
Quoted 166 lines

Best Wishes

Phillip

Quoted 162 lines

------- >8 ------------- >8 ------------- >8 ------------- >8 ------- There are compilers other than Visual C that want to show absolute paths. Generalize the helper introduced by a2c5e294 (unit-tests: do show relative file paths, 2023-09-25) so that it can also work with a path that uses slash as the directory separator, and becomes almost no-op once one-time preparation finds out that we are using a compiler that already gives relative paths. Incidentally, this also should do the right thing on Windows with a compiler that shows relative paths but with backslash as the directory separator (if such a thing exists and is used to build git).

---

    * I found that the diff relative to the result of applying v1 was
      easier to follow than the range-diff, so here it is.
    diff --git c/t/unit-tests/test-lib.c w/t/unit-tests/test-lib.c
    index 83c9eb8c59..66d6980ffb 100644
    --- c/t/unit-tests/test-lib.c
    +++ w/t/unit-tests/test-lib.c
    @@ -64,34 +64,33 @@ static const char *make_relative(const char *location)
     		 * prefix_len == 0 if the compiler gives paths relative
     		 * to the root of the working tree.  Otherwise, we want
     		 * to see that we did find the needle[] at a directory
    -		 * boundary.
    +		 * boundary.  Again we rely on that needle[] begins with
    +		 * "t" followed by the directory separator.
     		 */
     		if (fspathcmp(needle, prefix + prefix_len) ||
    -		    (prefix_len &&
    -		     prefix[prefix_len - 1] != '/' &&
    -		     prefix[prefix_len - 1] != '\\'))
    +		    (prefix_len && prefix[prefix_len - 1] != needle[1]))
     			die("unexpected suffix of '%s'", prefix);
    -
     	}
         	/*
    -	 * If our compiler gives relative paths and we do not need
    -	 * to munge directory separator, we can return location as-is.
    +	 * Does it not start with the expected prefix?
    +	 * Return it as-is without making it worse.
     	 */
    -	if (!prefix_len && !need_bs_to_fs)
    +	if (prefix_len && fspathncmp(location, prefix, prefix_len))
     		return location;
        -	/* Does it not start with the expected prefix? */
    -	if (fspathncmp(location, prefix, prefix_len))
    -		return location;
    +	/*
    +	 * If we do not need to munge directory separator, we can return
    +	 * the substring at the tail of the location.
    +	 */
    +	if (!need_bs_to_fs)
    +		return location + prefix_len;
        -	strlcpy(buf, location + prefix_len, sizeof(buf));
     	/* convert backslashes to forward slashes */
    -	if (need_bs_to_fs) {
    -		for (p = buf; *p; p++)
    -			if (*p == '\\')
    -				*p = '/';
    -	}
    +	strlcpy(buf, location + prefix_len, sizeof(buf));
    +	for (p = buf; *p; p++)
    +		if (*p == '\\')
    +			*p = '/';
     	return buf;
     }
       t/unit-tests/test-lib.c | 61
+++++++++++++++++++++++++++++++----------
   1 file changed, 47 insertions(+), 14 deletions(-)
t/unit-tests/test-lib.c +2 -2
index 7bf9dfdb95..66d6980ffb 100644
@@ -21,12 +21,11 @@ static struct {
   	.result = RESULT_NONE,
   };
   -#ifndef _MSC_VER
-#define make_relative(location) location
-#else
   /*
    * Visual C interpolates the absolute Windows path for `__FILE__`,
    * but we want to see relative paths, as verified by t0080.
+ * There are other compilers that do the same, and are not for
+ * Windows.
    */
   #include "dir.h"
   @@ -34,32 +33,66 @@ static const char *make_relative(const char

*location)

   {
   	static char prefix[] = __FILE__, buf[PATH_MAX], *p;
   	static size_t prefix_len;
t/unit-tests/test-lib.c +4 -1
+	static int need_bs_to_fs = -1;
   -	if (!prefix_len) {
+	/* one-time preparation */
+	if (need_bs_to_fs < 0) {
   		size_t len = strlen(prefix);
-		const char *needle = "\\t\\unit-tests\\test-lib.c";
+		char needle[] = "t\\unit-tests\\test-lib.c";
   		size_t needle_len = strlen(needle);
   -		if (len < needle_len || strcmp(needle, prefix + len -

needle_len))

t/unit-tests/test-lib.c +41 -5
-			die("unexpected suffix of '%s'", prefix);
+		if (len < needle_len)
+			die("unexpected prefix '%s'", prefix);
+
+		/*
+		 * The path could be relative (t/unit-tests/test-lib.c)
+		 * or full (/home/user/git/t/unit-tests/test-lib.c).
+		 * Check the slash between "t" and "unit-tests".
+		 */
+		prefix_len = len - needle_len;
+		if (prefix[prefix_len + 1] == '/') {
+			/* Oh, we're not Windows */
+			for (size_t i = 0; i < needle_len; i++)
+				if (needle[i] == '\\')
+					needle[i] = '/';
+			need_bs_to_fs = 0;
+		} else {
+			need_bs_to_fs = 1;
+		}
   -		/* let it end in a directory separator */
-		prefix_len = len - needle_len + 1;
+		/*
+		 * prefix_len == 0 if the compiler gives paths relative
+		 * to the root of the working tree.  Otherwise, we want
+		 * to see that we did find the needle[] at a directory
+		 * boundary.  Again we rely on that needle[] begins with
+		 * "t" followed by the directory separator.
+		 */
+		if (fspathcmp(needle, prefix + prefix_len) ||
+		    (prefix_len && prefix[prefix_len - 1] != needle[1]))
+			die("unexpected suffix of '%s'", prefix);
   	}
   -	/* Does it not start with the expected prefix? */
-	if (fspathncmp(location, prefix, prefix_len))
+	/*
+	 * Does it not start with the expected prefix?
+	 * Return it as-is without making it worse.
+	 */
+	if (prefix_len && fspathncmp(location, prefix, prefix_len))
   		return location;
   -	strlcpy(buf, location + prefix_len, sizeof(buf));
+	/*
+	 * If we do not need to munge directory separator, we can return
+	 * the substring at the tail of the location.
+	 */
+	if (!need_bs_to_fs)
+		return location + prefix_len;
+
   	/* convert backslashes to forward slashes */
+	strlcpy(buf, location + prefix_len, sizeof(buf));
   	for (p = buf; *p; p++)
   		if (*p == '\\')
   			*p = '/';
-
   	return buf;
   }
-#endif
     static void msg_with_prefix(const char *prefix, const char

*format, va_list ap)
{

#7 lore raw
In reply to Junio C Hamano

Hi Junio,

Quoted 39 lines · Junio C Hamano
t/unit-tests/test-lib.c +10 -7
index 7bf9dfdb95..66d6980ffb 100644
@@ -21,12 +21,11 @@ static struct {
 	.result = RESULT_NONE,
 };
 
-#ifndef _MSC_VER
-#define make_relative(location) location
-#else
 /*
  * Visual C interpolates the absolute Windows path for `__FILE__`,
  * but we want to see relative paths, as verified by t0080.
+ * There are other compilers that do the same, and are not for
+ * Windows.
  */
 #include "dir.h"
 
@@ -34,32 +33,66 @@ static const char *make_relative(const char *location)
 {
 	static char prefix[] = __FILE__, buf[PATH_MAX], *p;
 	static size_t prefix_len;
+	static int need_bs_to_fs = -1;
 
-	if (!prefix_len) {
+	/* one-time preparation */
+	if (need_bs_to_fs < 0) {
 		size_t len = strlen(prefix);
-		const char *needle = "\\t\\unit-tests\\test-lib.c";
+		char needle[] = "t\\unit-tests\\test-lib.c";
 		size_t needle_len = strlen(needle);
 
-		if (len < needle_len || strcmp(needle, prefix + len - needle_len))
-			die("unexpected suffix of '%s'", prefix);
+		if (len < needle_len)
+			die("unexpected prefix '%s'", prefix);
+
+		/*

t/unit-tests/test-lib.c static const char *make_relative(const char *location) · line 57

Quoted 10 lines
t/unit-tests/test-lib.c +10 -0
+		 * The path could be relative (t/unit-tests/test-lib.c)
+		 * or full (/home/user/git/t/unit-tests/test-lib.c).
+		 * Check the slash between "t" and "unit-tests".
+		 */
+		prefix_len = len - needle_len;
+		if (prefix[prefix_len + 1] == '/') {
+			/* Oh, we're not Windows */
+			for (size_t i = 0; i < needle_len; i++)
+				if (needle[i] == '\\')
+					needle[i] = '/';

This looks very similar to the convert_slashes() function that is defined in compat/mingw.h. It might be a good opportunity to rename that function and move it to git-compat-util.h, then use it here and once more below at the end of make_relative().

That's just a nit, though. The patch looks good to me.

Thanks,
Johannes

Quoted 53 lines
t/unit-tests/test-lib.c +27 -8
+			need_bs_to_fs = 0;
+		} else {
+			need_bs_to_fs = 1;
+		}
 
-		/* let it end in a directory separator */
-		prefix_len = len - needle_len + 1;
+		/*
+		 * prefix_len == 0 if the compiler gives paths relative
+		 * to the root of the working tree.  Otherwise, we want
+		 * to see that we did find the needle[] at a directory
+		 * boundary.  Again we rely on that needle[] begins with
+		 * "t" followed by the directory separator.
+		 */
+		if (fspathcmp(needle, prefix + prefix_len) ||
+		    (prefix_len && prefix[prefix_len - 1] != needle[1]))
+			die("unexpected suffix of '%s'", prefix);
 	}
 
-	/* Does it not start with the expected prefix? */
-	if (fspathncmp(location, prefix, prefix_len))
+	/*
+	 * Does it not start with the expected prefix?
+	 * Return it as-is without making it worse.
+	 */
+	if (prefix_len && fspathncmp(location, prefix, prefix_len))
 		return location;
 
-	strlcpy(buf, location + prefix_len, sizeof(buf));
+	/*
+	 * If we do not need to munge directory separator, we can return
+	 * the substring at the tail of the location.
+	 */
+	if (!need_bs_to_fs)
+		return location + prefix_len;
+
 	/* convert backslashes to forward slashes */
+	strlcpy(buf, location + prefix_len, sizeof(buf));
 	for (p = buf; *p; p++)
 		if (*p == '\\')
 			*p = '/';
-
 	return buf;
 }
-#endif
 
 static void msg_with_prefix(const char *prefix, const char *format, va_list ap)
 {
--

2.44.0-rc0

#8 lore raw
Quoted 6 lines · Johannes Schindelin
Quoted 6 lines
t/unit-tests/test-lib.c +6 -0
+		/*
+		 * The path could be relative (t/unit-tests/test-lib.c)
+		 * or full (/home/user/git/t/unit-tests/test-lib.c).
+		 * Check the slash between "t" and "unit-tests".
+		 */
+		prefix_len = len - needle_len;
Quoted 8 lines

t/unit-tests/test-lib.c static const char *make_relative(const char *location) · line 57

Quoted 5 lines
t/unit-tests/test-lib.c +5 -0
+		if (prefix[prefix_len + 1] == '/') {
+			/* Oh, we're not Windows */
+			for (size_t i = 0; i < needle_len; i++)
+				if (needle[i] == '\\')
+					needle[i] = '/';

This looks very similar to the convert_slashes() function that is defined in compat/mingw.h.

I lifted it from your later loop in the function, but given that many of the things that needed on Windows came from you, it is not surprising if you have another copy there ;-)

Quoted 3 lines

It might be a good opportunity to rename that
function and move it to git-compat-util.h, then use it here and once more below at the end of make_relative().

Right. But not as part of the -rc fix. Let's leave it as #leftoverbits.

Thanks.