← Back to branch summary

~ubuntu-branches/debian/stretch/gnome-builder/stretch

« back to all changes in this revision

Viewing changes to tests/test-ide-buffer-manager.c

  • Committer: Package Import Robot
  • Author(s): Andreas Henriksson
  • Date: 2015-10-11 12:38:45 UTC
  • Revision ID: package-import@ubuntu.com-20151011123845-a0hvkz01se0p1p5a
Tags: upstream-3.16.3
Import upstream version 3.16.3

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/test-ide-buffer-manager.c
 
1
/* test-ide-buffer-manager.c
 
2
 *
 
3
 * Copyright (C) 2015 Christian Hergert <christian@hergert.me>
 
4
 *
 
5
 * This program is free software: you can redistribute it and/or modify
 
6
 * it under the terms of the GNU General Public License as published by
 
7
 * the Free Software Foundation, either version 3 of the License, or
 
8
 * (at your option) any later version.
 
9
 *
 
10
 * This program is distributed in the hope that it will be useful,
 
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
13
 * GNU General Public License for more details.
 
14
 *
 
15
 * You should have received a copy of the GNU General Public License
 
16
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
17
 */
 
18
 
 
19
#include <glib.h>
 
20
#include <glib/gstdio.h>
 
21
#include <girepository.h>
 
22
#include <ide.h>
 
23
 
 
24
typedef struct
 
25
{
 
26
  GMainLoop    *main_loop;
 
27
  IdeContext   *context;
 
28
  GCancellable *cancellable;
 
29
  GError       *error;
 
30
  gchar        *tmpfile;
 
31
  gint          load_count;
 
32
  gint          save_count;
 
33
} test_buffer_manager_basic_state;
 
34
 
 
35
static void
 
36
save_buffer_cb (IdeBufferManager                *buffer_manager,
 
37
                IdeBuffer                       *buffer,
 
38
                test_buffer_manager_basic_state *state)
 
39
{
 
40
  state->save_count++;
 
41
}
 
42
 
 
43
static void
 
44
buffer_loaded_cb (IdeBufferManager                *buffer_manager,
 
45
                  IdeBuffer                       *buffer,
 
46
                  test_buffer_manager_basic_state *state)
 
47
{
 
48
  state->load_count++;
 
49
}
 
50
 
 
51
static void
 
52
test_buffer_manager_basic_cb3 (GObject      *object,
 
53
                               GAsyncResult *result,
 
54
                               gpointer      user_data)
 
55
{
 
56
  IdeBufferManager *buffer_manager = (IdeBufferManager *)object;
 
57
  test_buffer_manager_basic_state *state = user_data;
 
58
  gboolean ret;
 
59
 
 
60
  ret = ide_buffer_manager_save_file_finish (buffer_manager, result, &state->error);
 
61
 
 
62
  g_assert_no_error (state->error);
 
63
  g_assert (ret);
 
64
 
 
65
  g_main_loop_quit (state->main_loop);
 
66
}
 
67
 
 
68
static void
 
69
test_buffer_manager_basic_cb2 (GObject      *object,
 
70
                               GAsyncResult *result,
 
71
                               gpointer      user_data)
 
72
{
 
73
  g_autoptr(IdeBuffer) buffer = NULL;
 
74
  IdeBufferManager *buffer_manager = (IdeBufferManager *)object;
 
75
  g_autoptr(IdeProgress) progress = NULL;
 
76
  IdeProject *project;
 
77
  GtkTextIter begin, end;
 
78
  IdeFile *file;
 
79
  test_buffer_manager_basic_state *state = user_data;
 
80
  g_autofree gchar *text = NULL;
 
81
  int fd;
 
82
 
 
83
  buffer = ide_buffer_manager_load_file_finish (buffer_manager, result, &state->error);
 
84
  gtk_text_buffer_get_bounds (GTK_TEXT_BUFFER (buffer), &begin, &end);
 
85
  text = gtk_text_buffer_get_text (GTK_TEXT_BUFFER (buffer), &begin, &end, TRUE);
 
86
  g_assert_cmpstr (text, ==, "LT_INIT");
 
87
 
 
88
  g_assert_no_error (state->error);
 
89
  g_assert (!buffer || IDE_IS_BUFFER (buffer));
 
90
 
 
91
  fd = g_file_open_tmp (NULL, &state->tmpfile, &state->error);
 
92
  g_assert_no_error (state->error);
 
93
  g_assert_cmpint (-1, !=, fd);
 
94
  close (fd); /* not secure, but okay for tests */
 
95
 
 
96
  project = ide_context_get_project (state->context);
 
97
  file = ide_project_get_file_for_path (project, state->tmpfile);
 
98
 
 
99
  ide_buffer_manager_save_file_async (buffer_manager,
 
100
                                      buffer,
 
101
                                      file,
 
102
                                      &progress,
 
103
                                      state->cancellable,
 
104
                                      test_buffer_manager_basic_cb3,
 
105
                                      state);
 
106
 
 
107
  g_assert (IDE_IS_PROGRESS (progress));
 
108
}
 
109
 
 
110
static void
 
111
test_buffer_manager_basic_cb1 (GObject      *object,
 
112
                               GAsyncResult *result,
 
113
                               gpointer      user_data)
 
114
{
 
115
  test_buffer_manager_basic_state *state = user_data;
 
116
  g_autoptr(IdeFile) file = NULL;
 
117
  g_autoptr(IdeProgress) progress = NULL;
 
118
  IdeBufferManager *buffer_manager;
 
119
  IdeProject *project;
 
120
  g_autofree gchar *path = NULL;
 
121
 
 
122
  state->context = ide_context_new_finish (result, &state->error);
 
123
 
 
124
  if (!state->context)
 
125
    goto failure;
 
126
 
 
127
  buffer_manager = ide_context_get_buffer_manager (state->context);
 
128
 
 
129
  g_signal_connect (buffer_manager, "save-buffer", G_CALLBACK (save_buffer_cb), state);
 
130
  g_signal_connect (buffer_manager, "buffer-loaded", G_CALLBACK (buffer_loaded_cb), state);
 
131
 
 
132
  project = ide_context_get_project (state->context);
 
133
 
 
134
  path = g_build_filename (g_get_current_dir (), TEST_DATA_DIR, "project1", "configure.ac", NULL);
 
135
  file = ide_project_get_file_for_path (project, path);
 
136
 
 
137
  ide_buffer_manager_load_file_async (buffer_manager,
 
138
                                      file,
 
139
                                      FALSE,
 
140
                                      &progress,
 
141
                                      state->cancellable,
 
142
                                      test_buffer_manager_basic_cb2,
 
143
                                      state);
 
144
 
 
145
  g_assert (IDE_IS_PROGRESS (progress));
 
146
 
 
147
  return;
 
148
 
 
149
failure:
 
150
  g_main_loop_quit (state->main_loop);
 
151
}
 
152
 
 
153
static void
 
154
test_buffer_manager_basic (void)
 
155
{
 
156
  test_buffer_manager_basic_state state = { 0 };
 
157
  IdeBufferManager *buffer_manager;
 
158
  GFile *project_file;
 
159
  g_autofree gchar *path = NULL;
 
160
 
 
161
  path = g_build_filename (g_get_current_dir (), TEST_DATA_DIR, "project1", "configure.ac", NULL);
 
162
  project_file = g_file_new_for_path (path);
 
163
 
 
164
  state.main_loop = g_main_loop_new (NULL, FALSE);
 
165
  state.cancellable = g_cancellable_new ();
 
166
 
 
167
  ide_context_new_async (project_file, state.cancellable,
 
168
                         test_buffer_manager_basic_cb1, &state);
 
169
 
 
170
  g_main_loop_run (state.main_loop);
 
171
 
 
172
  if (state.tmpfile)
 
173
    g_unlink (state.tmpfile);
 
174
 
 
175
  g_assert_no_error (state.error);
 
176
  g_assert (state.context);
 
177
 
 
178
  buffer_manager = ide_context_get_buffer_manager (state.context);
 
179
  g_assert (IDE_IS_BUFFER_MANAGER (buffer_manager));
 
180
 
 
181
  g_assert_cmpint (state.load_count, ==, 1);
 
182
  g_assert_cmpint (state.save_count, ==, 1);
 
183
 
 
184
  g_clear_object (&state.cancellable);
 
185
  g_clear_object (&state.context);
 
186
  g_clear_error (&state.error);
 
187
  g_main_loop_unref (state.main_loop);
 
188
  g_clear_object (&project_file);
 
189
}
 
190
 
 
191
gint
 
192
main (gint   argc,
 
193
      gchar *argv[])
 
194
{
 
195
  g_irepository_prepend_search_path (BUILDDIR"/../libide");
 
196
  gtk_init (&argc, &argv);
 
197
  g_test_init (&argc, &argv, NULL);
 
198
  g_irepository_require_private (g_irepository_get_default (),
 
199
                                 BUILDDIR,
 
200
                                 "Ide", "1.0", 0, NULL);
 
201
  g_test_add_func ("/Ide/BufferManager/basic", test_buffer_manager_basic);
 
202
  return g_test_run ();
 
203
}