From cbae1c219d97dbc3cb0b88abe3bf6c21d019ebf8 Mon Sep 17 00:00:00 2001
From: Edward Thomson <ethomson@edwardthomson.com>
Date: Wed, 1 Apr 2020 22:12:07 +0100
Subject: assert: allow non-int returning functions to assert

Include GIT_ASSERT_WITH_RETVAL and GIT_ASSERT_ARG_WITH_RETVAL so that
functions that do not return int (or more precisely, where `-1` would
not be an error code) can assert.

This allows functions that return, eg, NULL on an error code to do that
by passing the return value (in this example, `NULL`) as a second
parameter to the GIT_ASSERT_WITH_RETVAL functions.
---
 src/assert_safe.h   | 35 +++++++++++++++++++++--------------
 tests/core/assert.c | 53 +++++++++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 74 insertions(+), 14 deletions(-)

diff --git a/src/assert_safe.h b/src/assert_safe.h
index 9f2e16493..8c261100f 100644
--- a/src/assert_safe.h
+++ b/src/assert_safe.h
@@ -21,28 +21,35 @@
 
 # define GIT_ASSERT(expr) assert(expr)
 # define GIT_ASSERT_ARG(expr) assert(expr)
+
+# define GIT_ASSERT_WITH_RETVAL(expr, fail) assert(expr)
+# define GIT_ASSERT_ARG_WITH_RETVAL(expr, fail) assert(expr)
 #else
 
+/** Internal consistency check to stop the function. */
+# define GIT_ASSERT(expr) GIT_ASSERT_WITH_RETVAL(expr, -1)
+
 /**
  * Assert that a consumer-provided argument is valid, setting an
  * actionable error message and returning -1 if it is not.
  */
-# define GIT_ASSERT_ARG(expr) do { \
-		if (!(expr)) { \
-			git_error_set(GIT_ERROR_INVALID, \
-				"invalid argument: '%s'", \
-				#expr); \
-			return -1; \
-		} \
-	} while(0)
+# define GIT_ASSERT_ARG(expr) GIT_ASSERT_ARG_WITH_RETVAL(expr, -1)
+
+/** Internal consistency check to return the `fail` param on failure. */
+# define GIT_ASSERT_WITH_RETVAL(expr, fail) \
+	GIT_ASSERT__WITH_RETVAL(expr, GIT_ERROR_INTERNAL, "unrecoverable internal error", fail)
+
+/**
+ * Assert that a consumer-provided argument is valid, setting an
+ * actionable error message and returning the `fail` param if not.
+ */
+# define GIT_ASSERT_ARG_WITH_RETVAL(expr, fail) \
+	GIT_ASSERT__WITH_RETVAL(expr, GIT_ERROR_INVALID, "invalid argument", fail)
 
-/* Internal consistency check to stop the function. */
-# define GIT_ASSERT(expr) do { \
+# define GIT_ASSERT__WITH_RETVAL(expr, code, msg, fail) do { \
 		if (!(expr)) { \
-			git_error_set(GIT_ERROR_INTERNAL, \
-				"unrecoverable internal error: '%s'", \
-				#expr); \
-			return -1; \
+			git_error_set(code, "%s: '%s'", msg, #expr); \
+			return fail; \
 		} \
 	} while(0)
 
diff --git a/tests/core/assert.c b/tests/core/assert.c
index 5260b268e..ef75624b9 100644
--- a/tests/core/assert.c
+++ b/tests/core/assert.c
@@ -1,8 +1,13 @@
+#ifdef GIT_ASSERT_HARD
+# undef GIT_ASSERT_HARD
+#endif
+
 #define GIT_ASSERT_HARD 0
 
 #include "clar_libgit2.h"
 
 static const char *hello_world = "hello, world";
+static const char *fail = "FAIL";
 
 static int dummy_fn(const char *myarg)
 {
@@ -11,12 +16,26 @@ static int dummy_fn(const char *myarg)
 	return 0;
 }
 
+static const char *fn_returns_string(const char *myarg)
+{
+	GIT_ASSERT_ARG_WITH_RETVAL(myarg, fail);
+	GIT_ASSERT_ARG_WITH_RETVAL(myarg != hello_world, fail);
+
+	return myarg;
+}
+
 static int bad_math(void)
 {
 	GIT_ASSERT(1 + 1 == 3);
 	return 42;
 }
 
+static const char *bad_returns_string(void)
+{
+	GIT_ASSERT_WITH_RETVAL(1 + 1 == 3, NULL);
+	return hello_world;
+}
+
 void test_core_assert__argument(void)
 {
 	cl_git_fail(dummy_fn(NULL));
@@ -32,10 +51,44 @@ void test_core_assert__argument(void)
 	cl_git_pass(dummy_fn("foo"));
 }
 
+void test_core_assert__argument_with_non_int_return_type(void)
+{
+	const char *foo = "foo";
+
+	cl_assert_equal_p(fail, fn_returns_string(NULL));
+	cl_assert_equal_i(GIT_ERROR_INVALID, git_error_last()->klass);
+	cl_assert_equal_s("invalid argument: 'myarg'", git_error_last()->message);
+
+	cl_assert_equal_p(fail, fn_returns_string(hello_world));
+	cl_assert_equal_i(GIT_ERROR_INVALID, git_error_last()->klass);
+	cl_assert_equal_s("invalid argument: 'myarg != hello_world'", git_error_last()->message);
+
+	cl_assert_equal_p(foo, fn_returns_string(foo));
+}
+
+void test_core_assert__argument_with_void_return_type(void)
+{
+	const char *foo = "foo";
+
+	git_error_clear();
+	fn_returns_string(hello_world);
+	cl_assert_equal_i(GIT_ERROR_INVALID, git_error_last()->klass);
+	cl_assert_equal_s("invalid argument: 'myarg != hello_world'", git_error_last()->message);
+
+	git_error_clear();
+	cl_assert_equal_p(foo, fn_returns_string(foo));
+	cl_assert_equal_p(NULL, git_error_last());
+}
+
 void test_core_assert__internal(void)
 {
 	cl_git_fail(bad_math());
 	cl_assert(git_error_last());
 	cl_assert_equal_i(GIT_ERROR_INTERNAL, git_error_last()->klass);
 	cl_assert_equal_s("unrecoverable internal error: '1 + 1 == 3'", git_error_last()->message);
+
+	cl_assert_equal_p(NULL, bad_returns_string());
+	cl_assert(git_error_last());
+	cl_assert_equal_i(GIT_ERROR_INTERNAL, git_error_last()->klass);
+	cl_assert_equal_s("unrecoverable internal error: '1 + 1 == 3'", git_error_last()->message);
 }
-- 
cgit v1.2.1