2 * Copyright (c) 2015 Cisco and/or its affiliates.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at:
7 * http://www.apache.org/licenses/LICENSE-2.0
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
16 Copyright (c) 2005 Eliot Dresselhaus
18 Permission is hereby granted, free of charge, to any person obtaining
19 a copy of this software and associated documentation files (the
20 "Software"), to deal in the Software without restriction, including
21 without limitation the rights to use, copy, modify, merge, publish,
22 distribute, sublicense, and/or sell copies of the Software, and to
23 permit persons to whom the Software is furnished to do so, subject to
24 the following conditions:
26 The above copyright notice and this permission notice shall be
27 included in all copies or substantial portions of the Software.
29 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
30 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
31 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
32 NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
33 LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
34 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
35 WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
38 #include <vppinfra/format.h>
39 #include <vppinfra/random.h>
40 #include <vppinfra/serialize.h>
41 #include <vppinfra/os.h>
43 #define foreach_my_vector_type \
51 foreach_my_vector_type
56 serialize_my_vector_type_single (serialize_main_t * m, va_list * va)
58 my_vector_type_t *v = va_arg (*va, my_vector_type_t *);
59 u32 n = va_arg (*va, u32);
62 for (i = 0; i < n; i++)
64 #define _(t,f) serialize_integer (m, v[i].f, sizeof (v[i].f));
65 foreach_my_vector_type;
71 unserialize_my_vector_type_single (serialize_main_t * m, va_list * va)
73 my_vector_type_t *v = va_arg (*va, my_vector_type_t *);
74 u32 n = va_arg (*va, u32);
77 for (i = 0; i < n; i++)
79 #define _(t,f) { u32 tmp; unserialize_integer (m, &tmp, sizeof (v[i].f)); v[i].f = tmp; }
80 foreach_my_vector_type;
86 serialize_my_vector_type_multiple (serialize_main_t * m, va_list * va)
88 my_vector_type_t *v = va_arg (*va, my_vector_type_t *);
89 u32 n = va_arg (*va, u32);
95 STRUCT_SIZE_OF (my_vector_type_t, f), \
96 STRUCT_STRIDE_OF (my_vector_type_t, f), \
99 foreach_my_vector_type;
105 unserialize_my_vector_type_multiple (serialize_main_t * m, va_list * va)
107 my_vector_type_t *v = va_arg (*va, my_vector_type_t *);
108 u32 n = va_arg (*va, u32);
111 unserialize_multiple \
114 STRUCT_SIZE_OF (my_vector_type_t, f), \
115 STRUCT_STRIDE_OF (my_vector_type_t, f), \
118 foreach_my_vector_type;
131 my_vector_type_t **test_vectors;
135 serialize_main_t serialize_main;
136 serialize_main_t unserialize_main;
137 } test_serialize_main_t;
140 test_serialize_main (unformat_input_t * input)
142 clib_error_t *error = 0;
143 test_serialize_main_t _tm, *tm = &_tm;
144 serialize_main_t *sm = &tm->serialize_main;
145 serialize_main_t *um = &tm->unserialize_main;
148 memset (tm, 0, sizeof (tm[0]));
155 while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
157 if (unformat (input, "iter %d", &tm->n_iter))
159 else if (unformat (input, "seed %d", &tm->seed))
161 else if (unformat (input, "file %s", &tm->dump_file))
163 else if (unformat (input, "max-len %d", &tm->max_len))
165 else if (unformat (input, "multiple %=", &tm->multiple, 1))
167 else if (unformat (input, "single %=", &tm->multiple, 0))
169 else if (unformat (input, "verbose %=", &tm->verbose, 1))
173 error = clib_error_create ("unknown input `%U'\n",
174 format_unformat_error, input);
180 tm->seed = random_default_seed ();
182 clib_warning ("iter %d seed %d max-len %d", tm->n_iter, tm->seed,
187 serialize_open_unix_file (sm, tm->dump_file);
190 serialize_open_vector (sm, 0);
192 vec_resize (tm->test_vectors, tm->n_iter);
193 for (i = 0; i < tm->n_iter; i++)
195 uword l = 1 + (random_u32 (&tm->seed) % tm->max_len);
196 my_vector_type_t *mv;
198 vec_resize (tm->test_vectors[i], l);
199 vec_foreach (mv, tm->test_vectors[i])
201 #define _(t,f) mv->f = random_u32 (&tm->seed) & pow2_mask (31);
202 foreach_my_vector_type;
206 vec_serialize (sm, tm->test_vectors[i],
207 tm->multiple ? serialize_my_vector_type_multiple :
208 serialize_my_vector_type_single);
212 clib_warning ("overflow vector max bytes %d",
213 vec_max_len (sm->stream.overflow_buffer));
215 serialize_close (sm);
220 if ((error = unserialize_open_unix_file (um, tm->dump_file)))
226 u8 *v = serialize_close_vector (sm);
227 unserialize_open_data (um, v, vec_len (v));
230 for (i = 0; i < tm->n_iter; i++)
232 my_vector_type_t *mv0;
233 my_vector_type_t *mv1;
235 vec_unserialize (um, &mv0,
236 tm->multiple ? unserialize_my_vector_type_multiple :
237 unserialize_my_vector_type_single);
238 mv1 = tm->test_vectors[i];
240 if (vec_len (mv0) != vec_len (mv1))
242 if (memcmp (mv0, mv1, vec_len (mv0) * sizeof (mv0[0])))
250 clib_error_report (error);
256 main (int argc, char *argv[])
261 unformat_init_command_line (&i, argv);
262 r = test_serialize_main (&i);
269 * fd.io coding-style-patch-verification: ON
272 * eval: (c-set-style "gnu")