tests: Make the output file locations more predictable
[refdbg:em-refdbg.git] / tests / tests.c
1 /*
2  * tests.c - common code for the tests
3  *
4  * refdbg - GObject refcount debugger
5  * Copyright (C) 2010 Stefan Kost <ensonic@users.sourceforge.net>
6  *
7  * This program is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License
9  * as published by the Free Software Foundation; either version 2
10  * of the License, or (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
20  * 02111-1307, USA or point your web browser to http://www.gnu.org.
21  */
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <glib-object.h>
26
27 #include "refdbg.h"
28
29 /* setup refdbg and finalize the test run */
30
31 void
32 test_init (const gchar *arg0)
33 {
34   const gchar *build_dir = g_getenv ("TESTS_BUILD_DIR");
35   gchar *basename = g_path_get_basename (arg0);
36   gchar *options = g_strdup_printf ("logname='%s%c%s.out'", build_dir, G_DIR_SEPARATOR, basename);
37
38   refdbg_cmd (options);
39   g_free (options);
40   g_free (basename);
41 }
42
43 static
44 canon_log_line (gchar *l)
45 {
46   gchar *s;
47
48   /* nuke hex addresses */
49   s=l;
50   while (s=strstr(s,"0x")) {
51      s+=2;
52      while (*s && isxdigit(*s)) {
53        *s++='0';
54      }
55   }
56   /* nuke timestamps addresses */
57   s=l;
58   while (s=strstr(s," 00:")) {
59     s+=4;
60     strncpy(s,"00.000000",9);
61     s+=9;
62   }
63 }
64
65 gint
66 test_fini (const gchar *arg0)
67 {
68   const gchar *source_dir = g_getenv ("TESTS_SOURCE_DIR");
69   const gchar *build_dir = g_getenv ("TESTS_BUILD_DIR");
70   gchar *basename;
71   gchar *testlogname,*reflogname;
72   FILE *tl,*rl;
73   gchar ts[251], rs[251], *tsp, *rsp;
74   gboolean fail = FALSE;
75   guint l = 0;
76
77   refdbg_save_log ();
78
79   basename = g_path_get_basename (arg0);
80   testlogname = g_strdup_printf ("%s%c%s.out", build_dir, G_DIR_SEPARATOR, basename);
81   reflogname = g_strdup_printf ("%s%c%s.ref", source_dir, G_DIR_SEPARATOR, basename);
82   g_free (basename);
83
84   /* compare the test log line by line to the reference log */
85   /* TODO: ignore hex addresses and timestamps */
86   tl = fopen (testlogname, "r");
87   rl = fopen (reflogname, "r");
88   if (tl && rl) {
89     while (!feof (tl) && !feof (rl)) {
90       tsp = fgets (ts, 250, tl);
91       rsp = fgets (rs, 250, rl);
92       if (tsp && rsp) {
93         canon_log_line(g_strchomp(ts));
94         canon_log_line(g_strchomp(rs));
95         if (strcmp (ts, rs)) {
96           fprintf(stderr, "logs differ at line %u\n'%s'\n'%s'\n", l, ts, rs);
97           fail = TRUE;
98           break;
99         }
100         l++;
101       }
102     }
103     if(!fail && (!feof (tl) || !feof (rl))) {
104       fprintf(stderr, "logs differ in length at line %u\n", l);
105       fail = TRUE;
106     }
107   }
108   if (tl) {
109     fclose (tl);
110   } else {
111     fprintf(stderr, "test log missing: %s\n", testlogname);
112     fail = TRUE;
113   }
114   if (rl) {
115     fclose (rl);
116   } else {
117     fprintf(stderr, "reference log missing: %s\n", reflogname);
118     fail = TRUE;
119   }
120
121   g_free (testlogname);
122   g_free (reflogname);
123
124   return fail;
125 }
126
127 /* reusable test types */
128
129 GType
130 test1_get_type (void)
131 {
132   static GType type = 0;
133   if (type == 0) {
134     static GTypeInfo info = {
135       sizeof (GObjectClass),
136       NULL,                     /* base_init */
137       NULL,                     /* base_finalize */
138       NULL,                     /* class_init */
139       NULL,                     /* class_finalize */
140       NULL,                     /* class_data */
141       sizeof (GObject),
142       0,
143       NULL                      /* instance_init */
144     };
145     type = g_type_register_static (G_TYPE_OBJECT, "refdbg-test1", &info, 0);
146   }
147   return type;
148 }
149
150
151 static void
152 test2_get_property (GObject *object,guint property_id,GValue *value,GParamSpec *pspec) {
153   switch (property_id) {
154     case 1:
155       break;
156     default:
157       G_OBJECT_WARN_INVALID_PROPERTY_ID (object,property_id,pspec);
158       break;
159   }
160 }
161
162 static void 
163 test2_set_property (GObject *object,guint property_id,const GValue *value,GParamSpec *pspec) {
164   switch (property_id) {
165     case 1:
166       break;
167     default:
168       G_OBJECT_WARN_INVALID_PROPERTY_ID (object,property_id,pspec);
169       break;
170   }
171 }
172
173 static void 
174 test2_class_init (GObjectClass *klass) {
175   klass->set_property = test2_set_property;
176   klass->get_property = test2_get_property;
177
178   g_object_class_install_property (klass, 1,
179     g_param_spec_boolean ("switch", "switch prop", "switch parameter",
180        FALSE, G_PARAM_READWRITE));
181 }
182
183 GType
184 test2_get_type (void)
185 {
186   static GType type = 0;
187   if (type == 0) {
188     static GTypeInfo info = {
189       sizeof (GObjectClass),
190       NULL,                     /* base_init */
191       NULL,                     /* base_finalize */
192       (GClassInitFunc)test2_class_init,                     /* class_init */
193       NULL,                     /* class_finalize */
194       NULL,                     /* class_data */
195       sizeof (GObject),
196       0,
197       NULL                      /* instance_init */
198     };
199     type = g_type_register_static (G_TYPE_OBJECT, "refdbg-test2", &info, 0);
200   }
201   return type;
202 }
203