doc/
[gpgme.git] / tests / t-data.c
1 /* t-data - Regression tests for the GpgmeData abstraction.
2  *      Copyright (C) 2001 g10 Code GmbH
3  *
4  * This file is part of GPGME.
5  *
6  * GPGME is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * GPGME is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19  */
20
21 #include <stddef.h>
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include <errno.h>
26
27 #include <gpgme.h>
28
29 #define fail_if_err(a) do { if(a) {                                       \
30                                fprintf (stderr, "%s:%d: (%i) GpgmeError " \
31                                 "%s\n", __FILE__, __LINE__, round,        \
32                                 gpgme_strerror(a));                       \
33                                 exit (1); }                               \
34                              } while(0)
35
36 static char *
37 make_filename (const char *fname)
38 {
39   const char *srcdir = getenv ("srcdir");
40   char *buf;
41
42   if (!srcdir)
43     srcdir = ".";
44   buf = malloc (strlen(srcdir) + strlen(fname) + 2 );
45   if (!buf)
46     {
47       fprintf (stderr, "%s:%d: could not allocate string: %s\n",
48                __FILE__, __LINE__, strerror (errno));
49       exit (1);
50     }
51   strcpy (buf, srcdir);
52   strcat (buf, "/");
53   strcat (buf, fname);
54   return buf;
55 }
56
57 typedef enum
58   {
59     TEST_INITIALIZER,
60     TEST_INVALID_ARGUMENT,
61     TEST_INOUT_NONE,
62     TEST_INOUT_MEM_NO_COPY,
63     TEST_INOUT_MEM_COPY,
64     TEST_INOUT_MEM_FROM_FILE_COPY,
65     TEST_INOUT_MEM_FROM_INEXISTANT_FILE,
66     TEST_INOUT_MEM_FROM_FILE_NO_COPY,
67     TEST_INOUT_MEM_FROM_FILE_PART_BY_NAME,
68     TEST_INOUT_MEM_FROM_INEXISTANT_FILE_PART,
69     TEST_INOUT_MEM_FROM_FILE_PART_BY_FP,
70     TEST_OUT_CB,
71     TEST_END
72   } round_t;
73
74 const char *text = "Just GNU it!\n";
75 const char *text2 = "Just GNU it!\nJust GNU it!\n";
76
77 int
78 read_cb (void *cb_value, char *buffer, size_t count, size_t *nread)
79 {
80   static int off = 0;
81   int amount = strlen (text) - off;
82   /*  round_t round = *((round_t *) cb_value);  */
83
84   if (!buffer && !count && !nread)
85     {
86       /* Rewind requested.  */
87       off = 0;
88       return 0;
89     }
90   if (! buffer || !nread)
91     return -1;
92   if (amount <= 0)
93     {
94       /* End of file.  */
95       *nread = 0;
96       return -1;
97     }
98   if (amount > count)
99     amount = count;
100   memcpy (buffer, text, amount);
101   off += amount;
102   *nread = amount;
103   return 0;
104 }
105
106 void
107 read_once_test (round_t round, GpgmeData data)
108 {
109   char buffer[1024];
110   size_t read;
111
112   read = gpgme_data_read (data, buffer, sizeof (buffer));
113
114   if (read != strlen (text) || strncmp (buffer, text, strlen (text)))
115     {
116       fprintf (stderr, "%s:%d: (%i) gpgme_data_read returned wrong data\n",
117                __FILE__, __LINE__, round);
118       exit (1);
119     }
120
121   read = gpgme_data_read (data, buffer, sizeof (buffer));
122   if (read)
123     {
124       fprintf (stderr, "%s:%d: (%i) gpgme_data_read did not signal EOF\n",
125                __FILE__, __LINE__, round);
126       exit (1);
127     }
128 }
129
130 void
131 read_test (round_t round, GpgmeData data)
132 {
133   GpgmeError err;
134   char buffer[1024];
135   size_t read;
136
137   if (round == TEST_INOUT_NONE)
138     {
139       read = gpgme_data_read (data, buffer, sizeof (buffer));
140       if (read > 0)
141         {
142           fprintf (stderr, "%s:%d: (%i) gpgme_data_read succeded unexpectedly\n",
143                    __FILE__, __LINE__, round);
144           exit (1);
145         }
146       return;
147     }
148
149   read_once_test (round, data);
150   err = gpgme_data_rewind (data);
151   fail_if_err (err);
152   read_once_test (round, data);
153 }
154
155 void
156 write_test (round_t round, GpgmeData data)
157 {
158   GpgmeError err;
159   char buffer[1024];
160   size_t amt;
161
162   amt = gpgme_data_write (data, text, strlen (text));
163   if (amt != strlen (text))
164     fail_if_err (GPGME_File_Error);
165
166   err = gpgme_data_rewind (data);
167   fail_if_err (err);
168
169   if (round == TEST_INOUT_NONE)
170     read_once_test (round, data);
171   else
172     {
173       amt = gpgme_data_read (data, buffer, sizeof (buffer));
174
175       if (amt != strlen (text2) || strncmp (buffer, text2, strlen (text2)))
176         {
177           fprintf (stderr, "%s:%d: (%i) gpgme_data_read returned wrong data\n",
178                    __FILE__, __LINE__, round);
179           exit (1);
180         }
181
182       amt = gpgme_data_read (data, buffer, sizeof (buffer));
183       if (amt)
184         {
185           fprintf (stderr, "%s:%d: (%i) gpgme_data_read did not signal EOF\n",
186                    __FILE__, __LINE__, round);
187           exit (1);
188         }
189     }
190 }
191
192 int 
193 main (int argc, char **argv)
194 {
195   round_t round = TEST_INITIALIZER;
196   const char *text_filename = make_filename ("t-data-1.txt");
197   const char *longer_text_filename = make_filename ("t-data-2.txt");
198   const char *missing_filename = "this-file-surely-does-not-exist";
199   GpgmeError err = GPGME_No_Error;
200   GpgmeData data;
201
202   while (++round)
203     {
204       switch (round)
205         {
206         case TEST_INVALID_ARGUMENT:
207           err = gpgme_data_new (NULL);
208           if (!err)
209             {
210               fprintf (stderr, "%s:%d: gpgme_data_new on NULL pointer succeeded "
211                        "unexpectedly\n", __FILE__, __LINE__);
212               exit (1);
213             }
214           continue;
215         case TEST_INOUT_NONE:
216           err = gpgme_data_new (&data);
217           break;
218         case TEST_INOUT_MEM_NO_COPY:
219           err = gpgme_data_new_from_mem (&data, text, strlen (text), 0);
220           break;
221         case TEST_INOUT_MEM_COPY:
222           err = gpgme_data_new_from_mem (&data, text, strlen (text), 1);
223           break;
224         case TEST_INOUT_MEM_FROM_FILE_COPY:
225           err = gpgme_data_new_from_file (&data, text_filename, 1);
226           break;
227         case TEST_INOUT_MEM_FROM_INEXISTANT_FILE:
228           err = gpgme_data_new_from_file (&data, missing_filename, 1);
229           if (!err)
230             {
231               fprintf (stderr, "%s:%d: gpgme_data_new_from_file on inexistant "
232                        "file succeeded unexpectedly\n", __FILE__, __LINE__);
233               exit (1);
234             }
235           continue;
236         case TEST_INOUT_MEM_FROM_FILE_NO_COPY:
237           err = gpgme_data_new_from_file (&data, text_filename, 0);
238           /* This is not implemented yet.  */
239           if (err == GPGME_Not_Implemented || err == GPGME_Invalid_Value)
240             continue;
241           break;
242         case TEST_INOUT_MEM_FROM_FILE_PART_BY_NAME:
243           err = gpgme_data_new_from_filepart (&data, longer_text_filename, 0,
244                                               strlen (text), strlen (text));
245           break;
246         case TEST_INOUT_MEM_FROM_INEXISTANT_FILE_PART:
247           err = gpgme_data_new_from_filepart (&data, missing_filename, 0,
248                                               strlen (text), strlen (text));
249           if (!err)
250             {
251               fprintf (stderr, "%s:%d: gpgme_data_new_from_file on inexistant "
252                        "file succeeded unexpectedly\n", __FILE__, __LINE__);
253               exit (1);
254             }
255           continue;
256         case TEST_INOUT_MEM_FROM_FILE_PART_BY_FP:
257           {
258             FILE *fp = fopen (longer_text_filename, "rb");
259             if (! fp)
260               {
261                 fprintf (stderr, "%s:%d: fopen: %s\n", __FILE__, __LINE__,
262                          strerror (errno));
263                 exit (1);
264               }
265             err = gpgme_data_new_from_filepart (&data, 0, fp,
266                                                 strlen (text), strlen (text));
267           }
268           break;
269         case TEST_OUT_CB:
270           err = gpgme_data_new_with_read_cb (&data, read_cb, &round);
271           break;
272         case TEST_END:
273           return 0;
274         case TEST_INITIALIZER:
275           /* Shouldn't happen.  */
276           fprintf (stderr, "%s:%d: impossible condition\n", __FILE__, __LINE__);
277           exit (1);
278         }
279       fail_if_err (err);
280
281       read_test (round, data);
282       if (round != TEST_OUT_CB)
283         write_test (round, data);
284       gpgme_data_release (data);
285     }
286   return 0;
287 }