unit/test-gobex-header.c

   1 /*
   2  *
   3  *  OBEX library with GLib integration
   4  *
   5  *  Copyright (C) 2011  Intel Corporation. All rights reserved.
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License as published by
   9  *  the Free Software Foundation; either version 2 of the License, or
  10  *  (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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  20  *
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 #include "config.h"
  25 #endif
  26
  27 #include <stdint.h>
  28 #include <string.h>
  29
  30 #include "gobex/gobex.h"
  31 #include "gobex/gobex-header.h"
  32
  33 #include "util.h"
  34
  35 static uint8_t hdr_connid[] = { G_OBEX_HDR_CONNECTION, 1, 2, 3, 4 };
  36 static uint8_t hdr_name_empty[] = { G_OBEX_HDR_NAME, 0x00, 0x03 };
  37 static uint8_t hdr_name_ascii[] = { G_OBEX_HDR_NAME, 0x00, 0x0b,
  38                                 0x00, 'f', 0x00, 'o', 0x00, 'o',
  39                                 0x00, 0x00 };
  40 static uint8_t hdr_name_umlaut[] = { G_OBEX_HDR_NAME, 0x00, 0x0b,
  41                                 0x00, 0xe5, 0x00, 0xe4, 0x00, 0xf6,
  42                                 0x00, 0x00 };
  43 static uint8_t hdr_body[] = { G_OBEX_HDR_BODY, 0x00, 0x07, 1, 2, 3, 4 };
  44 static uint8_t hdr_actionid[] = { G_OBEX_HDR_ACTION, 0xab };
  45
  46 static uint8_t hdr_uint32_nval[] = { G_OBEX_HDR_CONNECTION, 1, 2 };
  47 static uint8_t hdr_unicode_nval_short[] = { G_OBEX_HDR_NAME, 0x12, 0x34,
  48                                                 0x00, 'a', 0x00, 'b',
  49                                                 0x00, 0x00 };
  50 static uint8_t hdr_unicode_nval_data[] = { G_OBEX_HDR_NAME, 0x00, 0x01,
  51                                                 0x00, 'a', 0x00, 'b' };
  52 static uint8_t hdr_bytes_nval_short[] = { G_OBEX_HDR_BODY, 0xab, 0xcd,
  53                                                 0x01, 0x02, 0x03 };
  54 static uint8_t hdr_bytes_nval_data[] = { G_OBEX_HDR_BODY, 0xab };
  55 static uint8_t hdr_bytes_nval_len[] = { G_OBEX_HDR_BODY, 0x00, 0x00 };
  56 static uint8_t hdr_apparam[] = { G_OBEX_HDR_APPARAM, 0x00, 0x09, 0x00, 0x04,
  57                                                 0x01, 0x02, 0x03, 0x04 };
  58
  59 static void test_header_name_empty(void)
  60 {
  61         GObexHeader *header;
  62         uint8_t buf[1024];
  63         size_t len;
  64
  65         header = g_obex_header_new_unicode(G_OBEX_HDR_NAME, "");
  66
  67         g_assert(header != NULL);
  68
  69         len = g_obex_header_encode(header, buf, sizeof(buf));
  70
  71         assert_memequal(hdr_name_empty, sizeof(hdr_name_empty), buf, len);
  72
  73         g_obex_header_free(header);
  74 }
  75
  76 static void test_header_name_ascii(void)
  77 {
  78         GObexHeader *header;
  79         uint8_t buf[1024];
  80         size_t len;
  81
  82         header = g_obex_header_new_unicode(G_OBEX_HDR_NAME, "foo");
  83
  84         g_assert(header != NULL);
  85
  86         len = g_obex_header_encode(header, buf, sizeof(buf));
  87
  88         assert_memequal(hdr_name_ascii, sizeof(hdr_name_ascii), buf, len);
  89
  90         g_obex_header_free(header);
  91 }
  92
  93 static void test_header_name_umlaut(void)
  94 {
  95         GObexHeader *header;
  96         uint8_t buf[1024];
  97         size_t len;
  98
  99         header = g_obex_header_new_unicode(G_OBEX_HDR_NAME, "åäö");
 100
 101         g_assert(header != NULL);
 102
 103         len = g_obex_header_encode(header, buf, sizeof(buf));
 104
 105         assert_memequal(hdr_name_umlaut, sizeof(hdr_name_umlaut), buf, len);
 106
 107         g_obex_header_free(header);
 108 }
 109
 110 static void test_header_bytes(void)
 111 {
 112         GObexHeader *header;
 113         uint8_t buf[1024], data[] = { 1, 2, 3, 4 };
 114         size_t len;
 115
 116         header = g_obex_header_new_bytes(G_OBEX_HDR_BODY, data, sizeof(data));
 117         g_assert(header != NULL);
 118
 119         len = g_obex_header_encode(header, buf, sizeof(buf));
 120
 121         assert_memequal(hdr_body, sizeof(hdr_body), buf, len);
 122
 123         g_obex_header_free(header);
 124 }
 125
 126 static void test_header_apparam(void)
 127 {
 128         GObexHeader *header;
 129         GObexApparam *apparam;
 130         uint8_t buf[1024];
 131         size_t len;
 132
 133         apparam = g_obex_apparam_set_uint32(NULL, 0, 0x01020304);
 134         g_assert(apparam != NULL);
 135
 136         header = g_obex_header_new_apparam(apparam);
 137         g_assert(header != NULL);
 138
 139         len = g_obex_header_encode(header, buf, sizeof(buf));
 140
 141         assert_memequal(hdr_apparam, sizeof(hdr_apparam), buf, len);
 142
 143         g_obex_apparam_free(apparam);
 144         g_obex_header_free(header);
 145 }
 146
 147 static void test_header_uint8(void)
 148 {
 149         GObexHeader *header;
 150         uint8_t buf[1024];
 151         size_t len;
 152
 153         header = g_obex_header_new_uint8(G_OBEX_HDR_ACTION, 0xab);
 154
 155         g_assert(header != NULL);
 156
 157         len = g_obex_header_encode(header, buf, sizeof(buf));
 158
 159         assert_memequal(hdr_actionid, sizeof(hdr_actionid), buf, len);
 160
 161         g_obex_header_free(header);
 162 }
 163
 164 static void test_header_uint32(void)
 165 {
 166         GObexHeader *header;
 167         uint8_t buf[1024];
 168         size_t len;
 169
 170         header = g_obex_header_new_uint32(G_OBEX_HDR_CONNECTION, 0x01020304);
 171         len = g_obex_header_encode(header, buf, sizeof(buf));
 172
 173         assert_memequal(hdr_connid, sizeof(hdr_connid), buf, len);
 174
 175         g_obex_header_free(header);
 176 }
 177
 178 static GObexHeader *parse_and_encode(uint8_t *buf, size_t buf_len)
 179 {
 180         GObexHeader *header;
 181         uint8_t encoded[1024];
 182         size_t len;
 183         GError *err = NULL;
 184
 185         header = g_obex_header_decode(buf, buf_len, G_OBEX_DATA_REF, &len,
 186                                                                         &err);
 187         g_assert_no_error(err);
 188         g_assert_cmpuint(len, ==, buf_len);
 189
 190         len = g_obex_header_encode(header, encoded, sizeof(encoded));
 191
 192         assert_memequal(buf, buf_len, encoded, len);
 193
 194         return header;
 195 }
 196
 197 static void test_header_encode_connid(void)
 198 {
 199         GObexHeader *header;
 200         gboolean ret;
 201         guint32 val;
 202
 203         header = parse_and_encode(hdr_connid, sizeof(hdr_connid));
 204
 205         ret = g_obex_header_get_uint32(header, &val);
 206
 207         g_assert(ret == TRUE);
 208         g_assert(val == 0x01020304);
 209
 210         g_obex_header_free(header);
 211 }
 212
 213 static void test_header_encode_name_ascii(void)
 214 {
 215         GObexHeader *header;
 216         const char *str;
 217         gboolean ret;
 218
 219         header = parse_and_encode(hdr_name_ascii, sizeof(hdr_name_ascii));
 220
 221         ret = g_obex_header_get_unicode(header, &str);
 222
 223         g_assert(ret == TRUE);
 224         g_assert_cmpstr(str, ==, "foo");
 225
 226         g_obex_header_free(header);
 227 }
 228
 229 static void test_header_encode_name_umlaut(void)
 230 {
 231         GObexHeader *header;
 232         const char *str;
 233         gboolean ret;
 234
 235         header = parse_and_encode(hdr_name_umlaut, sizeof(hdr_name_umlaut));
 236
 237         ret = g_obex_header_get_unicode(header, &str);
 238
 239         g_assert(ret == TRUE);
 240         g_assert_cmpstr(str, ==, "åäö");
 241
 242         g_obex_header_free(header);
 243 }
 244
 245 static void test_header_encode_name_empty(void)
 246 {
 247         GObexHeader *header;
 248         const char *str;
 249         gboolean ret;
 250
 251         header = parse_and_encode(hdr_name_empty, sizeof(hdr_name_empty));
 252
 253         ret = g_obex_header_get_unicode(header, &str);
 254
 255         g_assert(ret == TRUE);
 256         g_assert_cmpstr(str, ==, "");
 257
 258         g_obex_header_free(header);
 259 }
 260
 261 static void test_header_encode_body(void)
 262 {
 263         GObexHeader *header;
 264         guint8 expected[] = { 1, 2, 3, 4};
 265         const guint8 *buf;
 266         size_t len;
 267         gboolean ret;
 268
 269         header = parse_and_encode(hdr_body, sizeof(hdr_body));
 270
 271         ret = g_obex_header_get_bytes(header, &buf, &len);
 272
 273         g_assert(ret == TRUE);
 274         assert_memequal(expected, sizeof(expected), buf, len);
 275
 276         g_obex_header_free(header);
 277 }
 278
 279 static void test_header_encode_apparam(void)
 280 {
 281         GObexHeader *header;
 282         GObexApparam *apparam;
 283         gboolean ret;
 284         guint32 data;
 285
 286         header = parse_and_encode(hdr_apparam, sizeof(hdr_apparam));
 287
 288         apparam = g_obex_header_get_apparam(header);
 289         g_assert(apparam != NULL);
 290
 291         ret = g_obex_apparam_get_uint32(apparam, 0x00, &data);
 292         g_assert(ret == TRUE);
 293         g_assert(data == 0x01020304);
 294
 295         g_obex_apparam_free(apparam);
 296         g_obex_header_free(header);
 297 }
 298
 299 static void test_header_encode_actionid(void)
 300 {
 301         GObexHeader *header;
 302         gboolean ret;
 303         guint8 val;
 304
 305         header = parse_and_encode(hdr_actionid, sizeof(hdr_actionid));
 306
 307         ret = g_obex_header_get_uint8(header, &val);
 308
 309         g_assert(ret == TRUE);
 310         g_assert_cmpuint(val, ==, 0xab);
 311
 312         g_obex_header_free(header);
 313 }
 314
 315 static void test_decode_header_connid(void)
 316 {
 317         GObexHeader *header;
 318         size_t parsed;
 319         GError *err = NULL;
 320
 321         header = g_obex_header_decode(hdr_connid, sizeof(hdr_connid),
 322                                         G_OBEX_DATA_REF, &parsed, &err);
 323         g_assert_no_error(err);
 324
 325         g_assert_cmpuint(parsed, ==, sizeof(hdr_connid));
 326
 327         g_obex_header_free(header);
 328 }
 329
 330 static void test_decode_header_name_ascii(void)
 331 {
 332         GObexHeader *header;
 333         size_t parsed;
 334         GError *err = NULL;
 335
 336         header = g_obex_header_decode(hdr_name_ascii, sizeof(hdr_name_ascii),
 337                                         G_OBEX_DATA_REF, &parsed, &err);
 338         g_assert_no_error(err);
 339
 340         g_assert_cmpuint(parsed, ==, sizeof(hdr_name_ascii));
 341
 342         g_obex_header_free(header);
 343 }
 344
 345 static void test_decode_header_name_empty(void)
 346 {
 347         GObexHeader *header;
 348         size_t parsed;
 349         GError *err = NULL;
 350
 351         header = g_obex_header_decode(hdr_name_empty, sizeof(hdr_name_empty),
 352                                         G_OBEX_DATA_REF, &parsed, &err);
 353         g_assert_no_error(err);
 354
 355         g_assert_cmpuint(parsed, ==, sizeof(hdr_name_empty));
 356
 357         g_obex_header_free(header);
 358 }
 359
 360 static void test_decode_header_name_umlaut(void)
 361 {
 362         GObexHeader *header;
 363         size_t parsed;
 364         GError *err = NULL;
 365
 366         header = g_obex_header_decode(hdr_name_umlaut, sizeof(hdr_name_umlaut),
 367                                         G_OBEX_DATA_REF, &parsed, &err);
 368         g_assert_no_error(err);
 369
 370         g_assert_cmpuint(parsed, ==, sizeof(hdr_name_umlaut));
 371
 372         g_obex_header_free(header);
 373 }
 374
 375 static void test_decode_header_body(void)
 376 {
 377         GObexHeader *header;
 378         size_t parsed;
 379         GError *err = NULL;
 380
 381         header = g_obex_header_decode(hdr_body, sizeof(hdr_body),
 382                                         G_OBEX_DATA_COPY, &parsed, &err);
 383         g_assert_no_error(err);
 384
 385         g_assert_cmpuint(parsed, ==, sizeof(hdr_body));
 386
 387         g_obex_header_free(header);
 388 }
 389
 390 static void test_decode_header_body_extdata(void)
 391 {
 392         GObexHeader *header;
 393         size_t parsed;
 394         GError *err = NULL;
 395
 396         header = g_obex_header_decode(hdr_body, sizeof(hdr_body),
 397                                         G_OBEX_DATA_REF, &parsed, &err);
 398         g_assert_no_error(err);
 399
 400         g_assert_cmpuint(parsed, ==, sizeof(hdr_body));
 401
 402         g_obex_header_free(header);
 403 }
 404
 405 static void test_decode_header_actionid(void)
 406 {
 407         GObexHeader *header;
 408         size_t parsed;
 409         GError *err = NULL;
 410
 411         header = g_obex_header_decode(hdr_actionid, sizeof(hdr_actionid),
 412                                         G_OBEX_DATA_REF, &parsed, &err);
 413         g_assert_no_error(err);
 414
 415         g_assert_cmpuint(parsed, ==, sizeof(hdr_actionid));
 416
 417         g_obex_header_free(header);
 418 }
 419
 420 static void decode_header_nval(uint8_t *buf, size_t len)
 421 {
 422         GObexHeader *header;
 423         size_t parsed;
 424         GError *err = NULL;
 425
 426         header = g_obex_header_decode(buf, len, G_OBEX_DATA_REF, &parsed,
 427                                                                         &err);
 428         g_assert_error(err, G_OBEX_ERROR, G_OBEX_ERROR_PARSE_ERROR);
 429         g_assert(header == NULL);
 430         g_error_free(err);
 431 }
 432
 433 static void test_decode_header_uint32_nval(void)
 434 {
 435         decode_header_nval(hdr_uint32_nval, sizeof(hdr_uint32_nval));
 436 }
 437
 438 static void test_decode_header_unicode_nval_short(void)
 439 {
 440         decode_header_nval(hdr_unicode_nval_short,
 441                                         sizeof(hdr_unicode_nval_short));
 442 }
 443
 444 static void test_decode_header_unicode_nval_data(void)
 445 {
 446         decode_header_nval(hdr_unicode_nval_data,
 447                                         sizeof(hdr_unicode_nval_data));
 448 }
 449
 450 static void test_decode_header_bytes_nval_short(void)
 451 {
 452         decode_header_nval(hdr_bytes_nval_short, sizeof(hdr_bytes_nval_short));
 453 }
 454
 455 static void test_decode_header_bytes_nval_data(void)
 456 {
 457         decode_header_nval(hdr_bytes_nval_data, sizeof(hdr_bytes_nval_data));
 458 }
 459
 460 static void test_decode_header_bytes_nval_len(void)
 461 {
 462         decode_header_nval(hdr_bytes_nval_len, sizeof(hdr_bytes_nval_len));
 463 }
 464
 465 static void test_decode_header_multi(void)
 466 {
 467         GObexHeader *header;
 468         GByteArray *buf;
 469         size_t parsed;
 470         GError *err = NULL;
 471
 472         buf = g_byte_array_sized_new(sizeof(hdr_connid) +
 473                                         sizeof(hdr_name_ascii) +
 474                                         sizeof(hdr_actionid) +
 475                                         sizeof(hdr_body));
 476
 477         g_byte_array_append(buf, hdr_connid, sizeof(hdr_connid));
 478         g_byte_array_append(buf, hdr_name_ascii, sizeof(hdr_name_ascii));
 479         g_byte_array_append(buf, hdr_actionid, sizeof(hdr_actionid));
 480         g_byte_array_append(buf, hdr_body, sizeof(hdr_body));
 481
 482         header = g_obex_header_decode(buf->data, buf->len, G_OBEX_DATA_REF,
 483                                                                 &parsed, &err);
 484         g_assert_no_error(err);
 485         g_assert_cmpuint(parsed, ==, sizeof(hdr_connid));
 486         g_byte_array_remove_range(buf, 0, parsed);
 487         g_obex_header_free(header);
 488
 489         header = g_obex_header_decode(buf->data, buf->len, G_OBEX_DATA_REF,
 490                                                                 &parsed, &err);
 491         g_assert_no_error(err);
 492         g_assert_cmpuint(parsed, ==, sizeof(hdr_name_ascii));
 493         g_byte_array_remove_range(buf, 0, parsed);
 494         g_obex_header_free(header);
 495
 496         header = g_obex_header_decode(buf->data, buf->len, G_OBEX_DATA_REF,
 497                                                                 &parsed, &err);
 498         g_assert_no_error(err);
 499         g_assert_cmpuint(parsed, ==, sizeof(hdr_actionid));
 500         g_byte_array_remove_range(buf, 0, parsed);
 501         g_obex_header_free(header);
 502
 503         header = g_obex_header_decode(buf->data, buf->len, G_OBEX_DATA_REF,
 504                                                                 &parsed, &err);
 505         g_assert_no_error(err);
 506         g_assert_cmpuint(parsed, ==, sizeof(hdr_body));
 507         g_byte_array_remove_range(buf, 0, parsed);
 508         g_obex_header_free(header);
 509
 510         g_byte_array_unref(buf);
 511 }
 512
 513 int main(int argc, char *argv[])
 514 {
 515         g_test_init(&argc, &argv, NULL);
 516
 517         g_test_add_func("/gobex/test_decode_header_connid",
 518                                                 test_decode_header_connid);
 519         g_test_add_func("/gobex/test_decode_header_name_empty",
 520                                         test_decode_header_name_empty);
 521         g_test_add_func("/gobex/test_decode_header_name_ascii",
 522                                         test_decode_header_name_ascii);
 523         g_test_add_func("/gobex/test_decode_header_name_umlaut",
 524                                         test_decode_header_name_umlaut);
 525         g_test_add_func("/gobex/test_decode_header_body",
 526                                                 test_decode_header_body);
 527         g_test_add_func("/gobex/test_decode_header_body_extdata",
 528                                         test_decode_header_body_extdata);
 529         g_test_add_func("/gobex/test_decode_header_actionid",
 530                                                 test_decode_header_actionid);
 531         g_test_add_func("/gobex/test_decode_header_multi",
 532                                                 test_decode_header_multi);
 533
 534         g_test_add_func("/gobex/test_decode_header_uint32_nval",
 535                                         test_decode_header_uint32_nval);
 536         g_test_add_func("/gobex/test_decode_header_unicode_nval_short",
 537                                         test_decode_header_unicode_nval_short);
 538         g_test_add_func("/gobex/test_decode_header_unicode_nval_data",
 539                                         test_decode_header_unicode_nval_data);
 540         g_test_add_func("/gobex/test_decode_header_bytes_nval_short",
 541                                         test_decode_header_bytes_nval_short);
 542         g_test_add_func("/gobex/test_decode_header_bytes_nval_data",
 543                                         test_decode_header_bytes_nval_data);
 544         g_test_add_func("/gobex/test_decode_header_bytes_nval_len",
 545                                         test_decode_header_bytes_nval_len);
 546
 547         g_test_add_func("/gobex/test_header_encode_connid",
 548                                                 test_header_encode_connid);
 549         g_test_add_func("/gobex/test_header_encode_name_empty",
 550                                         test_header_encode_name_empty);
 551         g_test_add_func("/gobex/test_header_encode_name_ascii",
 552                                         test_header_encode_name_ascii);
 553         g_test_add_func("/gobex/test_header_encode_name_umlaut",
 554                                         test_header_encode_name_umlaut);
 555         g_test_add_func("/gobex/test_header_encode_body",
 556                                                 test_header_encode_body);
 557         g_test_add_func("/gobex/test_header_encode_connid",
 558                                                 test_header_encode_actionid);
 559         g_test_add_func("/gobex/test_header_encode_apparam",
 560                                                 test_header_encode_apparam);
 561
 562         g_test_add_func("/gobex/test_header_name_empty",
 563                                                 test_header_name_empty);
 564         g_test_add_func("/gobex/test_header_name_ascii",
 565                                                 test_header_name_ascii);
 566         g_test_add_func("/gobex/test_header_name_umlaut",
 567                                                 test_header_name_umlaut);
 568         g_test_add_func("/gobex/test_header_bytes", test_header_bytes);
 569         g_test_add_func("/gobex/test_header_uint8", test_header_uint8);
 570         g_test_add_func("/gobex/test_header_uint32", test_header_uint32);
 571         g_test_add_func("/gobex/test_header_apparam", test_header_apparam);
 572
 573         return g_test_run();
 574 }