test: port libvterm unit test to neovim test suite

These were imported from the v0.3.3 git tag
https://github.com/neovim/libvterm/tree/v0.3.3 and not the latest
commit. This is for compatibility reasons as the libvterm code was
imported from v0.3.3.

CMakeLists.txt

@@ -46,6 +46,7 @@ set(DEPS_IGNORE_SHA FALSE)
 #-------------------------------------------------------------------------------
 set(FUNCS_DATA ${PROJECT_BINARY_DIR}/funcs_data.mpack)
 set(TOUCHES_DIR ${PROJECT_BINARY_DIR}/touches)
+set(VTERM_TEST_FILE ${PROJECT_BINARY_DIR}/test/vterm_test_output)
 
 file(GLOB DOCFILES CONFIGURE_DEPENDS ${PROJECT_SOURCE_DIR}/runtime/doc/*.txt)
 

cmake.config/config.h.in

@@ -52,3 +52,5 @@
 #cmakedefine HAVE_BUILTIN_ADD_OVERFLOW
 #cmakedefine HAVE_WIMPLICIT_FALLTHROUGH_FLAG
 #cmakedefine HAVE_BITSCANFORWARD64
+
+#define VTERM_TEST_FILE "@VTERM_TEST_FILE@"

src/vterm/vterm.c

@@ -1,8 +1,9 @@
 #include "vterm_internal.h"
 
+#include "auto/config.h"
+#include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <stdarg.h>
 #include <string.h>
 
 /*****************
@@ -429,3 +430,509 @@ void vterm_check_version(int major, int minor)
 
   // Happy
 }
+
+// For unit tests.
+#ifndef NDEBUG
+
+int parser_text(const char bytes[], size_t len, void *user)
+{
+  FILE *f = fopen(VTERM_TEST_FILE, "a");
+  fprintf(f, "text ");
+  int i;
+  for(i = 0; i < len; i++) {
+    unsigned char b = bytes[i];
+    if(b < 0x20 || b == 0x7f || (b >= 0x80 && b < 0xa0)) {
+      break;
+    }
+    fprintf(f, i ? ",%x" : "%x", b);
+  }
+  fprintf(f, "\n");
+  fclose(f);
+
+  return i;
+}
+
+static void printchars(const char *s, size_t len, FILE *f)
+{
+  while(len--) {
+    fprintf(f, "%c", (s++)[0]);
+  }
+}
+
+int parser_csi(const char *leader, const long args[], int argcount, const char *intermed, char command, void *user)
+{
+  FILE *f = fopen(VTERM_TEST_FILE, "a");
+  fprintf(f, "csi %02x", command);
+
+  if(leader && leader[0]) {
+    fprintf(f, " L=");
+    for(int i = 0; leader[i]; i++) {
+      fprintf(f, "%02x", leader[i]);
+    }
+  }
+
+  for(int i = 0; i < argcount; i++) {
+    char sep = i ? ',' : ' ';
+
+    if(args[i] == CSI_ARG_MISSING) {
+      fprintf(f, "%c*", sep);
+    } else {
+      fprintf(f, "%c%ld%s", sep, CSI_ARG(args[i]), CSI_ARG_HAS_MORE(args[i]) ? "+" : "");
+    }
+  }
+
+  if(intermed && intermed[0]) {
+    fprintf(f, " I=");
+    for(int i = 0; intermed[i]; i++) {
+      fprintf(f, "%02x", intermed[i]);
+    }
+  }
+
+  fprintf(f, "\n");
+
+  fclose(f);
+
+  return 1;
+}
+
+int parser_osc(int command, VTermStringFragment frag, void *user)
+{
+  FILE *f = fopen(VTERM_TEST_FILE, "a");
+  fprintf(f, "osc ");
+
+  if(frag.initial) {
+    if(command == -1) {
+      fprintf(f, "[");
+    } else {
+      fprintf(f, "[%d;", command);
+    }
+  }
+
+  printchars(frag.str, frag.len, f);
+
+  if(frag.final) {
+    fprintf(f, "]");
+  }
+
+  fprintf(f, "\n");
+  fclose(f);
+
+  return 1;
+}
+
+int parser_dcs(const char *command, size_t commandlen, VTermStringFragment frag, void *user)
+{
+  FILE *f = fopen(VTERM_TEST_FILE, "a");
+  fprintf(f, "dcs ");
+
+  if(frag.initial) {
+    fprintf(f, "[");
+    for(int i = 0; i < commandlen; i++) {
+      fprintf(f, "%c", command[i]);
+    }
+  }
+
+  printchars(frag.str, frag.len,f);
+
+  if(frag.final) {
+    fprintf(f, "]");
+  }
+
+  fprintf(f, "\n");
+  fclose(f);
+
+  return 1;
+}
+
+int parser_apc(VTermStringFragment frag, void *user)
+{
+  FILE *f = fopen(VTERM_TEST_FILE, "a");
+  fprintf(f, "apc ");
+
+  if(frag.initial) {
+    fprintf(f, "[");
+  }
+
+  printchars(frag.str, frag.len, f);
+
+  if(frag.final) {
+    fprintf(f, "]");
+  }
+
+  fprintf(f, "\n");
+  fclose(f);
+
+  return 1;
+}
+
+int parser_pm(VTermStringFragment frag, void *user)
+{
+  FILE *f = fopen(VTERM_TEST_FILE, "a");
+  fprintf(f, "pm ");
+
+  if(frag.initial) {
+    fprintf(f, "[");
+  }
+
+  printchars(frag.str, frag.len,f);
+
+  if(frag.final) {
+    fprintf(f, "]");
+  }
+
+  fprintf(f, "\n");
+  fclose(f);
+
+  return 1;
+}
+
+int parser_sos(VTermStringFragment frag, void *user)
+{
+  FILE *f = fopen(VTERM_TEST_FILE, "a");
+  fprintf(f, "sos ");
+
+  if(frag.initial) {
+    fprintf(f, "[");
+  }
+
+  printchars(frag.str, frag.len,f);
+
+  if(frag.final) {
+    fprintf(f, "]");
+  }
+
+  fprintf(f, "\n");
+  fclose(f);
+
+  return 1;
+}
+
+int selection_set(VTermSelectionMask mask, VTermStringFragment frag, void *user)
+{
+  FILE *f = fopen(VTERM_TEST_FILE, "a");
+  fprintf(f, "selection-set mask=%04X ", mask);
+  if(frag.initial) {
+    fprintf(f, "[");
+}
+  printchars(frag.str, frag.len, f);
+  if(frag.final) {
+    fprintf(f, "]");
+}
+  fprintf(f,"\n");
+
+  fclose(f);
+  return 1;
+}
+
+int selection_query(VTermSelectionMask mask, void *user)
+{
+  FILE *f = fopen(VTERM_TEST_FILE, "a");
+  fprintf(f,"selection-query mask=%04X\n", mask);
+
+  fclose(f);
+  return 1;
+}
+
+bool want_state_putglyph;
+int state_putglyph(VTermGlyphInfo *info, VTermPos pos, void *user)
+{
+  if(!want_state_putglyph) {
+    return 1;
+  }
+
+  FILE *f = fopen(VTERM_TEST_FILE, "a");
+  fprintf(f, "putglyph ");
+  for(int i = 0; i < VTERM_MAX_CHARS_PER_CELL && info->chars[i]; i++) {
+    fprintf(f, i ? ",%x" : "%x", info->chars[i]);
+  }
+  fprintf(f, " %d %d,%d", info->width, pos.row, pos.col);
+  if(info->protected_cell) {
+    fprintf(f, " prot");
+  }
+  if(info->dwl) {
+    fprintf(f, " dwl");
+  }
+  if(info->dhl) {
+    fprintf(f, " dhl-%s", info->dhl == 1 ? "top" : info->dhl == 2 ? "bottom" : "?" );
+  }
+  fprintf(f, "\n");
+
+  fclose(f);
+
+  return 1;
+}
+
+bool want_state_movecursor;
+VTermPos state_pos;
+int state_movecursor(VTermPos pos, VTermPos oldpos, int visible, void *user)
+{
+  FILE *f = fopen(VTERM_TEST_FILE, "a");
+  state_pos = pos;
+
+  if(want_state_movecursor) {
+    fprintf(f,"movecursor %d,%d\n", pos.row, pos.col);
+  }
+
+  fclose(f);
+  return 1;
+}
+
+bool want_state_scrollrect;
+int state_scrollrect(VTermRect rect, int downward, int rightward, void *user)
+{
+  if(!want_state_scrollrect) {
+    return 0;
+  }
+
+  FILE *f = fopen(VTERM_TEST_FILE, "a");
+
+  fprintf(f,"scrollrect %d..%d,%d..%d => %+d,%+d\n",
+      rect.start_row, rect.end_row, rect.start_col, rect.end_col,
+      downward, rightward);
+
+  fclose(f);
+  return 1;
+}
+
+bool want_state_moverect;
+int state_moverect(VTermRect dest, VTermRect src, void *user)
+{
+  if(!want_state_moverect) {
+    return 0;
+  }
+
+  FILE *f = fopen(VTERM_TEST_FILE, "a");
+  fprintf(f,"moverect %d..%d,%d..%d -> %d..%d,%d..%d\n",
+      src.start_row,  src.end_row,  src.start_col,  src.end_col,
+      dest.start_row, dest.end_row, dest.start_col, dest.end_col);
+
+  fclose(f);
+  return 1;
+}
+
+void print_color(const VTermColor *col)
+{
+  FILE *f = fopen(VTERM_TEST_FILE, "a");
+  if (VTERM_COLOR_IS_RGB(col)) {
+    fprintf(f,"rgb(%d,%d,%d", col->rgb.red, col->rgb.green, col->rgb.blue);
+  }
+  else if (VTERM_COLOR_IS_INDEXED(col)) {
+    fprintf(f,"idx(%d", col->indexed.idx);
+  }
+  else {
+    fprintf(f,"invalid(%d", col->type);
+  }
+  if (VTERM_COLOR_IS_DEFAULT_FG(col)) {
+    fprintf(f,",is_default_fg");
+  }
+  if (VTERM_COLOR_IS_DEFAULT_BG(col)) {
+    fprintf(f,",is_default_bg");
+  }
+  fprintf(f,")");
+  fclose(f);
+}
+
+bool want_state_settermprop;
+int state_settermprop(VTermProp prop, VTermValue *val, void *user)
+{
+  if(!want_state_settermprop) {
+    return 1;
+  }
+
+  int errcode = 0;
+  FILE *f = fopen(VTERM_TEST_FILE, "a");
+
+  VTermValueType type = vterm_get_prop_type(prop);
+  switch(type) {
+    case VTERM_VALUETYPE_BOOL:
+      fprintf(f,"settermprop %d %s\n", prop, val->boolean ? "true" : "false");
+      errcode = 1;
+      goto end;
+    case VTERM_VALUETYPE_INT:
+      fprintf(f,"settermprop %d %d\n", prop, val->number);
+      errcode = 1;
+      goto end;
+    case VTERM_VALUETYPE_STRING:
+      fprintf(f,"settermprop %d %s\"%.*s\"%s\n", prop,
+          val->string.initial ? "[" : "", (int)val->string.len, val->string.str, val->string.final ? "]" : "");
+      errcode=0;
+      goto end;
+    case VTERM_VALUETYPE_COLOR:
+      fprintf(f,"settermprop %d ", prop);
+      print_color(&val->color);
+      fprintf(f,"\n");
+      errcode=1;
+      goto end;
+    case VTERM_N_VALUETYPES:
+      goto end;
+  }
+
+end:
+  fclose(f);
+  return errcode;
+}
+
+bool want_state_erase;
+int state_erase(VTermRect rect, int selective, void *user)
+{
+  if(!want_state_erase) {
+    return 1;
+  }
+
+  FILE *f = fopen(VTERM_TEST_FILE, "a");
+
+  fprintf(f,"erase %d..%d,%d..%d%s\n",
+      rect.start_row, rect.end_row, rect.start_col, rect.end_col,
+      selective ? " selective" : "");
+
+  fclose(f);
+  return 1;
+}
+
+struct {
+  int bold;
+  int underline;
+  int italic;
+  int blink;
+  int reverse;
+  int conceal;
+  int strike;
+  int font;
+  int small;
+  int baseline;
+  VTermColor foreground;
+  VTermColor background;
+} state_pen;
+
+int state_setpenattr(VTermAttr attr, VTermValue *val, void *user)
+{
+  switch(attr) {
+  case VTERM_ATTR_BOLD:
+    state_pen.bold = val->boolean;
+    break;
+  case VTERM_ATTR_UNDERLINE:
+    state_pen.underline = val->number;
+    break;
+  case VTERM_ATTR_ITALIC:
+    state_pen.italic = val->boolean;
+    break;
+  case VTERM_ATTR_BLINK:
+    state_pen.blink = val->boolean;
+    break;
+  case VTERM_ATTR_REVERSE:
+    state_pen.reverse = val->boolean;
+    break;
+  case VTERM_ATTR_CONCEAL:
+    state_pen.conceal = val->boolean;
+    break;
+  case VTERM_ATTR_STRIKE:
+    state_pen.strike = val->boolean;
+    break;
+  case VTERM_ATTR_FONT:
+    state_pen.font = val->number;
+    break;
+  case VTERM_ATTR_SMALL:
+    state_pen.small = val->boolean;
+    break;
+  case VTERM_ATTR_BASELINE:
+    state_pen.baseline = val->number;
+    break;
+  case VTERM_ATTR_FOREGROUND:
+    state_pen.foreground = val->color;
+    break;
+  case VTERM_ATTR_BACKGROUND:
+    state_pen.background = val->color;
+    break;
+
+  case VTERM_N_ATTRS:
+    return 0;
+  default:
+    break;
+  }
+
+  return 1;
+}
+
+bool want_state_scrollback;
+int state_sb_clear(void *user) {
+  if(!want_state_scrollback) {
+    return 1;
+  }
+
+  FILE *f = fopen(VTERM_TEST_FILE, "a");
+  fprintf(f,"sb_clear\n");
+  fclose(f);
+
+  return 0;
+}
+
+bool want_screen_scrollback;
+int screen_sb_pushline(int cols, const VTermScreenCell *cells, void *user)
+{
+  if(!want_screen_scrollback) {
+    return 1;
+  }
+
+  int eol = cols;
+  while(eol && !cells[eol-1].chars[0]) {
+    eol--;
+  }
+
+  FILE *f = fopen(VTERM_TEST_FILE, "a");
+  fprintf(f, "sb_pushline %d =", cols);
+  for(int c = 0; c < eol; c++) {
+    fprintf(f, " %02X", cells[c].chars[0]);
+  }
+  fprintf(f, "\n");
+
+  fclose(f);
+
+  return 1;
+}
+
+int screen_sb_popline(int cols, VTermScreenCell *cells, void *user)
+{
+  if(!want_screen_scrollback) {
+    return 0;
+  }
+
+  // All lines of scrollback contain "ABCDE"
+  for(int col = 0; col < cols; col++) {
+    if(col < 5) {
+      cells[col].chars[0] = 'A' + col;
+    } else {
+      cells[col].chars[0] = 0;
+    }
+
+    cells[col].width = 1;
+  }
+
+  FILE *f = fopen(VTERM_TEST_FILE, "a");
+  fprintf(f,"sb_popline %d\n", cols);
+  fclose(f);
+  return 1;
+}
+
+int screen_sb_clear(void *user)
+{
+  if(!want_screen_scrollback) {
+    return 1;
+  }
+
+  FILE *f = fopen(VTERM_TEST_FILE, "a");
+  fprintf(f, "sb_clear\n");
+  fclose(f);
+  return 0;
+}
+
+void term_output(const char *s, size_t len, void *user)
+{
+  FILE *f = fopen(VTERM_TEST_FILE, "a");
+  fprintf(f, "output ");
+  for(int i = 0; i < len; i++) {
+    fprintf(f, "%x%s", (unsigned char)s[i], i < len-1 ? "," : "\n");
+  }
+  fclose(f);
+}
+
+#endif

src/vterm/vterm.h

@@ -9,6 +9,7 @@ extern "C" {
 #include <stdlib.h>
 #include <stdbool.h>
 
+#include "nvim/macros_defs.h"
 #include "vterm_keycodes.h"
 
 #define VTERM_VERSION_MAJOR 0
@@ -21,7 +22,7 @@ extern "C" {
 /* Any cell can contain at most one basic printing character and 5 combining
  * characters. This number could be changed but will be ABI-incompatible if
  * you do */
-#define VTERM_MAX_CHARS_PER_CELL 6
+enum{ VTERM_MAX_CHARS_PER_CELL=6};
 
 typedef struct VTerm VTerm;
 typedef struct VTermState VTermState;
@@ -634,6 +635,40 @@ void vterm_copy_cells(VTermRect dest,
                       void (*copycell)(VTermPos dest, VTermPos src, void *user),
                       void *user);
 
+#ifndef NDEBUG
+int parser_text(const char bytes[], size_t len, void *user);
+int parser_csi(const char *leader, const long args[], int argcount, const char *intermed, char command, void *user);
+int parser_osc(int command, VTermStringFragment frag, void *user);
+int parser_dcs(const char *command, size_t commandlen, VTermStringFragment frag, void *user);
+int parser_apc(VTermStringFragment frag, void *user);
+int parser_pm(VTermStringFragment frag, void *user);
+int parser_sos(VTermStringFragment frag, void *user);
+int selection_set(VTermSelectionMask mask, VTermStringFragment frag, void *user);
+int selection_query(VTermSelectionMask mask, void *user);
+int state_putglyph(VTermGlyphInfo *info, VTermPos pos, void *user);
+int state_movecursor(VTermPos pos, VTermPos oldpos, int visible, void *user);
+int state_scrollrect(VTermRect rect, int downward, int rightward, void *user);
+int state_moverect(VTermRect dest, VTermRect src, void *user);
+int state_settermprop(VTermProp prop, VTermValue *val, void *user);
+int state_erase(VTermRect rect, int selective, void *user);
+int state_setpenattr(VTermAttr attr, VTermValue *val, void *user);
+int state_sb_clear(void *user);
+void print_color(const VTermColor *col);
+int screen_sb_pushline(int cols, const VTermScreenCell *cells, void *user);
+int screen_sb_popline(int cols, VTermScreenCell *cells, void *user);
+int screen_sb_clear(void *user);
+void term_output(const char *s, size_t len, void *user);
+EXTERN VTermPos state_pos;
+EXTERN bool want_state_putglyph INIT (=false);
+EXTERN bool want_state_movecursor INIT(= false);
+EXTERN bool want_state_erase INIT(= false);
+EXTERN bool want_state_scrollrect INIT(= false);
+EXTERN bool want_state_moverect INIT(= false);
+EXTERN bool want_state_settermprop INIT(= false);
+EXTERN bool want_state_scrollback INIT(= false);
+EXTERN bool want_screen_scrollback INIT(= false);
+#endif
+
 #ifdef __cplusplus
 }
 #endif

test/cmakeconfig/paths.lua.in

@@ -5,6 +5,7 @@ for p in ("${TEST_INCLUDE_DIRS}" .. ";"):gmatch("[^;]+") do
   table.insert(M.include_paths, p)
 end
 
+M.vterm_test_file = "${VTERM_TEST_FILE}"
 M.test_build_dir = "${CMAKE_BINARY_DIR}"
 M.test_source_path = "${CMAKE_SOURCE_DIR}"
 M.test_lua_prg = "${LUA_PRG}"

test/unit/testutil.lua

@@ -151,6 +151,13 @@ local function filter_complex_blocks(body)
         or string.find(line, 'mach_vm_range_recipe')
       )
     then
+      -- HACK: remove bitfields from specific structs as luajit can't seem to handle them.
+      if line:find('struct VTermState') then
+        line = string.gsub(line, 'state : 8;', 'state;')
+      end
+      if line:find('VTermStringFragment') then
+        line = string.gsub(line, 'size_t.*len : 30;', 'size_t len;')
+      end
       result[#result + 1] = line
     end
   end