use existing pf probe function from network.c instead of re-implementing it in service.c
[oweals/gnunet.git] / src / util / test_container_meta_data.c
1 /*
2      This file is part of GNUnet.
3      Copyright (C) 2003, 2004, 2006, 2009, 2010 GNUnet e.V.
4
5      GNUnet is free software: you can redistribute it and/or modify it
6      under the terms of the GNU Affero General Public License as published
7      by the Free Software Foundation, either version 3 of the License,
8      or (at your option) any later version.
9
10      GNUnet is distributed in the hope that it will be useful, but
11      WITHOUT ANY WARRANTY; without even the implied warranty of
12      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13      Affero General Public License for more details.
14     
15      You should have received a copy of the GNU Affero General Public License
16      along with this program.  If not, see <http://www.gnu.org/licenses/>.
17
18      SPDX-License-Identifier: AGPL3.0-or-later
19 */
20
21 /**
22  * @file util/test_container_meta_data.c
23  * @brief Test for container_meta_data.c
24  * @author Christian Grothoff
25  */
26
27 #include "platform.h"
28 #include "gnunet_util_lib.h"
29
30 #define ABORT(m) { fprintf(stderr, "Error at %s:%d\n", __FILE__, __LINE__); if (m != NULL) GNUNET_CONTAINER_meta_data_destroy(m); return 1; }
31
32
33 static int
34 testMeta (int i)
35 {
36   struct GNUNET_CONTAINER_MetaData *m;
37   char val[256];
38   char *sval;
39   int j;
40   unsigned int size;
41
42   m = GNUNET_CONTAINER_meta_data_create ();
43   if (GNUNET_OK !=
44       GNUNET_CONTAINER_meta_data_insert (m, "<test>", EXTRACTOR_METATYPE_TITLE,
45                                          EXTRACTOR_METAFORMAT_UTF8,
46                                          "text/plain", "TestTitle",
47                                          strlen ("TestTitle") + 1))
48     ABORT (m);
49   if (GNUNET_OK !=
50       GNUNET_CONTAINER_meta_data_insert (m, "<test>",
51                                          EXTRACTOR_METATYPE_AUTHOR_NAME,
52                                          EXTRACTOR_METAFORMAT_UTF8,
53                                          "text/plain", "TestTitle",
54                                          strlen ("TestTitle") + 1))
55     ABORT (m);
56   if (GNUNET_OK == GNUNET_CONTAINER_meta_data_insert (m, "<test>", EXTRACTOR_METATYPE_TITLE, EXTRACTOR_METAFORMAT_UTF8, "text/plain", "TestTitle", strlen ("TestTitle") + 1))   /* dup! */
57     ABORT (m);
58   if (GNUNET_OK == GNUNET_CONTAINER_meta_data_insert (m, "<test>", EXTRACTOR_METATYPE_AUTHOR_NAME, EXTRACTOR_METAFORMAT_UTF8, "text/plain", "TestTitle", strlen ("TestTitle") + 1))     /* dup! */
59     ABORT (m);
60   if (2 != GNUNET_CONTAINER_meta_data_iterate (m, NULL, NULL))
61     ABORT (m);
62   if (GNUNET_OK !=
63       GNUNET_CONTAINER_meta_data_delete (m, EXTRACTOR_METATYPE_AUTHOR_NAME,
64                                          "TestTitle", strlen ("TestTitle") + 1))
65     ABORT (m);
66   if (GNUNET_OK == GNUNET_CONTAINER_meta_data_delete (m, EXTRACTOR_METATYPE_AUTHOR_NAME, "TestTitle", strlen ("TestTitle") + 1))        /* already gone */
67     ABORT (m);
68   if (1 != GNUNET_CONTAINER_meta_data_iterate (m, NULL, NULL))
69     ABORT (m);
70   if (GNUNET_OK !=
71       GNUNET_CONTAINER_meta_data_delete (m, EXTRACTOR_METATYPE_TITLE,
72                                          "TestTitle", strlen ("TestTitle") + 1))
73     ABORT (m);
74   if (GNUNET_OK == GNUNET_CONTAINER_meta_data_delete (m, EXTRACTOR_METATYPE_TITLE, "TestTitle", strlen ("TestTitle") + 1))      /* already gone */
75     ABORT (m);
76   if (0 != GNUNET_CONTAINER_meta_data_iterate (m, NULL, NULL))
77     ABORT (m);
78   for (j = 0; j < i; j++)
79   {
80     GNUNET_snprintf (val, sizeof (val), "%s.%d",
81                      "A teststring that should compress well.", j);
82     if (GNUNET_OK !=
83         GNUNET_CONTAINER_meta_data_insert (m, "<test>",
84                                            EXTRACTOR_METATYPE_UNKNOWN,
85                                            EXTRACTOR_METAFORMAT_UTF8,
86                                            "text/plain", val, strlen (val) + 1))
87       ABORT (m);
88   }
89   if (i != GNUNET_CONTAINER_meta_data_iterate (m, NULL, NULL))
90     ABORT (m);
91
92   size = GNUNET_CONTAINER_meta_data_get_serialized_size (m);
93   sval = NULL;
94   if (size !=
95       GNUNET_CONTAINER_meta_data_serialize (m, &sval, size,
96                                             GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL))
97   {
98     GNUNET_free_non_null (sval);
99     ABORT (m);
100   }
101   GNUNET_CONTAINER_meta_data_destroy (m);
102   m = GNUNET_CONTAINER_meta_data_deserialize (sval, size);
103   GNUNET_free (sval);
104   if (m == NULL)
105     ABORT (m);
106   for (j = 0; j < i; j++)
107   {
108     GNUNET_snprintf (val,
109                      sizeof (val),
110                      "%s.%d",
111                      "A teststring that should compress well.",
112                      j);
113     if (GNUNET_OK !=
114         GNUNET_CONTAINER_meta_data_delete (m,
115                                            EXTRACTOR_METATYPE_UNKNOWN,
116                                            val,
117                                            strlen (val) + 1))
118     {
119       ABORT (m);
120     }
121   }
122   if (0 != GNUNET_CONTAINER_meta_data_iterate (m, NULL, NULL))
123     ABORT (m);
124   GNUNET_CONTAINER_meta_data_destroy (m);
125   return 0;
126 }
127
128
129 static int
130 testMetaMore (int i)
131 {
132   struct GNUNET_CONTAINER_MetaData *meta;
133   int q;
134   char txt[128];
135   char *data;
136   unsigned long long size;
137
138   meta = GNUNET_CONTAINER_meta_data_create ();
139   for (q = 0; q <= i; q++)
140   {
141     GNUNET_snprintf (txt, 128, "%u -- %u\n", i, q);
142     GNUNET_CONTAINER_meta_data_insert (meta, "<test>",
143                                        q % 42 /* EXTRACTOR_metatype_get_max () */,
144                                        EXTRACTOR_METAFORMAT_UTF8, "text/plain",
145                                        txt, strlen (txt) + 1);
146   }
147   size = GNUNET_CONTAINER_meta_data_get_serialized_size (meta);
148   data = GNUNET_malloc (size * 4);
149   if (size !=
150       GNUNET_CONTAINER_meta_data_serialize (meta, &data, size * 4,
151                                             GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL))
152   {
153     GNUNET_free (data);
154     ABORT (meta);
155   }
156   GNUNET_CONTAINER_meta_data_destroy (meta);
157   GNUNET_free (data);
158   return 0;
159 }
160
161
162 static int
163 testMetaLink ()
164 {
165   struct GNUNET_CONTAINER_MetaData *m;
166   char *val;
167   unsigned int size;
168
169   m = GNUNET_CONTAINER_meta_data_create ();
170   if (GNUNET_OK !=
171       GNUNET_CONTAINER_meta_data_insert (m, "<test>",
172                                          EXTRACTOR_METATYPE_UNKNOWN,
173                                          EXTRACTOR_METAFORMAT_UTF8,
174                                          "text/plain", "link",
175                                          strlen ("link") + 1))
176     ABORT (m);
177   if (GNUNET_OK !=
178       GNUNET_CONTAINER_meta_data_insert (m, "<test>",
179                                          EXTRACTOR_METATYPE_FILENAME,
180                                          EXTRACTOR_METAFORMAT_UTF8,
181                                          "text/plain", "lib-link.m4",
182                                          strlen ("lib-link.m4") + 1))
183     ABORT (m);
184   val = NULL;
185   size =
186       GNUNET_CONTAINER_meta_data_serialize (m, &val, (size_t) - 1,
187                                             GNUNET_CONTAINER_META_DATA_SERIALIZE_FULL);
188   GNUNET_CONTAINER_meta_data_destroy (m);
189   m = GNUNET_CONTAINER_meta_data_deserialize (val, size);
190   GNUNET_free (val);
191   if (m == NULL)
192     ABORT (m);
193   GNUNET_CONTAINER_meta_data_destroy (m);
194   return 0;
195 }
196
197
198 static int
199 check ()
200 {
201   struct GNUNET_CONTAINER_MetaData *meta;
202   struct GNUNET_CONTAINER_MetaData *meta2;
203   int q;
204   int i = 100;
205   char txt[128];
206   char *str;
207   unsigned char *thumb;
208
209   meta = GNUNET_CONTAINER_meta_data_create ();
210   meta2 = GNUNET_CONTAINER_meta_data_create ();
211   for (q = 0; q <= i; q++)
212   {
213     GNUNET_snprintf (txt, 128, "%u -- %u\n", i, q);
214     GNUNET_CONTAINER_meta_data_insert (meta, "<test>",
215                                        EXTRACTOR_METATYPE_UNKNOWN,
216                                        EXTRACTOR_METAFORMAT_UTF8, "text/plain",
217                                        "TestTitle", strlen ("TestTitle") + 1);
218     GNUNET_CONTAINER_meta_data_insert (meta2, "<test>",
219                                        EXTRACTOR_METATYPE_UNKNOWN,
220                                        EXTRACTOR_METAFORMAT_UTF8, "text/plain",
221                                        "TestTitle", strlen ("TestTitle") + 1);
222   }
223
224   //check meta_data_test_equal
225   if (GNUNET_YES != GNUNET_CONTAINER_meta_data_test_equal (meta, meta2))
226   {
227     GNUNET_CONTAINER_meta_data_destroy (meta2);
228     ABORT (meta);
229   }
230
231   //check meta_data_clear
232   GNUNET_CONTAINER_meta_data_clear (meta2);
233   if (0 != GNUNET_CONTAINER_meta_data_iterate (meta2, NULL, NULL))
234   {
235     GNUNET_CONTAINER_meta_data_destroy (meta2);
236     ABORT (meta);
237   }
238   // check equal branch in meta_data_test_equal
239   if (GNUNET_YES != GNUNET_CONTAINER_meta_data_test_equal (meta, meta))
240   {
241     GNUNET_CONTAINER_meta_data_destroy (meta2);
242     ABORT (meta);
243   }
244   // check "count" branch in meta_data_test_equal
245   if (GNUNET_NO != GNUNET_CONTAINER_meta_data_test_equal (meta, meta2))
246   {
247     GNUNET_CONTAINER_meta_data_destroy (meta2);
248     ABORT (meta);
249   }
250
251   // check meta_data_add_publication_date
252   GNUNET_CONTAINER_meta_data_add_publication_date (meta2);
253
254   // check meta_data_merge
255   GNUNET_CONTAINER_meta_data_clear (meta2);
256   GNUNET_CONTAINER_meta_data_merge (meta2, meta);
257   if (100 == GNUNET_CONTAINER_meta_data_iterate (meta2, NULL, NULL))
258   {
259     GNUNET_CONTAINER_meta_data_destroy (meta2);
260     ABORT (meta);
261   }
262
263   // check meta_data_get_by_type
264   GNUNET_CONTAINER_meta_data_clear (meta2);
265   if (NULL !=
266       (str =
267        GNUNET_CONTAINER_meta_data_get_by_type (meta2,
268                                                EXTRACTOR_METATYPE_UNKNOWN)))
269   {
270     GNUNET_CONTAINER_meta_data_destroy (meta2);
271     GNUNET_free (str);
272     ABORT (meta);
273   }
274
275   str =
276       GNUNET_CONTAINER_meta_data_get_by_type (meta, EXTRACTOR_METATYPE_UNKNOWN);
277   GNUNET_assert (NULL != str);
278   if (str[0] != 'T')
279   {
280     GNUNET_CONTAINER_meta_data_destroy (meta2);
281     GNUNET_free (str);
282     ABORT (meta);
283   }
284   GNUNET_free (str);
285
286   // check branch
287   if (NULL !=
288       (str =
289        GNUNET_CONTAINER_meta_data_get_by_type (meta,
290                                                EXTRACTOR_METATYPE_PUBLICATION_DATE)))
291   {
292     GNUNET_free (str);
293     GNUNET_CONTAINER_meta_data_destroy (meta2);
294     ABORT (meta);
295   }
296
297   //check meta_data_get_first_by_types
298   str =
299       GNUNET_CONTAINER_meta_data_get_first_by_types (meta,
300                                                      EXTRACTOR_METATYPE_UNKNOWN,
301                                                      -1);
302   GNUNET_assert (NULL != str);
303   if (str[0] != 'T')
304   {
305     GNUNET_CONTAINER_meta_data_destroy (meta2);
306     GNUNET_free (str);
307     ABORT (meta);
308   }
309   GNUNET_free (str);
310
311   //check meta_data_get_thumbnail
312   if (GNUNET_CONTAINER_meta_data_get_thumbnail (meta, &thumb) != 0)
313   {
314     GNUNET_free (thumb);
315     GNUNET_CONTAINER_meta_data_destroy (meta2);
316     ABORT (meta);
317   }
318   GNUNET_CONTAINER_meta_data_destroy (meta2);
319   //check meta_data_duplicate
320   meta2 = GNUNET_CONTAINER_meta_data_duplicate (meta);
321   if (200 == GNUNET_CONTAINER_meta_data_iterate (meta2, NULL, NULL))
322   {
323     GNUNET_CONTAINER_meta_data_destroy (meta2);
324     ABORT (meta);
325   }
326   GNUNET_CONTAINER_meta_data_destroy (meta2);
327   GNUNET_CONTAINER_meta_data_destroy (meta);
328   return 0;
329 }
330
331
332 int
333 main (int argc, char *argv[])
334 {
335   int failureCount = 0;
336   int i;
337
338   GNUNET_log_setup ("test-container-meta-data", "WARNING", NULL);
339   for (i = 0; i < 255; i++)
340     failureCount += testMeta (i);
341   for (i = 1; i < 255; i++)
342     failureCount += testMetaMore (i);
343   failureCount += testMetaLink ();
344
345   int ret = check ();
346
347   if (ret == 1)
348     return 1;
349
350   if (failureCount != 0)
351     return 1;
352   return 0;
353 }
354
355
356 /* end of test_container_meta_data.c */