forked from AuroraMiddleware/gtk
5e341210a1
The GtkTextHistory helper provides the fundamental undo/redo stack that can be integrated with other text widgets. It allows coalescing related actions to reduce both the number of undo actions to the user as well as the memory overhead. A new istring helper is used by GtkTextHistory to allow for "inline strings" that gracefully grow to using allocations with g_realloc(). This ensure that most undo operations require no additional allocations other than the struct for the action itself. A queue of undoable and redoable actions are maintained and the link for the queue is embedded in the undo action union. This allows again, for reducing the number of allocations involved for undo operations.
601 lines
17 KiB
C
601 lines
17 KiB
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 gchar *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,
|
|
gint selection_insert,
|
|
gint 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 ();
|
|
}
|