gtk/tests/testtexthistory.c

#include "gtktexthistoryprivate.h"

#if 0
# define DEBUG_COMMANDS
#endif

typedef struct
{
  GtkTextHistory *history;
  GString *buf;
  struct {
    int insert;
    int bound;
  } selection;
  guint can_redo : 1;
  guint can_undo : 1;
  guint is_modified : 1;
} Text;

enum {
  IGNORE = 0,
  SET = 1,
  UNSET = 2,
};

enum {
  IGNORE_SELECT = 0,
  DO_SELECT = 1,
};

enum {
  INSERT = 1,
  INSERT_SEQ,
  BACKSPACE,
  DELETE_KEY,
  UNDO,
  REDO,
  BEGIN_IRREVERSIBLE,
  END_IRREVERSIBLE,
  BEGIN_USER,
  END_USER,
  MODIFIED,
  UNMODIFIED,
  SELECT,
  CHECK_SELECT,
  SET_MAX_UNDO,
};

typedef struct
{
  int kind;
  int location;
  int end_location;
  const char *text;
  const char *expected;
  int can_undo;
  int can_redo;
  int is_modified;
  int select;
} Command;

static void
do_change_state (gpointer funcs_data,
                 gboolean is_modified,
                 gboolean can_undo,
                 gboolean can_redo)
{
  Text *text = funcs_data;

  text->is_modified = is_modified;
  text->can_undo = can_undo;
  text->can_redo = can_redo;
}

static void
do_insert (gpointer    funcs_data,
           guint       begin,
           guint       end,
           const char *text,
           guint       len)
{
  Text *t = funcs_data;

#ifdef DEBUG_COMMANDS
  g_printerr ("Insert Into '%s' (begin=%u end=%u text=%s)\n",
              t->buf->str, begin, end, text);
#endif

  g_string_insert_len (t->buf, begin, text, len);
}

static void
do_delete (gpointer     funcs_data,
           guint        begin,
           guint        end,
           const char *expected_text,
           guint        len)
{
  Text *t = funcs_data;

#ifdef DEBUG_COMMANDS
  g_printerr ("Delete(begin=%u end=%u expected_text=%s)\n", begin, end, expected_text);
#endif

  if (end < begin)
    {
      guint tmp = end;
      end = begin;
      begin = tmp;
    }

  g_assert_cmpint (memcmp (t->buf->str + begin, expected_text, len), ==, 0);

  if (end >= t->buf->len)
    {
      t->buf->len = begin;
      t->buf->str[begin] = 0;
      return;
    }

  memmove (t->buf->str + begin,
           t->buf->str + end,
           t->buf->len - end);
  g_string_truncate (t->buf, t->buf->len - (end - begin));
}

static void
do_select (gpointer funcs_data,
           int      selection_insert,
           int      selection_bound)
{
  Text *text = funcs_data;

  text->selection.insert = selection_insert;
  text->selection.bound = selection_bound;
}

static GtkTextHistoryFuncs funcs = {
  do_change_state,
  do_insert,
  do_delete,
  do_select,
};

static Text *
text_new (void)
{
  Text *text = g_slice_new0 (Text);

  text->history = gtk_text_history_new (&funcs, text);
  text->buf = g_string_new (NULL);
  text->selection.insert = -1;
  text->selection.bound = -1;

  return text;
}

static void
text_free (Text *text)
{
  g_object_unref (text->history);
  g_string_free (text->buf, TRUE);
  g_slice_free (Text, text);
}

static void
command_insert (const Command *cmd,
                Text          *text)
{
  do_insert (text,
             cmd->location,
             cmd->location + g_utf8_strlen (cmd->text, -1),
             cmd->text,
             strlen (cmd->text));
  gtk_text_history_text_inserted (text->history, cmd->location, cmd->text, -1);
}

static void
command_delete_key (const Command *cmd,
                    Text          *text)
{
  do_delete (text,
             cmd->location,
             cmd->end_location,
             cmd->text,
             strlen (cmd->text));
  gtk_text_history_text_deleted (text->history,
                                 cmd->location,
                                 cmd->end_location,
                                 cmd->text,
                                 ABS (cmd->end_location - cmd->location));
}

static void
command_undo (const Command *cmd,
              Text          *text)
{
  gtk_text_history_undo (text->history);
}

static void
command_redo (const Command *cmd,
              Text          *text)
{
  gtk_text_history_redo (text->history);
}

static void
set_selection (Text *text,
               int   begin,
               int   end)
{
  gtk_text_history_selection_changed (text->history, begin, end);
}

static void
run_test (const Command *commands,
          guint          n_commands,
          guint          max_undo)
{
  Text *text = text_new ();

  if (max_undo)
    gtk_text_history_set_max_undo_levels (text->history, max_undo);

  for (guint i = 0; i < n_commands; i++)
    {
      const Command *cmd = &commands[i];

#ifdef DEBUG_COMMANDS
      g_printerr ("%d: %d\n", i, cmd->kind);
#endif

      switch (cmd->kind)
        {
        case INSERT:
          command_insert (cmd, text);
          break;

        case INSERT_SEQ:
          for (guint j = 0; cmd->text[j]; j++)
            {
              const char seqtext[2] = { cmd->text[j], 0 };
              Command seq = { INSERT, cmd->location + j, 1, seqtext, NULL };
              command_insert (&seq, text);
            }
          break;

        case DELETE_KEY:
          if (cmd->select == DO_SELECT)
            set_selection (text, cmd->location, cmd->end_location);
          else if (strlen (cmd->text) == 1)
            set_selection (text, cmd->location, -1);
          else
            set_selection (text, -1, -1);
          command_delete_key (cmd, text);
          break;

        case BACKSPACE:
          if (cmd->select == DO_SELECT)
            set_selection (text, cmd->location, cmd->end_location);
          else if (strlen (cmd->text) == 1)
            set_selection (text, cmd->end_location, -1);
          else
            set_selection (text, -1, -1);
          command_delete_key (cmd, text);
          break;

        case UNDO:
          command_undo (cmd, text);
          break;

        case REDO:
          command_redo (cmd, text);
          break;

        case BEGIN_USER:
          gtk_text_history_begin_user_action (text->history);
          break;

        case END_USER:
          gtk_text_history_end_user_action (text->history);
          break;

        case BEGIN_IRREVERSIBLE:
          gtk_text_history_begin_irreversible_action (text->history);
          break;

        case END_IRREVERSIBLE:
          gtk_text_history_end_irreversible_action (text->history);
          break;

        case MODIFIED:
          gtk_text_history_modified_changed (text->history, TRUE);
          break;

        case UNMODIFIED:
          gtk_text_history_modified_changed (text->history, FALSE);
          break;

        case SELECT:
          gtk_text_history_selection_changed (text->history,
                                              cmd->location,
                                              cmd->end_location);
          break;

        case CHECK_SELECT:
          g_assert_cmpint (text->selection.insert, ==, cmd->location);
          g_assert_cmpint (text->selection.bound, ==, cmd->end_location);
          break;

        case SET_MAX_UNDO:
          /* Not ideal use of location, but fine */
          gtk_text_history_set_max_undo_levels (text->history, cmd->location);
          break;

        default:
          break;
        }

      if (cmd->expected)
        g_assert_cmpstr (text->buf->str, ==, cmd->expected);

      if (cmd->can_redo == SET)
        g_assert_cmpint (text->can_redo, ==, TRUE);
      else if (cmd->can_redo == UNSET)
        g_assert_cmpint (text->can_redo, ==, FALSE);

      if (cmd->can_undo == SET)
        g_assert_cmpint (text->can_undo, ==, TRUE);
      else if (cmd->can_undo == UNSET)
        g_assert_cmpint (text->can_undo, ==, FALSE);

      if (cmd->is_modified == SET)
        g_assert_cmpint (text->is_modified, ==, TRUE);
      else if (cmd->is_modified == UNSET)
        g_assert_cmpint (text->is_modified, ==, FALSE);
    }

  text_free (text);
}

static void
test1 (void)
{
  static const Command commands[] = {
    { INSERT, 0, -1, "test", "test", SET, UNSET },
    { INSERT, 2, -1, "s", "tesst", SET, UNSET },
    { INSERT, 3, -1, "ss", "tesssst", SET, UNSET },
    { DELETE_KEY, 2, 5, "sss", "test", SET, UNSET },
    { UNDO, -1, -1, NULL, "tesssst", SET, SET },
    { REDO, -1, -1, NULL, "test", SET, UNSET },
    { UNDO, -1, -1, NULL, "tesssst", SET, SET },
    { DELETE_KEY, 0, 7, "tesssst", "", SET, UNSET },
    { INSERT, 0, -1, "z", "z", SET, UNSET },
    { UNDO, -1, -1, NULL, "", SET, SET },
    { UNDO, -1, -1, NULL, "tesssst", SET, SET },
    { UNDO, -1, -1, NULL, "test", SET, SET },
  };

  run_test (commands, G_N_ELEMENTS (commands), 0);
}

static void
test2 (void)
{
  static const Command commands[] = {
    { BEGIN_IRREVERSIBLE, -1, -1, NULL, "", UNSET, UNSET },
    { INSERT, 0, -1, "this is a test", "this is a test", UNSET, UNSET },
    { END_IRREVERSIBLE, -1, -1, NULL, "this is a test", UNSET, UNSET },
    { UNDO, -1, -1, NULL, "this is a test", UNSET, UNSET },
    { REDO, -1, -1, NULL, "this is a test", UNSET, UNSET },
    { BEGIN_USER, -1, -1, NULL, NULL, UNSET, UNSET },
    { INSERT, 0, -1, "first", "firstthis is a test", UNSET, UNSET },
    { INSERT, 5, -1, " ", "first this is a test", UNSET, UNSET },
    { END_USER, -1, -1, NULL, "first this is a test", SET, UNSET },
    { UNDO, -1, -1, NULL, "this is a test", UNSET, SET },
    { UNDO, -1, -1, NULL, "this is a test", UNSET, SET },
    { REDO, -1, -1, NULL, "first this is a test", SET, UNSET },
    { UNDO, -1, -1, NULL, "this is a test", UNSET, SET },
  };

  run_test (commands, G_N_ELEMENTS (commands), 0);
}

static void
test3 (void)
{
  static const Command commands[] = {
    { INSERT_SEQ, 0, -1, "this is a test of insertions.", "this is a test of insertions.", SET, UNSET },
    { UNDO, -1, -1, NULL, "this is a test of", SET, SET },
    { UNDO, -1, -1, NULL, "this is a test", SET, SET },
    { UNDO, -1, -1, NULL, "this is a", SET, SET },
    { UNDO, -1, -1, NULL, "this is", SET, SET },
    { UNDO, -1, -1, NULL, "this", SET, SET },
    { UNDO, -1, -1, NULL, "", UNSET, SET },
    { UNDO, -1, -1, NULL, "" , UNSET, SET },
    { REDO, -1, -1, NULL, "this", SET, SET },
    { REDO, -1, -1, NULL, "this is", SET, SET },
    { REDO, -1, -1, NULL, "this is a", SET, SET },
    { REDO, -1, -1, NULL, "this is a test", SET, SET },
    { REDO, -1, -1, NULL, "this is a test of", SET, SET },
    { REDO, -1, -1, NULL, "this is a test of insertions.", SET, UNSET },
  };

  run_test (commands, G_N_ELEMENTS (commands), 0);
}

static void
test4 (void)
{
  static const Command commands[] = {
    { INSERT, 0, -1, "initial text", "initial text", SET, UNSET },
    /* Barrier */
    { BEGIN_IRREVERSIBLE, -1, -1, NULL, NULL, UNSET, UNSET },
    { END_IRREVERSIBLE, -1, -1, NULL, NULL, UNSET, UNSET },
    { INSERT, 0, -1, "more text ", "more text initial text", SET, UNSET },
    { UNDO, -1, -1, NULL, "initial text", UNSET, SET },
    { UNDO, -1, -1, NULL, "initial text", UNSET, SET },
    { REDO, -1, -1, NULL, "more text initial text", SET, UNSET },
    /* Barrier */
    { BEGIN_IRREVERSIBLE, UNSET, UNSET },
    { END_IRREVERSIBLE, UNSET, UNSET },
    { UNDO, -1, -1, NULL, "more text initial text", UNSET, UNSET },
  };

  run_test (commands, G_N_ELEMENTS (commands), 0);
}

static void
test5 (void)
{
  static const Command commands[] = {
    { INSERT, 0, -1, "initial text", "initial text", SET, UNSET },
    { DELETE_KEY, 0, 12, "initial text", "", SET, UNSET },
    /* Add empty nested user action (should get ignored) */
    { BEGIN_USER, -1, -1, NULL, NULL, UNSET, UNSET },
      { BEGIN_USER, -1, -1, NULL, NULL, UNSET, UNSET },
        { BEGIN_USER, -1, -1, NULL, NULL, UNSET, UNSET },
        { END_USER, -1, -1, NULL, NULL, UNSET, UNSET },
      { END_USER, -1, -1, NULL, NULL, UNSET, UNSET },
    { END_USER, -1, -1, NULL, NULL, SET, UNSET },
    { UNDO, -1, -1, NULL, "initial text" },
  };

  run_test (commands, G_N_ELEMENTS (commands), 0);
}

static void
test6 (void)
{
  static const Command commands[] = {
    { INSERT_SEQ, 0, -1, " \t\t    this is some text", " \t\t    this is some text", SET, UNSET },
    { UNDO, -1, -1, NULL, " \t\t    this is some", SET, SET },
    { UNDO, -1, -1, NULL, " \t\t    this is", SET, SET },
    { UNDO, -1, -1, NULL, " \t\t    this", SET, SET },
    { UNDO, -1, -1, NULL, "", UNSET, SET },
    { UNDO, -1, -1, NULL, "", UNSET, SET },
  };

  run_test (commands, G_N_ELEMENTS (commands), 0);
}

static void
test7 (void)
{
  static const Command commands[] = {
    { MODIFIED, -1, -1, NULL, NULL, UNSET, UNSET, SET },
    { UNMODIFIED, -1, -1, NULL, NULL, UNSET, UNSET, UNSET },
    { INSERT, 0, -1, "foo bar", "foo bar", SET, UNSET, UNSET },
    { MODIFIED, -1, -1, NULL, NULL, SET, UNSET, SET },
    { UNDO, -1, -1, NULL, "", UNSET, SET, UNSET },
    { REDO, -1, -1, NULL, "foo bar", SET, UNSET, SET },
    { UNDO, -1, -1, NULL, "", UNSET, SET, UNSET },
    { REDO, -1, -1, NULL, "foo bar", SET, UNSET, SET },
  };

  run_test (commands, G_N_ELEMENTS (commands), 0);
}

static void
test8 (void)
{
  static const Command commands[] = {
    { INSERT, 0, -1, "foo bar", "foo bar", SET, UNSET, UNSET },
    { MODIFIED, -1, -1, NULL, NULL, SET, UNSET, SET },
    { INSERT, 0, -1, "f", "ffoo bar", SET, UNSET, SET },
    { UNMODIFIED, -1, -1, NULL, NULL, SET, UNSET, UNSET },
    { UNDO, -1, -1, NULL, "foo bar", SET, SET, SET },
    { UNDO, -1, -1, NULL, "", UNSET, SET, SET },
    { REDO, -1, -1, NULL, "foo bar", SET, SET, SET },
    { REDO, -1, -1, NULL, "ffoo bar", SET, UNSET, UNSET },
  };

  run_test (commands, G_N_ELEMENTS (commands), 0);
}

static void
test9 (void)
{
  static const Command commands[] = {
    { INSERT, 0, -1, "foo bar", "foo bar", SET, UNSET, UNSET },
    { DELETE_KEY, 0, 3, "foo", " bar", SET, UNSET, UNSET, DO_SELECT },
    { DELETE_KEY, 0, 4, " bar", "", SET, UNSET, UNSET, DO_SELECT },
    { UNDO, -1, -1, NULL, " bar", SET, SET, UNSET },
    { CHECK_SELECT, 0, 4, NULL, " bar", SET, SET, UNSET },
    { UNDO, -1, -1, NULL, "foo bar", SET, SET, UNSET },
    { CHECK_SELECT, 0, 3, NULL, "foo bar", SET, SET, UNSET },
    { BEGIN_IRREVERSIBLE, -1, -1, NULL, "foo bar", UNSET, UNSET, UNSET },
    { END_IRREVERSIBLE, -1, -1, NULL, "foo bar", UNSET, UNSET, UNSET },
  };

  run_test (commands, G_N_ELEMENTS (commands), 0);
}

static void
test10 (void)
{
  static const Command commands[] = {
    { BEGIN_USER }, { INSERT, 0, -1, "t", "t", UNSET, UNSET, UNSET }, { END_USER },
    { BEGIN_USER }, { INSERT, 1, -1, " ", "t ", UNSET, UNSET, UNSET }, { END_USER },
    { BEGIN_USER }, { INSERT, 2, -1, "t", "t t", UNSET, UNSET, UNSET }, { END_USER },
    { BEGIN_USER }, { INSERT, 3, -1, "h", "t th", UNSET, UNSET, UNSET }, { END_USER },
    { BEGIN_USER }, { INSERT, 4, -1, "i", "t thi", UNSET, UNSET, UNSET }, { END_USER },
    { BEGIN_USER }, { INSERT, 5, -1, "s", "t this", UNSET, UNSET, UNSET }, { END_USER },
  };

  run_test (commands, G_N_ELEMENTS (commands), 0);
}

static void
test11 (void)
{
  /* Test backspace */
  static const Command commands[] = {
    { INSERT_SEQ, 0, -1, "insert some text", "insert some text", SET, UNSET, UNSET },
    { BACKSPACE, 15, 16, "t", "insert some tex", SET, UNSET, UNSET },
    { BACKSPACE, 14, 15, "x", "insert some te", SET, UNSET, UNSET },
    { BACKSPACE, 13, 14, "e", "insert some t", SET, UNSET, UNSET },
    { BACKSPACE, 12, 13, "t", "insert some ", SET, UNSET, UNSET },
    { UNDO, -1, -1, NULL, "insert some text", SET, SET, UNSET },
  };

  run_test (commands, G_N_ELEMENTS (commands), 0);
}

static void
test12 (void)
{
  static const Command commands[] = {
    { INSERT_SEQ, 0, -1, "this is a test\nmore", "this is a test\nmore", SET, UNSET, UNSET },
    { UNDO, -1, -1, NULL, "this is a test\n", SET, SET, UNSET },
    { UNDO, -1, -1, NULL, "this is a test", SET, SET, UNSET },
    { UNDO, -1, -1, NULL, "this is a", SET, SET, UNSET },
    { UNDO, -1, -1, NULL, "this is", SET, SET, UNSET },
    { UNDO, -1, -1, NULL, "this", SET, SET, UNSET },
    { UNDO, -1, -1, NULL, "", UNSET, SET, UNSET },
  };

  run_test (commands, G_N_ELEMENTS (commands), 0);
}

static void
test13 (void)
{
  static const Command commands[] = {
    { INSERT_SEQ, 0, -1, "this is a test\nmore", "this is a test\nmore", SET, UNSET, UNSET },
    { UNDO, -1, -1, NULL, "this is a test\n", SET, SET, UNSET },
    { UNDO, -1, -1, NULL, "this is a test", SET, SET, UNSET },
    { UNDO, -1, -1, NULL, "this is a", UNSET, SET, UNSET },
    { UNDO, -1, -1, NULL, "this is a", UNSET, SET, UNSET },
    { SET_MAX_UNDO, 2, -1, NULL, "this is a", UNSET, SET, UNSET },
    { REDO, -1, -1, NULL, "this is a test", SET, SET, UNSET },
    { REDO, -1, -1, NULL, "this is a test\n", SET, UNSET, UNSET },
    { REDO, -1, -1, NULL, "this is a test\n", SET, UNSET, UNSET },
  };

  run_test (commands, G_N_ELEMENTS (commands), 3);
}

int
main (int   argc,
      char *argv[])
{
  g_test_init (&argc, &argv, NULL);
  g_test_add_func ("/Gtk/TextHistory/test1", test1);
  g_test_add_func ("/Gtk/TextHistory/test2", test2);
  g_test_add_func ("/Gtk/TextHistory/test3", test3);
  g_test_add_func ("/Gtk/TextHistory/test4", test4);
  g_test_add_func ("/Gtk/TextHistory/test5", test5);
  g_test_add_func ("/Gtk/TextHistory/test6", test6);
  g_test_add_func ("/Gtk/TextHistory/test7", test7);
  g_test_add_func ("/Gtk/TextHistory/test8", test8);
  g_test_add_func ("/Gtk/TextHistory/test9", test9);
  g_test_add_func ("/Gtk/TextHistory/test10", test10);
  g_test_add_func ("/Gtk/TextHistory/test11", test11);
  g_test_add_func ("/Gtk/TextHistory/test12", test12);
  g_test_add_func ("/Gtk/TextHistory/test13", test13);
  return g_test_run ();
}