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