mirror of
https://github.com/ZoiteChat/zoitechat.git
synced 2026-10-14 17:47:13 +00:00
598 lines
23 KiB
C
598 lines
23 KiB
C
/* XText regression tests. Distributed under GPL-2.0-or-later; see COPYING.
|
||
* Include the implementation to check layout/selection invariants without
|
||
* adding test-only symbols to the widget's public API. Application services
|
||
* are stubbed; GTK, Pango, Cairo and the widget itself are exercised normally. */
|
||
#include "../xtext.c"
|
||
#include <glib/gstdio.h>
|
||
|
||
struct zoitechatprefs prefs;
|
||
|
||
void emoji_font_apply (GtkWidget *widget) { }
|
||
int url_last (int *start, int *end) { return 0; }
|
||
gsize strftime_utf8 (char *dest, gsize size, const char *format, time_t stamp)
|
||
{
|
||
return strftime (dest, size, format, localtime (&stamp));
|
||
}
|
||
int xtext_get_stamp_str (time_t stamp, char **out)
|
||
{
|
||
*out = g_strdup ("[12:34] ");
|
||
return strlen (*out);
|
||
}
|
||
void theme_get_xtext_colors_for_widget (GtkWidget *widget, XTextColor *colors, size_t len)
|
||
{
|
||
size_t i;
|
||
for (i = 0; i < len; i++)
|
||
{
|
||
colors[i].red = colors[i].green = colors[i].blue = 0.0;
|
||
colors[i].alpha = 1.0;
|
||
}
|
||
colors[XTEXT_FG].red = colors[XTEXT_FG].green = colors[XTEXT_FG].blue = 1.0;
|
||
colors[XTEXT_MARK_BG].blue = 1.0;
|
||
colors[XTEXT_MARK_FG] = colors[XTEXT_FG];
|
||
colors[XTEXT_MARKER].red = 1.0;
|
||
}
|
||
|
||
typedef struct { GtkWidget *window; GtkXText *xtext; } Fixture;
|
||
|
||
static void drain_events (void)
|
||
{
|
||
while (g_main_context_iteration (NULL, FALSE)) { }
|
||
}
|
||
|
||
static void fixture_setup (Fixture *f, gconstpointer data)
|
||
{
|
||
XTextColor colors[XTEXT_COLS];
|
||
GtkWidget *scrolled = gtk_scrolled_window_new (NULL, NULL);
|
||
theme_get_xtext_colors_for_widget (NULL, colors, G_N_ELEMENTS (colors));
|
||
f->window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
|
||
gtk_window_set_default_size (GTK_WINDOW (f->window), 640, 360);
|
||
f->xtext = GTK_XTEXT (gtk_xtext_new (colors, TRUE));
|
||
g_object_ref (f->xtext);
|
||
gtk_container_add (GTK_CONTAINER (scrolled), GTK_WIDGET (f->xtext));
|
||
gtk_container_add (GTK_CONTAINER (f->window), scrolled);
|
||
g_assert_true (gtk_xtext_set_font (f->xtext, "monospace 12"));
|
||
gtk_widget_show_all (f->window);
|
||
drain_events ();
|
||
}
|
||
|
||
static void fixture_teardown (Fixture *f, gconstpointer data)
|
||
{
|
||
gtk_widget_destroy (f->window);
|
||
g_object_unref (f->xtext);
|
||
drain_events ();
|
||
g_assert_null (image_pending_list);
|
||
}
|
||
|
||
static void append (Fixture *f, const char *text)
|
||
{
|
||
gtk_xtext_append (f->xtext->buffer, (guchar *)text, -1, 1234);
|
||
}
|
||
|
||
static cairo_surface_t *snapshot (Fixture *f, gboolean partial)
|
||
{
|
||
GtkWidget *widget = GTK_WIDGET (f->xtext);
|
||
int width = gtk_widget_get_allocated_width (widget);
|
||
int height = gtk_widget_get_allocated_height (widget);
|
||
cairo_surface_t *surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, width, height);
|
||
cairo_t *cr = cairo_create (surface);
|
||
if (partial)
|
||
{
|
||
cairo_rectangle (cr, 0, f->xtext->fontsize, width, height - f->xtext->fontsize);
|
||
cairo_clip (cr);
|
||
}
|
||
gtk_widget_draw (widget, cr);
|
||
g_assert_cmpint (cairo_status (cr), ==, CAIRO_STATUS_SUCCESS);
|
||
cairo_destroy (cr);
|
||
cairo_surface_flush (surface);
|
||
return surface;
|
||
}
|
||
|
||
static void test_empty_and_bounded_append (Fixture *f, gconstpointer data)
|
||
{
|
||
const guchar bytes[] = {'a', 'b', 'c'}; /* deliberately no terminating NUL */
|
||
append (f, "");
|
||
g_assert_cmpstr ((char *)f->xtext->buffer->text_last->str, ==, "");
|
||
g_assert_cmpint (f->xtext->buffer->text_last->subline_count, ==, 1);
|
||
append (f, "\n");
|
||
g_assert_cmpint (f->xtext->buffer->text_last->str_len, ==, 0);
|
||
gtk_xtext_append (f->xtext->buffer, (guchar *)bytes, sizeof (bytes), 1234);
|
||
g_assert_cmpstr ((char *)f->xtext->buffer->text_last->str, ==, "abc");
|
||
gtk_xtext_append_indent (f->xtext->buffer, (guchar *)"", 0, (guchar *)"", 0, 1234);
|
||
g_assert_cmpstr ((char *)f->xtext->buffer->text_last->str, ==, " ");
|
||
}
|
||
|
||
static void test_utf8_limits (Fixture *f, gconstpointer data)
|
||
{
|
||
GString *text = g_string_new (NULL);
|
||
int i;
|
||
for (i = 0; i < 1500; i++) g_string_append (text, "猫");
|
||
gtk_xtext_append (f->xtext->buffer, (guchar *)text->str, text->len, 1234);
|
||
g_assert_cmpint (f->xtext->buffer->text_last->str_len, ==, 4095);
|
||
g_assert_true (g_utf8_validate ((char *)f->xtext->buffer->text_last->str, -1, NULL));
|
||
gtk_xtext_append_indent (f->xtext->buffer, (guchar *)text->str, text->len,
|
||
(guchar *)"猫", -1, 1234);
|
||
g_assert_cmpint (f->xtext->buffer->text_last->str_len, <=, 4095);
|
||
g_assert_true (g_utf8_validate ((char *)f->xtext->buffer->text_last->str, -1, NULL));
|
||
gtk_xtext_append (f->xtext->buffer, (guchar *)"hello 猫", 8, 1234);
|
||
g_assert_cmpstr ((char *)f->xtext->buffer->text_last->str, ==, "hello ");
|
||
gtk_xtext_append (f->xtext->buffer, (guchar *)"ok\xff" "bad", 6, 1234);
|
||
g_assert_cmpstr ((char *)f->xtext->buffer->text_last->str, ==, "ok");
|
||
g_string_free (text, TRUE);
|
||
}
|
||
|
||
static void test_null_empty_prefix (Fixture *f, gconstpointer data)
|
||
{
|
||
xtext_buffer *buf = f->xtext->buffer;
|
||
/* PrintTextLine passes NULL/0 for indented server text without a tab. */
|
||
gtk_xtext_append_indent (buf, NULL, 0, (guchar *)"server notice", -1, 1234);
|
||
g_assert_cmpstr ((char *)buf->text_last->str, ==, " server notice");
|
||
g_assert_cmpint (buf->text_last->left_len, ==, 0);
|
||
g_assert_cmpint (buf->text_last->stamp, ==, 1234);
|
||
gtk_xtext_append_indent (buf, (guchar *)"nick", -1, NULL, 0, 1234);
|
||
g_assert_cmpstr ((char *)buf->text_last->str, ==, "nick ");
|
||
gtk_xtext_append_indent (buf, NULL, 0, NULL, 0, 1234);
|
||
g_assert_cmpstr ((char *)buf->text_last->str, ==, " ");
|
||
g_assert_cmpint (buf->num_lines, ==, 3);
|
||
cairo_surface_destroy (snapshot (f, FALSE));
|
||
}
|
||
|
||
static void test_wrapping (Fixture *f, gconstpointer data)
|
||
{
|
||
xtext_buffer *buf = f->xtext->buffer;
|
||
textentry *ent;
|
||
int start = 0, i;
|
||
append (f, "猫猫猫猫猫猫猫猫猫猫");
|
||
ent = buf->text_last;
|
||
/* A character wider than the row must still be kept whole. */
|
||
buf->window_width = 3;
|
||
gtk_xtext_lines_taken (buf, ent);
|
||
g_assert_cmpint (ent->subline_count, ==, 10);
|
||
for (i = 0; i < ent->subline_count; i++)
|
||
{
|
||
int end = gtk_xtext_subline_end (ent, i);
|
||
g_assert_cmpint (end, >, start);
|
||
g_assert_true (g_utf8_validate ((char *)ent->str + start, end - start, NULL));
|
||
start = end;
|
||
}
|
||
buf->window_width = 120;
|
||
gtk_xtext_lines_taken (buf, ent);
|
||
g_assert_cmpint (ent->subline_count, >, 1);
|
||
buf->window_width = 640;
|
||
gtk_xtext_lines_taken (buf, ent);
|
||
g_assert_cmpint (ent->subline_count, ==, 1);
|
||
}
|
||
|
||
static void test_font_isolation (Fixture *f, gconstpointer data)
|
||
{
|
||
Fixture second;
|
||
int original = gtk_xtext_text_width (f->xtext, (guchar *)"WWii hello", 10);
|
||
fixture_setup (&second, NULL);
|
||
g_assert_true (gtk_xtext_set_font (second.xtext, "sans 30"));
|
||
g_assert_cmpint (gtk_xtext_text_width (second.xtext, (guchar *)"WWii hello", 10), >, original);
|
||
g_assert_cmpint (gtk_xtext_text_width (f->xtext, (guchar *)"WWii hello", 10), ==, original);
|
||
fixture_teardown (&second, NULL);
|
||
g_assert_cmpint (gtk_xtext_text_width (f->xtext, (guchar *)"WWii hello", 10), ==, original);
|
||
}
|
||
|
||
static void test_wide_metrics (Fixture *f, gconstpointer data)
|
||
{
|
||
char *text = g_strnfill (4000, 'W');
|
||
g_assert_true (gtk_xtext_set_font (f->xtext, "sans 40"));
|
||
append (f, text);
|
||
g_assert_cmpint (f->xtext->buffer->text_last->str_width, >, 65535);
|
||
g_assert_cmpint (f->xtext->buffer->text_last->subline_count, >, 1);
|
||
g_free (text);
|
||
}
|
||
|
||
static void test_formatting (Fixture *f, gconstpointer data)
|
||
{
|
||
const char *formatted = "a\002bold\002 \035italic\035 \00304,02red\017 \037u\037 \036s\036 \026r\026";
|
||
char *plain;
|
||
GSList *runs = NULL;
|
||
int len;
|
||
plain = (char *)gtk_xtext_strip_color ((guchar *)formatted, strlen (formatted), NULL, &len, &runs, FALSE);
|
||
g_assert_cmpstr (plain, ==, "abold italic red u s r");
|
||
g_assert_cmpint (len, ==, strlen (plain));
|
||
g_assert_cmpint (((offlen_t *)runs->data)->off, ==, 0);
|
||
g_slist_free_full (runs, g_free);
|
||
g_free (plain);
|
||
plain = (char *)gtk_xtext_strip_color ((guchar *)"a\010secret\010b", 10, NULL, &len, NULL, TRUE);
|
||
g_assert_cmpstr (plain, ==, "ab");
|
||
g_free (plain);
|
||
append (f, formatted);
|
||
gtk_xtext_append_indent (f->xtext->buffer, (guchar *)"nick", -1, (guchar *)formatted, -1, 1234);
|
||
f->xtext->auto_indent = TRUE;
|
||
f->xtext->buffer->time_stamp = TRUE;
|
||
f->xtext->buffer->indent = 130;
|
||
gtk_xtext_recalc_widths (f->xtext->buffer, FALSE);
|
||
cairo_surface_destroy (snapshot (f, FALSE));
|
||
g_assert_cmpstr ((char *)f->xtext->buffer->text_last->str, ==,
|
||
"nick a\002bold\002 \035italic\035 \00304,02red\017 \037u\037 \036s\036 \026r\026");
|
||
}
|
||
|
||
static void select_entries (Fixture *f, textentry *start, textentry *end)
|
||
{
|
||
textentry *ent;
|
||
for (ent = start; ent; ent = ent->next)
|
||
{
|
||
ent->mark_start = 0;
|
||
ent->mark_end = ent->str_len;
|
||
if (ent == end) break;
|
||
}
|
||
gtk_xtext_selection_render (f->xtext, start, end);
|
||
f->xtext->selection_buffer = f->xtext->buffer;
|
||
}
|
||
|
||
static void test_selection_and_clipboard (Fixture *f, gconstpointer data)
|
||
{
|
||
char *selected;
|
||
int len;
|
||
append (f, "");
|
||
append (f, "\002bold\002 猫");
|
||
append (f, "last");
|
||
select_entries (f, f->xtext->buffer->text_first, f->xtext->buffer->text_last);
|
||
selected = gtk_xtext_selection_get_text (f->xtext, &len);
|
||
g_assert_cmpstr (selected, ==, "\nbold 猫\nlast");
|
||
g_assert_cmpint (len, ==, strlen (selected));
|
||
g_free (selected);
|
||
f->xtext->color_paste = TRUE;
|
||
f->xtext->mark_stamp = TRUE;
|
||
selected = gtk_xtext_selection_get_text (f->xtext, &len);
|
||
g_assert_cmpstr (selected, ==, "\n[12:34] \002bold\002 猫\n[12:34] last");
|
||
g_free (selected);
|
||
f->xtext->color_paste = f->xtext->mark_stamp = FALSE;
|
||
gtk_xtext_copy_selection (f->xtext);
|
||
selected = gtk_clipboard_wait_for_text (gtk_widget_get_clipboard (GTK_WIDGET (f->xtext), GDK_SELECTION_CLIPBOARD));
|
||
g_assert_cmpstr (selected, ==, "\nbold 猫\nlast");
|
||
g_free (selected);
|
||
selected = gtk_clipboard_wait_for_text (gtk_widget_get_clipboard (GTK_WIDGET (f->xtext), GDK_SELECTION_PRIMARY));
|
||
g_assert_cmpstr (selected, ==, "\nbold 猫\nlast");
|
||
g_free (selected);
|
||
gtk_xtext_unselect (f->xtext);
|
||
g_assert_false (gtk_xtext_is_selecting (f->xtext));
|
||
}
|
||
|
||
static void test_search (Fixture *f, gconstpointer data)
|
||
{
|
||
GError *error = NULL;
|
||
textentry *first;
|
||
xtext_buffer *buf = f->xtext->buffer;
|
||
append (f, "one \002needle\002 then NEEDLE");
|
||
first = buf->text_last;
|
||
append (f, "second needle");
|
||
g_assert_true (gtk_xtext_search (f->xtext, "needle", highlight, &error) == first);
|
||
g_assert_no_error (error);
|
||
g_assert_cmpint (g_list_length (first->marks), ==, 2);
|
||
g_assert_true (gtk_xtext_search (f->xtext, "needle", highlight, &error) == first);
|
||
g_assert_true (gtk_xtext_search (f->xtext, "needle", highlight, &error) == buf->text_last);
|
||
gtk_xtext_search (f->xtext, "", 0, &error);
|
||
g_assert_null (buf->search_found);
|
||
g_assert_true (gtk_xtext_search (f->xtext, "needle", backward | case_match, &error) == buf->text_last);
|
||
gtk_xtext_search (f->xtext, "n[a-z]+", regexp | case_match, &error);
|
||
g_assert_no_error (error);
|
||
g_assert_nonnull (buf->search_re);
|
||
gtk_xtext_search (f->xtext, "[", regexp, &error);
|
||
g_assert_error (error, G_REGEX_ERROR, G_REGEX_ERROR_UNTERMINATED_CHARACTER_CLASS);
|
||
g_clear_error (&error);
|
||
/* A no-match search must also release its regex/text on clear. */
|
||
gtk_xtext_search (f->xtext, "nomatch", regexp, &error);
|
||
g_assert_null (buf->search_found);
|
||
gtk_xtext_clear (buf, 0);
|
||
g_assert_null (buf->search_re);
|
||
g_assert_null (buf->search_text);
|
||
}
|
||
|
||
static void test_follow_search (Fixture *f, gconstpointer data)
|
||
{
|
||
xtext_buffer *buf = f->xtext->buffer;
|
||
append (f, "match first");
|
||
gtk_xtext_search (f->xtext, "match", 0, NULL);
|
||
append (f, "match second");
|
||
gtk_xtext_search (f->xtext, NULL, follow, NULL);
|
||
g_assert_cmpint (g_list_length (buf->search_found), ==, 2);
|
||
GList *current = buf->curmark;
|
||
gtk_xtext_search (f->xtext, NULL, 0, NULL);
|
||
gtk_xtext_search (f->xtext, NULL, follow, NULL);
|
||
g_assert_cmpint (g_list_length (buf->search_found), ==, 2);
|
||
g_assert_true (buf->curmark == current);
|
||
append (f, "match third");
|
||
g_assert_cmpint (g_list_length (buf->search_found), ==, 3);
|
||
}
|
||
|
||
static void test_search_unicode_offsets (Fixture *f, gconstpointer data)
|
||
{
|
||
xtext_buffer *buf = f->xtext->buffer;
|
||
offsets_t mark;
|
||
append (f, "İ \002NEEDLE\002 Straße");
|
||
gtk_xtext_search (f->xtext, "needle", 0, NULL);
|
||
mark.u = GPOINTER_TO_UINT (buf->text_first->marks->data);
|
||
g_assert_cmpint (mark.o.start, ==, 4);
|
||
/* The established color-offset mapping includes the closing control. */
|
||
g_assert_cmpint (mark.o.end, ==, 11);
|
||
gtk_xtext_search (f->xtext, "ss", 0, NULL);
|
||
mark.u = GPOINTER_TO_UINT (buf->text_first->marks->data);
|
||
g_assert_cmpint (mark.o.start, ==, 16);
|
||
g_assert_cmpint (mark.o.end, ==, 18);
|
||
gtk_xtext_clear (buf, 0);
|
||
append (f, "ſ needle");
|
||
gtk_xtext_search (f->xtext, "needle", 0, NULL);
|
||
mark.u = GPOINTER_TO_UINT (buf->text_first->marks->data);
|
||
g_assert_cmpint (mark.o.start, ==, 3);
|
||
g_assert_cmpint (mark.o.end, ==, 9);
|
||
}
|
||
|
||
static void test_rawlog_hidden_text (Fixture *f, gconstpointer data)
|
||
{
|
||
int hidden, visible;
|
||
append (f, "a\010secret\010b");
|
||
hidden = f->xtext->buffer->text_last->str_width;
|
||
f->xtext->ignore_hidden = TRUE;
|
||
gtk_xtext_recalc_widths (f->xtext->buffer, TRUE);
|
||
visible = f->xtext->buffer->text_last->str_width;
|
||
g_assert_cmpint (visible, >, hidden);
|
||
g_assert_cmpint (visible, ==, gtk_xtext_text_width (f->xtext, (guchar *)"asecretb", 8));
|
||
}
|
||
|
||
static void test_save (Fixture *f, gconstpointer data)
|
||
{
|
||
char *path, *saved;
|
||
GError *error = NULL;
|
||
int fd = g_file_open_tmp ("zoitechat-xtext-XXXXXX", &path, &error);
|
||
g_assert_no_error (error);
|
||
append (f, "\002bold\002 猫");
|
||
append (f, "");
|
||
append (f, "last");
|
||
gtk_xtext_save (f->xtext, fd);
|
||
close (fd);
|
||
g_assert_true (g_file_get_contents (path, &saved, NULL, &error));
|
||
g_assert_no_error (error);
|
||
g_assert_cmpstr (saved, ==, "bold 猫\n\nlast\n");
|
||
g_free (saved);
|
||
g_unlink (path);
|
||
g_free (path);
|
||
}
|
||
|
||
static void test_scrollable_ownership (Fixture *f, gconstpointer data)
|
||
{
|
||
GtkAdjustment *horizontal = GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, 1, 1, 1, 1));
|
||
GtkAdjustment *vertical = GTK_ADJUSTMENT (gtk_adjustment_new (0, 0, 100, 1, 10, 10));
|
||
GtkAdjustment *old = g_object_ref (f->xtext->adj);
|
||
g_object_set (f->xtext, "hadjustment", horizontal, "vadjustment", vertical, NULL);
|
||
g_assert_false (g_object_is_floating (horizontal));
|
||
g_assert_false (g_object_is_floating (vertical));
|
||
g_assert_true (f->xtext->hadj == horizontal);
|
||
g_assert_true (f->xtext->adj == vertical);
|
||
/* A replaced adjustment must no longer call into the widget. */
|
||
g_assert_cmpuint (g_signal_handler_find (old, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, f->xtext), ==, 0);
|
||
g_signal_emit_by_name (f->xtext, "set-scroll-adjustments", horizontal, vertical);
|
||
g_assert_true (f->xtext->adj == vertical);
|
||
g_object_set (f->xtext, "hadjustment", NULL, "vadjustment", NULL, NULL);
|
||
g_assert_true (GTK_IS_ADJUSTMENT (f->xtext->hadj));
|
||
g_assert_true (GTK_IS_ADJUSTMENT (f->xtext->adj));
|
||
g_object_unref (old);
|
||
}
|
||
|
||
static void test_clear_and_marker (Fixture *f, gconstpointer data)
|
||
{
|
||
xtext_buffer *buf = f->xtext->buffer;
|
||
append (f, "first"); append (f, "second"); append (f, "third");
|
||
buf->marker_pos = buf->text_first;
|
||
buf->marker_state = MARKER_IS_SET;
|
||
gtk_xtext_clear (buf, 1);
|
||
g_assert_cmpstr ((char *)buf->text_first->str, ==, "second");
|
||
g_assert_cmpint (buf->marker_state, ==, MARKER_RESET_BY_CLEAR);
|
||
gtk_xtext_clear (buf, -1);
|
||
g_assert_cmpstr ((char *)buf->text_last->str, ==, "second");
|
||
select_entries (f, buf->text_first, buf->text_last);
|
||
f->xtext->hilight_ent = buf->text_first;
|
||
gtk_xtext_clear (buf, 0);
|
||
g_assert_null (f->xtext->hilight_ent);
|
||
g_assert_null (buf->pagetop_ent);
|
||
g_assert_null (buf->last_ent_start);
|
||
g_assert_cmpint (buf->num_lines, ==, 0);
|
||
g_assert_true (gtk_xtext_is_empty (buf));
|
||
append (f, "after clear");
|
||
g_assert_cmpint (buf->num_lines, ==, 1);
|
||
}
|
||
|
||
static void test_scrollback_limit (Fixture *f, gconstpointer data)
|
||
{
|
||
int i;
|
||
xtext_buffer *buf = f->xtext->buffer;
|
||
gtk_xtext_set_max_lines (f->xtext, 10);
|
||
for (i = 0; i < 100; i++) append (f, "line");
|
||
g_assert_cmpint (buf->num_lines, ==, 10);
|
||
g_assert_null (buf->text_first->prev);
|
||
g_assert_null (buf->text_last->next);
|
||
g_assert_cmpfloat (gtk_adjustment_get_value (f->xtext->adj), >=, 0);
|
||
}
|
||
|
||
static void test_follow_trim_oversized_entry (Fixture *f, gconstpointer data)
|
||
{
|
||
char *long_text = g_strnfill (4000, 'W');
|
||
gtk_xtext_set_max_lines (f->xtext, 3);
|
||
append (f, "needle");
|
||
gtk_xtext_search (f->xtext, "W", follow, NULL);
|
||
gtk_xtext_clear (f->xtext->buffer, 1);
|
||
append (f, long_text);
|
||
g_assert_true (gtk_xtext_is_empty (f->xtext->buffer));
|
||
g_assert_null (f->xtext->buffer->search_found);
|
||
g_free (long_text);
|
||
append (f, "after oversized");
|
||
gtk_xtext_clear (f->xtext->buffer, G_MININT);
|
||
g_assert_true (gtk_xtext_is_empty (f->xtext->buffer));
|
||
}
|
||
|
||
static void test_stress (Fixture *f, gconstpointer data)
|
||
{
|
||
static const char *tokens[] = {"text ", "猫", "😀", "\002bold\002", "\00304,02red\017", "\010hidden\010", "\037u\037", "\036s\036"};
|
||
GRand *random = g_rand_new_with_seed (0x78746578);
|
||
xtext_buffer *buf = f->xtext->buffer;
|
||
int i;
|
||
gtk_xtext_set_max_lines (f->xtext, 80);
|
||
for (i = 0; i < 2000; i++)
|
||
{
|
||
GString *text = g_string_new (NULL);
|
||
textentry *ent;
|
||
int j, lines = 0;
|
||
for (j = 0; j < 30; j++)
|
||
g_string_append (text, tokens[g_rand_int_range (random, 0, G_N_ELEMENTS (tokens))]);
|
||
if (i % 2)
|
||
gtk_xtext_append_indent (buf, (guchar *)"nick", -1, (guchar *)text->str, text->len, 1234);
|
||
else
|
||
gtk_xtext_append (buf, (guchar *)text->str, text->len, 1234);
|
||
g_string_free (text, TRUE);
|
||
if (i % 29 == 0) gtk_xtext_search (f->xtext, "text", follow | highlight, NULL);
|
||
if (i % 31 == 0) gtk_xtext_clear (buf, 1);
|
||
if (i % 37 == 0) gtk_xtext_clear (buf, -1);
|
||
if (i % 101 == 0) gtk_xtext_clear (buf, 0);
|
||
for (ent = buf->text_first; ent; ent = ent->next)
|
||
{
|
||
g_assert_true (g_utf8_validate ((char *)ent->str, ent->str_len, NULL));
|
||
g_assert_cmpint (ent->subline_count, >, 0);
|
||
lines += ent->subline_count;
|
||
}
|
||
g_assert_cmpint (buf->num_lines, ==, lines);
|
||
if (i % 43 == 0) cairo_surface_destroy (snapshot (f, FALSE));
|
||
}
|
||
g_rand_free (random);
|
||
}
|
||
|
||
static void test_buffers (Fixture *f, gconstpointer data)
|
||
{
|
||
xtext_buffer *original = f->xtext->buffer;
|
||
xtext_buffer *second = gtk_xtext_buffer_new (f->xtext);
|
||
append (f, "original");
|
||
gtk_xtext_append (second, (guchar *)"alternate", -1, 1234);
|
||
gtk_xtext_buffer_show (f->xtext, second, TRUE);
|
||
g_assert_true (f->xtext->buffer == second);
|
||
cairo_surface_destroy (snapshot (f, FALSE));
|
||
gtk_xtext_buffer_show (f->xtext, original, TRUE);
|
||
g_assert_cmpstr ((char *)f->xtext->buffer->text_first->str, ==, "original");
|
||
gtk_xtext_buffer_free (second);
|
||
}
|
||
|
||
static void test_partial_draw_after_scroll (Fixture *f, gconstpointer data)
|
||
{
|
||
cairo_surface_t *partial, *full;
|
||
int i, stride, height, y;
|
||
for (i = 0; i < 80; i++)
|
||
{
|
||
char *line = g_strdup_printf ("line %d — 猫 \002bold\002", i);
|
||
append (f, line);
|
||
g_free (line);
|
||
}
|
||
cairo_surface_destroy (snapshot (f, FALSE));
|
||
gtk_adjustment_set_value (f->xtext->adj, 12.5);
|
||
partial = snapshot (f, TRUE);
|
||
full = snapshot (f, FALSE);
|
||
stride = cairo_image_surface_get_stride (full);
|
||
height = cairo_image_surface_get_height (full);
|
||
for (y = f->xtext->fontsize; y < height; y++)
|
||
g_assert_cmpmem (cairo_image_surface_get_data (partial) + y * stride, stride,
|
||
cairo_image_surface_get_data (full) + y * stride, stride);
|
||
cairo_surface_destroy (partial);
|
||
cairo_surface_destroy (full);
|
||
}
|
||
|
||
static void test_image_lifecycle (Fixture *f, gconstpointer data)
|
||
{
|
||
GdkPixbuf *image = gdk_pixbuf_new (GDK_COLORSPACE_RGB, TRUE, 8, 800, 600);
|
||
xtext_buffer *buf = f->xtext->buffer;
|
||
textentry *ent;
|
||
guint handle;
|
||
int before;
|
||
gdk_pixbuf_fill (image, 0xff0000ff);
|
||
append (f, "image");
|
||
ent = buf->text_last;
|
||
before = buf->num_lines;
|
||
handle = gtk_xtext_image_load_begin (f->xtext, ent, "https://example.invalid/image.png");
|
||
g_assert_cmpuint (handle, !=, 0);
|
||
g_assert_cmpuint (gtk_xtext_image_load_begin (f->xtext, ent, "duplicate"), ==, 0);
|
||
g_assert_true (gtk_xtext_image_load_finish (handle, image));
|
||
g_assert_cmpint (buf->num_lines, >, before);
|
||
g_assert_true (gtk_xtext_entry_has_image (f->xtext, ent));
|
||
g_assert_cmpint (gdk_pixbuf_get_width (ent->image), <=, XTEXT_IMAGE_MAX_WIDTH);
|
||
g_assert_true (gtk_xtext_entry_get_full_image (f->xtext, ent) == image);
|
||
cairo_surface_destroy (snapshot (f, FALSE));
|
||
g_assert_true (gtk_xtext_image_remove (f->xtext, ent));
|
||
g_assert_cmpint (buf->num_lines, ==, before);
|
||
handle = gtk_xtext_image_load_begin (f->xtext, ent, "late");
|
||
gtk_xtext_clear (buf, 0);
|
||
g_assert_false (gtk_xtext_image_load_finish (handle, image));
|
||
g_assert_false (gtk_xtext_entry_has_image (f->xtext, ent));
|
||
g_assert_null (gtk_xtext_entry_get_full_image (f->xtext, ent));
|
||
g_object_unref (image);
|
||
}
|
||
|
||
static void test_background (Fixture *f, gconstpointer data)
|
||
{
|
||
cairo_surface_t *background = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, 32, 32);
|
||
cairo_t *cr = cairo_create (background);
|
||
cairo_set_source_rgb (cr, 0.2, 0.3, 0.4);
|
||
cairo_paint (cr);
|
||
cairo_destroy (cr);
|
||
gtk_xtext_set_background (f->xtext, background);
|
||
cairo_surface_destroy (background);
|
||
gtk_xtext_set_background (f->xtext, f->xtext->background_surface);
|
||
append (f, "background text");
|
||
cairo_surface_destroy (snapshot (f, FALSE));
|
||
gtk_xtext_set_background (f->xtext, NULL);
|
||
cairo_surface_destroy (snapshot (f, FALSE));
|
||
}
|
||
|
||
static void test_destroy_pending_sources (Fixture *f, gconstpointer data)
|
||
{
|
||
guint image;
|
||
append (f, "pending");
|
||
image = gtk_xtext_image_load_begin (f->xtext, f->xtext->buffer->text_last, "late");
|
||
f->xtext->io_tag = g_timeout_add (10000, gtk_xtext_adjustment_timeout, f->xtext);
|
||
f->xtext->add_io_tag = g_timeout_add (10000, gtk_xtext_render_page_timeout, f->xtext);
|
||
f->xtext->scroll_tag = g_timeout_add (10000, gtk_xtext_scrollup_timeout, f->xtext);
|
||
gtk_widget_destroy (f->window);
|
||
g_assert_cmpint (f->xtext->io_tag, ==, 0);
|
||
g_assert_cmpint (f->xtext->add_io_tag, ==, 0);
|
||
g_assert_cmpint (f->xtext->scroll_tag, ==, 0);
|
||
g_assert_false (gtk_xtext_image_load_finish (image, NULL));
|
||
/* GtkWidget destruction must be safe if GObject dispose runs again. */
|
||
g_object_run_dispose (G_OBJECT (f->xtext));
|
||
f->window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
|
||
}
|
||
|
||
int main (int argc, char **argv)
|
||
{
|
||
g_test_init (&argc, &argv, NULL);
|
||
if (!gtk_init_check (&argc, &argv))
|
||
{
|
||
g_test_message ("GTK display unavailable; run under Xvfb for widget coverage");
|
||
return 77;
|
||
}
|
||
prefs.hex_gui_mouse_scroll_speed = 10;
|
||
#define ADD(name, function) g_test_add ("/xtext/" name, Fixture, NULL, fixture_setup, function, fixture_teardown)
|
||
ADD ("append/empty-bounded", test_empty_and_bounded_append);
|
||
ADD ("append/utf8-limits", test_utf8_limits);
|
||
ADD ("append/null-empty-prefix", test_null_empty_prefix);
|
||
ADD ("layout/wrapping", test_wrapping);
|
||
ADD ("layout/font-isolation", test_font_isolation);
|
||
ADD ("layout/wide-metrics", test_wide_metrics);
|
||
ADD ("render/formatting-timestamps", test_formatting);
|
||
ADD ("selection/clipboard", test_selection_and_clipboard);
|
||
ADD ("search/navigation-regex-clear", test_search);
|
||
ADD ("search/follow", test_follow_search);
|
||
ADD ("search/unicode-offsets", test_search_unicode_offsets);
|
||
ADD ("render/rawlog-hidden", test_rawlog_hidden_text);
|
||
ADD ("buffer/save", test_save);
|
||
ADD ("lifecycle/scrollable-ownership", test_scrollable_ownership);
|
||
ADD ("buffer/clear-marker", test_clear_and_marker);
|
||
ADD ("buffer/scrollback-limit", test_scrollback_limit);
|
||
ADD ("buffer/follow-trim-oversized", test_follow_trim_oversized_entry);
|
||
ADD ("buffer/stress", test_stress);
|
||
ADD ("buffer/switch", test_buffers);
|
||
ADD ("render/partial-scroll", test_partial_draw_after_scroll);
|
||
ADD ("images/lifecycle", test_image_lifecycle);
|
||
ADD ("render/background", test_background);
|
||
ADD ("lifecycle/pending-sources", test_destroy_pending_sources);
|
||
#undef ADD
|
||
return g_test_run ();
|
||
}
|