Merge branch 'topic/ci-fixes' (CI green-keeping fixes)

Author: dscho

Makefile

@@ -811,6 +811,7 @@ TEST_BUILTINS_OBJS += test-csprng.o
 TEST_BUILTINS_OBJS += test-date.o
 TEST_BUILTINS_OBJS += test-delete-gpgsig.o
 TEST_BUILTINS_OBJS += test-delta.o
+TEST_BUILTINS_OBJS += test-diff-process-backend.o
 TEST_BUILTINS_OBJS += test-dir-iterator.o
 TEST_BUILTINS_OBJS += test-drop-caches.o
 TEST_BUILTINS_OBJS += test-dump-cache-tree.o

t/helper/meson.build

@@ -12,6 +12,7 @@ test_tool_sources = [
   'test-date.c',
   'test-delete-gpgsig.c',
   'test-delta.c',
+  'test-diff-process-backend.c',
   'test-dir-iterator.c',
   'test-drop-caches.c',
   'test-dump-cache-tree.c',

t/helper/test-diff-process-backend.c

@@ -0,0 +1,278 @@
+/*
+ * Test backend for the long-running diff process protocol
+ * (see diff-process.c and Documentation/gitattributes.adoc).
+ *
+ * Usage: test-tool diff-process-backend --mode=<mode> [--log=<path>]
+ *
+ * Implements the server side of the handshake
+ *
+ *   git>  git-diff-client / version=1 / flush
+ *   tool< git-diff-server / version=1 / flush
+ *   git>  capability=hunks / flush
+ *   tool< capability=hunks / flush
+ *
+ * and a per-file response loop driven by a single --mode= switch so
+ * that t4080-diff-process.sh can exercise every documented branch
+ * (success, error, abort, crash, malformed hunks) from a shell test
+ * without having to depend on Python or Perl.
+ *
+ * Each request from Git looks like
+ *
+ *   git>  command=hunks / pathname=<path> / flush
+ *   git>  <old content packetized> / flush
+ *   git>  <new content packetized> / flush
+ *
+ * and the response chosen by --mode is
+ *
+ *   whole-file (default)   hunk 1 <old-lines> 1 <new-lines>; status=success
+ *   fixed-hunk             hunk 5 2 5 2;                     status=success
+ *   no-hunks               (no hunk lines);                  status=success
+ *   bad-hunk               hunk 999 1 999 1;                 status=success
+ *   bad-sync               hunk 1 2 1 1;                     status=success
+ *   overlap                hunk 1 5 1 5 + hunk 3 2 3 2;      status=success
+ *   error                  (no hunk lines);                  status=error
+ *   abort                  (no hunk lines);                  status=abort
+ *   crash                  exit(1) after reading the request
+ *
+ * Each request is summarised in the --log file as
+ *
+ *   command=<cmd> pathname=<path> old=<first line> new=<first line>
+ *
+ * which is what t4080's test_grep assertions key off of.
+ */
+
+#include "test-tool.h"
+#include "pkt-line.h"
+#include "parse-options.h"
+#include "strbuf.h"
+
+static FILE *logfile;
+
+enum mode {
+	MODE_WHOLE_FILE,
+	MODE_FIXED_HUNK,
+	MODE_NO_HUNKS,
+	MODE_BAD_HUNK,
+	MODE_BAD_SYNC,
+	MODE_OVERLAP,
+	MODE_ERROR,
+	MODE_ABORT,
+	MODE_CRASH,
+};
+
+static enum mode parse_mode(const char *s)
+{
+	if (!strcmp(s, "whole-file"))	return MODE_WHOLE_FILE;
+	if (!strcmp(s, "fixed-hunk"))	return MODE_FIXED_HUNK;
+	if (!strcmp(s, "no-hunks"))	return MODE_NO_HUNKS;
+	if (!strcmp(s, "bad-hunk"))	return MODE_BAD_HUNK;
+	if (!strcmp(s, "bad-sync"))	return MODE_BAD_SYNC;
+	if (!strcmp(s, "overlap"))	return MODE_OVERLAP;
+	if (!strcmp(s, "error"))	return MODE_ERROR;
+	if (!strcmp(s, "abort"))	return MODE_ABORT;
+	if (!strcmp(s, "crash"))	return MODE_CRASH;
+	die("unknown --mode=%s", s);
+}
+
+/*
+ * Drain "key=value" packets up to the next flush, capturing the
+ * "command" and "pathname" values.  Any other key is accepted and
+ * ignored so the helper stays forward-compatible with future Git
+ * versions that may add per-request metadata.
+ *
+ * Returns 1 if a request header was read, 0 on EOF (Git closed
+ * its end and is shutting down the long-running process).
+ */
+static int read_request_header(char **command, char **pathname)
+{
+	int first = 1;
+	char *line;
+
+	*command = *pathname = NULL;
+	for (;;) {
+		int len;
+		const char *value;
+
+		/*
+		 * Use the gentle variant for the first packet only so
+		 * that a clean shutdown by Git does not produce a
+		 * spurious "the remote end hung up unexpectedly" on
+		 * stderr.  Subsequent packets up to the flush are
+		 * guaranteed to be present, so the non-gentle variant
+		 * (which dies on truncation) is the right tool to
+		 * catch a misbehaving Git there.
+		 */
+		if (first) {
+			len = packet_read_line_gently(0, NULL, &line);
+			first = 0;
+			if (len < 0)
+				return 0;
+		} else {
+			line = packet_read_line(0, NULL);
+		}
+		if (!line)
+			break;
+		if (skip_prefix(line, "command=", &value))
+			*command = xstrdup(value);
+		else if (skip_prefix(line, "pathname=", &value))
+			*pathname = xstrdup(value);
+	}
+	return 1;
+}
+
+static size_t count_lines(const struct strbuf *buf)
+{
+	size_t lines = 0;
+
+	for (size_t i = 0; i < buf->len; i++)
+		if (buf->buf[i] == '\n')
+			lines++;
+
+	return lines + (buf->len > 0 && buf->buf[buf->len - 1] != '\n');
+}
+
+static void send_status(const char *status)
+{
+	packet_flush(1);
+	packet_write_fmt(1, "%s\n", status);
+	packet_flush(1);
+}
+
+static void respond(enum mode mode,
+		    const struct strbuf *old_buf,
+		    const struct strbuf *new_buf)
+{
+	switch (mode) {
+	case MODE_ERROR:
+		send_status("status=error");
+		return;
+	case MODE_ABORT:
+		send_status("status=abort");
+		return;
+	case MODE_CRASH:
+		exit(1);
+	case MODE_FIXED_HUNK:
+		packet_write_fmt(1, "hunk 5 2 5 2\n");
+		break;
+	case MODE_BAD_HUNK:
+		packet_write_fmt(1, "hunk 999 1 999 1\n");
+		break;
+	case MODE_BAD_SYNC:
+		packet_write_fmt(1, "hunk 1 2 1 1\n");
+		break;
+	case MODE_OVERLAP:
+		packet_write_fmt(1, "hunk 1 5 1 5\n");
+		packet_write_fmt(1, "hunk 3 2 3 2\n");
+		break;
+	case MODE_NO_HUNKS:
+		break;
+	case MODE_WHOLE_FILE:
+		packet_write_fmt(1, "hunk 1 %"PRIuMAX" 1 %"PRIuMAX"\n",
+				 (uintmax_t)count_lines(old_buf),
+				 (uintmax_t)count_lines(new_buf));
+		break;
+	}
+	send_status("status=success");
+}
+
+static void command_loop(enum mode mode)
+{
+	for (;;) {
+		char *command = NULL, *pathname = NULL;
+		struct strbuf obuf = STRBUF_INIT;
+		struct strbuf nbuf = STRBUF_INIT;
+
+		if (!read_request_header(&command, &pathname))
+			break; /* EOF: Git closed its end */
+
+		read_packetized_to_strbuf(0, &obuf, 0);
+		read_packetized_to_strbuf(0, &nbuf, 0);
+
+		if (logfile) {
+			fprintf(logfile,
+				"command=%s pathname=%s old=%.*s new=%.*s\n",
+				command ? command : "(none)",
+				pathname ? pathname : "(none)",
+				(int)(strchrnul(obuf.buf, '\n') - obuf.buf),
+				obuf.buf,
+				(int)(strchrnul(nbuf.buf, '\n') - nbuf.buf),
+				nbuf.buf);
+			fflush(logfile);
+		}
+
+		respond(mode, &obuf, &nbuf);
+
+		free(command);
+		free(pathname);
+		strbuf_release(&obuf);
+		strbuf_release(&nbuf);
+	}
+}
+
+static void handshake(void)
+{
+	char *line;
+
+	line = packet_read_line(0, NULL);
+	if (!line || strcmp(line, "git-diff-client"))
+		die("bad welcome: '%s'", line ? line : "(eof)");
+	line = packet_read_line(0, NULL);
+	if (!line || strcmp(line, "version=1"))
+		die("bad version: '%s'", line ? line : "(eof)");
+	if (packet_read_line(0, NULL))
+		die("expected flush after version");
+
+	packet_write_fmt(1, "git-diff-server\n");
+	packet_write_fmt(1, "version=1\n");
+	packet_flush(1);
+
+	/*
+	 * Git advertises capabilities and we acknowledge the ones we
+	 * support.  This backend always claims "hunks"; unknown
+	 * capabilities are silently dropped.
+	 */
+	while ((line = packet_read_line(0, NULL)))
+		; /* drain */
+	packet_write_fmt(1, "capability=hunks\n");
+	packet_flush(1);
+}
+
+static const char *const usage_str[] = {
+	"test-tool diff-process-backend --mode=<mode> [--log=<path>]",
+	NULL
+};
+
+int cmd__diff_process_backend(int argc, const char **argv)
+{
+	const char *mode_str = NULL, *log_path = NULL;
+	enum mode mode = MODE_WHOLE_FILE;
+	struct option options[] = {
+		OPT_STRING(0, "mode", &mode_str, "mode",
+			   "response shape: whole-file (default), fixed-hunk,"
+			   " no-hunks, bad-hunk, bad-sync, overlap, error,"
+			   " abort, crash"),
+		OPT_STRING(0, "log", &log_path, "path",
+			   "append per-request summary to this file"),
+		OPT_END()
+	};
+
+	argc = parse_options(argc, argv, NULL, options, usage_str, 0);
+	if (argc)
+		usage_with_options(usage_str, options);
+
+	if (mode_str)
+		mode = parse_mode(mode_str);
+
+	if (log_path) {
+		logfile = fopen(log_path, "a");
+		if (!logfile)
+			die_errno("failed to open log '%s'", log_path);
+	}
+
+	handshake();
+	command_loop(mode);
+
+	if (logfile && fclose(logfile))
+		die_errno("error closing log");
+	return 0;
+}

t/helper/test-tool.c

@@ -22,6 +22,7 @@ static struct test_cmd cmds[] = {
 	{ "date", cmd__date },
 	{ "delete-gpgsig", cmd__delete_gpgsig },
 	{ "delta", cmd__delta },
+	{ "diff-process-backend", cmd__diff_process_backend },
 	{ "dir-iterator", cmd__dir_iterator },
 	{ "drop-caches", cmd__drop_caches },
 	{ "dump-cache-tree", cmd__dump_cache_tree },

t/helper/test-tool.h

@@ -15,6 +15,7 @@ int cmd__csprng(int argc, const char **argv);
 int cmd__date(int argc, const char **argv);
 int cmd__delta(int argc, const char **argv);
 int cmd__delete_gpgsig(int argc, const char **argv);
+int cmd__diff_process_backend(int argc, const char **argv);
 int cmd__dir_iterator(int argc, const char **argv);
 int cmd__drop_caches(int argc, const char **argv);
 int cmd__dump_cache_tree(int argc, const char **argv);