src/test_libFLAC/bitbuffer.c

   1 /* test_libFLAC - Unit tester for libFLAC
   2  * Copyright (C) 2000,2001,2002,2003,2004  Josh Coalson
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License
   6  * as published by the Free Software Foundation; either version 2
   7  * of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  17  */
  18
  19 #include "FLAC/assert.h"
  20 #include "private/bitbuffer.h" /* from the libFLAC private include area */
  21 #include <stdio.h>
  22 #include <string.h> /* for memcmp() */
  23
  24 /* adjust for compilers that can't understand using LLU suffix for uint64_t literals */
  25 #ifdef _MSC_VER
  26 #define FLAC__U64L(x) x
  27 #else
  28 #define FLAC__U64L(x) x##LLU
  29 #endif
  30
  31 /*
  32  * WATCHOUT!  Since FLAC__BitBuffer is a private structure, we use a copy of
  33  * the definition here to get at the internals.  Make sure this is kept up
  34  * to date with what is in ../libFLAC/bitbuffer.c
  35  */
  36 struct FLAC__BitBuffer {
  37         FLAC__blurb *buffer;
  38         unsigned capacity; /* in blurbs */
  39         unsigned blurbs, bits;
  40         unsigned total_bits; /* must always == FLAC__BITS_PER_BLURB*blurbs+bits */
  41         unsigned consumed_blurbs, consumed_bits;
  42         unsigned total_consumed_bits; /* must always == FLAC__BITS_PER_BLURB*consumed_blurbs+consumed_bits */
  43         FLAC__uint16 read_crc16;
  44 #if FLAC__BITS_PER_BLURB == 32
  45         unsigned crc16_align;
  46 #endif
  47         FLAC__blurb save_head, save_tail;
  48 };
  49
  50
  51 static FLAC__bool dummy_read_callback(FLAC__byte buffer[], unsigned *bytes, void *client_data)
  52 {
  53         (void)buffer, (void)bytes, (void)client_data;
  54         return true;
  55 }
  56
  57 FLAC__bool test_bitbuffer()
  58 {
  59         FLAC__BitBuffer *bb, *bb_zero, *bb_one, *bbcopy;
  60         FLAC__bool ok;
  61         unsigned i, j;
  62         static FLAC__byte test_pattern1[19] = { 0xaa, 0xf0, 0xaa, 0xbe, 0xaa, 0xaa, 0xaa, 0xa8, 0x30, 0x0a, 0xaa, 0xaa, 0xaa, 0xad, 0xea, 0xdb, 0xee, 0xfa, 0xce };
  63
  64         FLAC__ASSERT(FLAC__BITS_PER_BLURB == 8);
  65
  66         printf("\n+++ libFLAC unit test: bitbuffer\n\n");
  67
  68         /*
  69          * test new -> delete
  70          */
  71         printf("testing new... ");
  72         bb = FLAC__bitbuffer_new();
  73         if(0 == bb) {
  74                 printf("FAILED, returned NULL\n");
  75                 return false;
  76         }
  77         printf("OK\n");
  78
  79         printf("testing delete... ");
  80         FLAC__bitbuffer_delete(bb);
  81         printf("OK\n");
  82
  83         /*
  84          * test new -> init -> delete
  85          */
  86         printf("testing new... ");
  87         bb = FLAC__bitbuffer_new();
  88         if(0 == bb) {
  89                 printf("FAILED, returned NULL\n");
  90                 return false;
  91         }
  92         printf("OK\n");
  93
  94         printf("testing init... ");
  95         FLAC__bitbuffer_init(bb);
  96         if(0 == bb) {
  97                 printf("FAILED, returned NULL\n");
  98                 return false;
  99         }
 100         printf("OK\n");
 101
 102         printf("testing delete... ");
 103         FLAC__bitbuffer_delete(bb);
 104         printf("OK\n");
 105
 106         /*
 107          * test new -> init -> clear -> delete
 108          */
 109         printf("testing new... ");
 110         bb = FLAC__bitbuffer_new();
 111         if(0 == bb) {
 112                 printf("FAILED, returned NULL\n");
 113                 return false;
 114         }
 115         printf("OK\n");
 116
 117         printf("testing init... ");
 118         FLAC__bitbuffer_init(bb);
 119         if(0 == bb) {
 120                 printf("FAILED, returned NULL\n");
 121                 return false;
 122         }
 123         printf("OK\n");
 124
 125         printf("testing clear... ");
 126         FLAC__bitbuffer_clear(bb);
 127         if(0 == bb) {
 128                 printf("FAILED, returned NULL\n");
 129                 return false;
 130         }
 131         printf("OK\n");
 132
 133         printf("testing delete... ");
 134         FLAC__bitbuffer_delete(bb);
 135         printf("OK\n");
 136
 137         /*
 138          * test normal usage
 139          */
 140         printf("testing new... ");
 141         bb = FLAC__bitbuffer_new();
 142         bb_zero = FLAC__bitbuffer_new();
 143         bb_one = FLAC__bitbuffer_new();
 144         bbcopy = FLAC__bitbuffer_new();
 145         if(0 == bb || 0 == bb_zero || 0 == bb_one || 0 == bbcopy) {
 146                 printf("FAILED, returned NULL\n");
 147                 return false;
 148         }
 149         printf("OK\n");
 150
 151         printf("testing init... ");
 152         ok = FLAC__bitbuffer_init(bb) && FLAC__bitbuffer_init(bb_zero) && FLAC__bitbuffer_init(bb_one) && FLAC__bitbuffer_init(bbcopy);
 153         printf("%s\n", ok?"OK":"FAILED");
 154         if(!ok)
 155                 return false;
 156
 157         printf("testing clear... ");
 158         ok = FLAC__bitbuffer_clear(bb) && FLAC__bitbuffer_clear(bb_zero) && FLAC__bitbuffer_clear(bb_one) && FLAC__bitbuffer_clear(bbcopy);
 159         printf("%s\n", ok?"OK":"FAILED");
 160         if(!ok)
 161                 return false;
 162
 163         printf("setting up bb_one... ");
 164         ok = FLAC__bitbuffer_write_raw_uint32(bb_one, 1, 7) && FLAC__bitbuffer_read_raw_uint32(bb_one, &i, 6, dummy_read_callback, 0);
 165         printf("%s\n", ok?"OK":"FAILED");
 166         if(!ok)
 167                 return false;
 168         FLAC__bitbuffer_dump(bb_one, stdout);
 169
 170         printf("capacity = %u\n", bb->capacity);
 171
 172         printf("testing zeroes, raw_uint32*... ");
 173         ok =
 174                 FLAC__bitbuffer_write_raw_uint32(bb, 0x1, 1) &&
 175                 FLAC__bitbuffer_write_raw_uint32(bb, 0x1, 2) &&
 176                 FLAC__bitbuffer_write_raw_uint32(bb, 0xa, 5) &&
 177                 FLAC__bitbuffer_write_raw_uint32(bb, 0xf0, 8) &&
 178                 FLAC__bitbuffer_write_raw_uint32(bb, 0x2aa, 10) &&
 179                 FLAC__bitbuffer_write_raw_uint32(bb, 0xf, 4) &&
 180                 FLAC__bitbuffer_write_raw_uint32(bb, 0xaaaaaaaa, 32) &&
 181                 FLAC__bitbuffer_write_zeroes(bb, 4) &&
 182                 FLAC__bitbuffer_write_raw_uint32(bb, 0x3, 2) &&
 183                 FLAC__bitbuffer_write_zeroes(bb, 8) &&
 184                 FLAC__bitbuffer_write_raw_uint64(bb, FLAC__U64L(0xaaaaaaaadeadbeef), 64) &&
 185                 FLAC__bitbuffer_write_raw_uint32(bb, 0xace, 12)
 186         ;
 187         if(!ok) {
 188                 printf("FAILED\n");
 189                 FLAC__bitbuffer_dump(bb, stdout);
 190                 return false;
 191         }
 192         if(bb->blurbs != sizeof(test_pattern1)) {
 193                 printf("FAILED byte count %u != %u\n", bb->blurbs, (unsigned)sizeof(test_pattern1));
 194                 FLAC__bitbuffer_dump(bb, stdout);
 195                 return false;
 196         }
 197         if(bb->bits != 0) {
 198                 printf("FAILED bit count %u != 0\n", bb->bits);
 199                 FLAC__bitbuffer_dump(bb, stdout);
 200                 return false;
 201         }
 202         if(bb->total_bits != 8*bb->blurbs+bb->bits) {
 203                 printf("FAILED total_bits count %u != %u (%u:%u)\n", bb->total_bits, 8*bb->blurbs+bb->bits, bb->blurbs, bb->bits);
 204                 FLAC__bitbuffer_dump(bb, stdout);
 205                 return false;
 206         }
 207         if(memcmp(bb->buffer, test_pattern1, sizeof(FLAC__byte)*sizeof(test_pattern1)) != 0) {
 208                 printf("FAILED pattern match\n");
 209                 FLAC__bitbuffer_dump(bb, stdout);
 210                 return false;
 211         }
 212         printf("OK\n");
 213         FLAC__bitbuffer_dump(bb, stdout);
 214
 215         printf("testing raw_uint32 some more... ");
 216         ok = FLAC__bitbuffer_write_raw_uint32(bb, 0x3d, 6);
 217         if(!ok) {
 218                 printf("FAILED\n");
 219                 FLAC__bitbuffer_dump(bb, stdout);
 220                 return false;
 221         }
 222         if(bb->blurbs != sizeof(test_pattern1)) {
 223                 printf("FAILED byte count %u != %u\n", bb->blurbs, (unsigned)sizeof(test_pattern1));
 224                 FLAC__bitbuffer_dump(bb, stdout);
 225                 return false;
 226         }
 227         if(bb->bits != 6) {
 228                 printf("FAILED bit count %u != 6\n", bb->bits);
 229                 FLAC__bitbuffer_dump(bb, stdout);
 230                 return false;
 231         }
 232         if(bb->total_bits != 8*bb->blurbs+bb->bits) {
 233                 printf("FAILED total_bits count %u != %u (%u:%u)\n", bb->total_bits, 8*bb->blurbs+bb->bits, bb->blurbs, bb->bits);
 234                 FLAC__bitbuffer_dump(bb, stdout);
 235                 return false;
 236         }
 237         if(memcmp(bb->buffer, test_pattern1, sizeof(FLAC__byte)*sizeof(test_pattern1)) != 0 || bb->buffer[bb->blurbs] != 0x3d) {
 238                 printf("FAILED pattern match\n");
 239                 FLAC__bitbuffer_dump(bb, stdout);
 240                 return false;
 241         }
 242         printf("OK\n");
 243         FLAC__bitbuffer_dump(bb, stdout);
 244
 245         printf("testing concatenate_aligned (bb_zero)... ");
 246         ok = FLAC__bitbuffer_concatenate_aligned(bb, bb_zero);
 247         if(!ok) {
 248                 printf("FAILED\n");
 249                 FLAC__bitbuffer_dump(bb, stdout);
 250                 return false;
 251         }
 252         if(bb->blurbs != sizeof(test_pattern1)) {
 253                 printf("FAILED byte count %u != %u\n", bb->blurbs, (unsigned)sizeof(test_pattern1));
 254                 FLAC__bitbuffer_dump(bb, stdout);
 255                 return false;
 256         }
 257         if(bb->bits != 6) {
 258                 printf("FAILED bit count %u != 6\n", bb->bits);
 259                 FLAC__bitbuffer_dump(bb, stdout);
 260                 return false;
 261         }
 262         if(bb->total_bits != 8*bb->blurbs+bb->bits) {
 263                 printf("FAILED total_bits count %u != %u (%u:%u)\n", bb->total_bits, 8*bb->blurbs+bb->bits, bb->blurbs, bb->bits);
 264                 FLAC__bitbuffer_dump(bb, stdout);
 265                 return false;
 266         }
 267         if(memcmp(bb->buffer, test_pattern1, sizeof(FLAC__byte)*sizeof(test_pattern1)) != 0 || bb->buffer[bb->blurbs] != 0x3d) {
 268                 printf("FAILED pattern match\n");
 269                 FLAC__bitbuffer_dump(bb, stdout);
 270                 return false;
 271         }
 272         printf("OK\n");
 273         FLAC__bitbuffer_dump(bb, stdout);
 274
 275         printf("testing concatenate_aligned (bb_one)... ");
 276         ok = FLAC__bitbuffer_concatenate_aligned(bb, bb_one);
 277         if(!ok) {
 278                 printf("FAILED\n");
 279                 FLAC__bitbuffer_dump(bb, stdout);
 280                 return false;
 281         }
 282         if(bb->blurbs != sizeof(test_pattern1)) {
 283                 printf("FAILED byte count %u != %u\n", bb->blurbs, (unsigned)sizeof(test_pattern1));
 284                 FLAC__bitbuffer_dump(bb, stdout);
 285                 return false;
 286         }
 287         if(bb->bits != 7) {
 288                 printf("FAILED bit count %u != 7\n", bb->bits);
 289                 FLAC__bitbuffer_dump(bb, stdout);
 290                 return false;
 291         }
 292         if(bb->total_bits != 8*bb->blurbs+bb->bits) {
 293                 printf("FAILED total_bits count %u != %u (%u:%u)\n", bb->total_bits, 8*bb->blurbs+bb->bits, bb->blurbs, bb->bits);
 294                 FLAC__bitbuffer_dump(bb, stdout);
 295                 return false;
 296         }
 297         if(memcmp(bb->buffer, test_pattern1, sizeof(FLAC__byte)*sizeof(test_pattern1)) != 0 || bb->buffer[bb->blurbs] != 0x7b) {
 298                 printf("FAILED pattern match\n");
 299                 FLAC__bitbuffer_dump(bb, stdout);
 300                 return false;
 301         }
 302         printf("OK\n");
 303         FLAC__bitbuffer_dump(bb, stdout);
 304
 305         printf("testing concatenate_aligned (bb_one again)... ");
 306         (void)FLAC__bitbuffer_write_raw_uint32(bb_one, 1, 1);
 307         (void)FLAC__bitbuffer_read_raw_uint32(bb_one, &i, 1, dummy_read_callback, 0);
 308         ok = FLAC__bitbuffer_concatenate_aligned(bb, bb_one);
 309         if(!ok) {
 310                 printf("FAILED\n");
 311                 FLAC__bitbuffer_dump(bb, stdout);
 312                 return false;
 313         }
 314         if(bb->blurbs != sizeof(test_pattern1)+1) {
 315                 printf("FAILED byte count %u != %u\n", bb->blurbs, (unsigned)sizeof(test_pattern1)+1);
 316                 FLAC__bitbuffer_dump(bb, stdout);
 317                 return false;
 318         }
 319         if(bb->bits != 0) {
 320                 printf("FAILED bit count %u != 0\n", bb->bits);
 321                 FLAC__bitbuffer_dump(bb, stdout);
 322                 return false;
 323         }
 324         if(bb->total_bits != 8*bb->blurbs+bb->bits) {
 325                 printf("FAILED total_bits count %u != %u (%u:%u)\n", bb->total_bits, 8*bb->blurbs+bb->bits, bb->blurbs, bb->bits);
 326                 FLAC__bitbuffer_dump(bb, stdout);
 327                 return false;
 328         }
 329         if(memcmp(bb->buffer, test_pattern1, sizeof(FLAC__byte)*sizeof(test_pattern1)) != 0 || bb->buffer[bb->blurbs-1] != 0xf7) {
 330                 printf("FAILED pattern match\n");
 331                 FLAC__bitbuffer_dump(bb, stdout);
 332                 return false;
 333         }
 334         printf("OK\n");
 335         FLAC__bitbuffer_dump(bb, stdout);
 336
 337         printf("testing concatenate_aligned (bb_four)... ");
 338         (void)FLAC__bitbuffer_clear(bb_one);
 339         (void)FLAC__bitbuffer_write_raw_uint32(bb_one, 8, 4);
 340         ok = FLAC__bitbuffer_concatenate_aligned(bb, bb_one);
 341         if(!ok) {
 342                 printf("FAILED\n");
 343                 FLAC__bitbuffer_dump(bb, stdout);
 344                 return false;
 345         }
 346         if(bb->blurbs != sizeof(test_pattern1)+1) {
 347                 printf("FAILED byte count %u != %u\n", bb->blurbs, (unsigned)sizeof(test_pattern1)+1);
 348                 FLAC__bitbuffer_dump(bb, stdout);
 349                 return false;
 350         }
 351         if(bb->bits != 4) {
 352                 printf("FAILED bit count %u != 4\n", bb->bits);
 353                 FLAC__bitbuffer_dump(bb, stdout);
 354                 return false;
 355         }
 356         if(bb->total_bits != 8*bb->blurbs+bb->bits) {
 357                 printf("FAILED total_bits count %u != %u (%u:%u)\n", bb->total_bits, 8*bb->blurbs+bb->bits, bb->blurbs, bb->bits);
 358                 FLAC__bitbuffer_dump(bb, stdout);
 359                 return false;
 360         }
 361         if(memcmp(bb->buffer, test_pattern1, sizeof(FLAC__byte)*sizeof(test_pattern1)) != 0 || bb->buffer[bb->blurbs] != 0x08) {
 362                 printf("FAILED pattern match\n");
 363                 FLAC__bitbuffer_dump(bb, stdout);
 364                 return false;
 365         }
 366         printf("OK\n");
 367         FLAC__bitbuffer_dump(bb, stdout);
 368
 369         printf("testing concatenate_aligned (bb_eight)... ");
 370         (void)FLAC__bitbuffer_read_raw_uint32(bb_one, &i, 4, dummy_read_callback, 0);
 371         (void)FLAC__bitbuffer_write_raw_uint32(bb_one, 0xaa, 8);
 372         ok = FLAC__bitbuffer_concatenate_aligned(bb, bb_one);
 373         if(!ok) {
 374                 printf("FAILED\n");
 375                 FLAC__bitbuffer_dump(bb, stdout);
 376                 return false;
 377         }
 378         if(bb->blurbs != sizeof(test_pattern1)+2) {
 379                 printf("FAILED byte count %u != %u\n", bb->blurbs, (unsigned)sizeof(test_pattern1)+2);
 380                 FLAC__bitbuffer_dump(bb, stdout);
 381                 return false;
 382         }
 383         if(bb->bits != 4) {
 384                 printf("FAILED bit count %u != 4\n", bb->bits);
 385                 FLAC__bitbuffer_dump(bb, stdout);
 386                 return false;
 387         }
 388         if(bb->total_bits != 8*bb->blurbs+bb->bits) {
 389                 printf("FAILED total_bits count %u != %u (%u:%u)\n", bb->total_bits, 8*bb->blurbs+bb->bits, bb->blurbs, bb->bits);
 390                 FLAC__bitbuffer_dump(bb, stdout);
 391                 return false;
 392         }
 393         if(memcmp(bb->buffer, test_pattern1, sizeof(FLAC__byte)*sizeof(test_pattern1)) != 0 || bb->buffer[bb->blurbs-1] != 0x8a || bb->buffer[bb->blurbs] != 0x0a) {
 394                 printf("FAILED pattern match\n");
 395                 FLAC__bitbuffer_dump(bb, stdout);
 396                 return false;
 397         }
 398         printf("OK\n");
 399         FLAC__bitbuffer_dump(bb, stdout);
 400
 401         printf("testing concatenate_aligned (bb_seventeen)... ");
 402         (void)FLAC__bitbuffer_write_raw_uint32(bb_one, 0x155, 9);
 403         ok = FLAC__bitbuffer_concatenate_aligned(bb, bb_one);
 404         if(!ok) {
 405                 printf("FAILED\n");
 406                 FLAC__bitbuffer_dump(bb, stdout);
 407                 return false;
 408         }
 409         if(bb->blurbs != sizeof(test_pattern1)+4) {
 410                 printf("FAILED byte count %u != %u\n", bb->blurbs, (unsigned)sizeof(test_pattern1)+4);
 411                 FLAC__bitbuffer_dump(bb, stdout);
 412                 return false;
 413         }
 414         if(bb->bits != 5) {
 415                 printf("FAILED bit count %u != 5\n", bb->bits);
 416                 FLAC__bitbuffer_dump(bb, stdout);
 417                 return false;
 418         }
 419         if(bb->total_bits != 8*bb->blurbs+bb->bits) {
 420                 printf("FAILED total_bits count %u != %u (%u:%u)\n", bb->total_bits, 8*bb->blurbs+bb->bits, bb->blurbs, bb->bits);
 421                 FLAC__bitbuffer_dump(bb, stdout);
 422                 return false;
 423         }
 424         if(memcmp(bb->buffer, test_pattern1, sizeof(FLAC__byte)*sizeof(test_pattern1)) != 0 || bb->buffer[bb->blurbs-3] != 0x8a || bb->buffer[bb->blurbs-2] != 0xaa || bb->buffer[bb->blurbs-1] != 0xaa || bb->buffer[bb->blurbs] != 0x15) {
 425                 printf("FAILED pattern match\n");
 426                 FLAC__bitbuffer_dump(bb, stdout);
 427                 return false;
 428         }
 429         printf("OK\n");
 430         FLAC__bitbuffer_dump(bb, stdout);
 431
 432         printf("testing utf8_uint32(0x00000000)... ");
 433         FLAC__bitbuffer_clear(bb);
 434         FLAC__bitbuffer_write_utf8_uint32(bb, 0x00000000);
 435         ok = bb->total_bits == 8 && bb->buffer[0] == 0;
 436         printf("%s\n", ok?"OK":"FAILED");
 437         if(!ok) {
 438                 FLAC__bitbuffer_dump(bb, stdout);
 439                 return false;
 440         }
 441
 442         printf("testing utf8_uint32(0x0000007F)... ");
 443         FLAC__bitbuffer_clear(bb);
 444         FLAC__bitbuffer_write_utf8_uint32(bb, 0x0000007F);
 445         ok = bb->total_bits == 8 && bb->buffer[0] == 0x7F;
 446         printf("%s\n", ok?"OK":"FAILED");
 447         if(!ok) {
 448                 FLAC__bitbuffer_dump(bb, stdout);
 449                 return false;
 450         }
 451
 452         printf("testing utf8_uint32(0x00000080)... ");
 453         FLAC__bitbuffer_clear(bb);
 454         FLAC__bitbuffer_write_utf8_uint32(bb, 0x00000080);
 455         ok = bb->total_bits == 16 && bb->buffer[0] == 0xC2 && bb->buffer[1] == 0x80;
 456         printf("%s\n", ok?"OK":"FAILED");
 457         if(!ok) {
 458                 FLAC__bitbuffer_dump(bb, stdout);
 459                 return false;
 460         }
 461
 462         printf("testing utf8_uint32(0x000007FF)... ");
 463         FLAC__bitbuffer_clear(bb);
 464         FLAC__bitbuffer_write_utf8_uint32(bb, 0x000007FF);
 465         ok = bb->total_bits == 16 && bb->buffer[0] == 0xDF && bb->buffer[1] == 0xBF;
 466         printf("%s\n", ok?"OK":"FAILED");
 467         if(!ok) {
 468                 FLAC__bitbuffer_dump(bb, stdout);
 469                 return false;
 470         }
 471
 472         printf("testing utf8_uint32(0x00000800)... ");
 473         FLAC__bitbuffer_clear(bb);
 474         FLAC__bitbuffer_write_utf8_uint32(bb, 0x00000800);
 475         ok = bb->total_bits == 24 && bb->buffer[0] == 0xE0 && bb->buffer[1] == 0xA0 && bb->buffer[2] == 0x80;
 476         printf("%s\n", ok?"OK":"FAILED");
 477         if(!ok) {
 478                 FLAC__bitbuffer_dump(bb, stdout);
 479                 return false;
 480         }
 481
 482         printf("testing utf8_uint32(0x0000FFFF)... ");
 483         FLAC__bitbuffer_clear(bb);
 484         FLAC__bitbuffer_write_utf8_uint32(bb, 0x0000FFFF);
 485         ok = bb->total_bits == 24 && bb->buffer[0] == 0xEF && bb->buffer[1] == 0xBF && bb->buffer[2] == 0xBF;
 486         printf("%s\n", ok?"OK":"FAILED");
 487         if(!ok) {
 488                 FLAC__bitbuffer_dump(bb, stdout);
 489                 return false;
 490         }
 491
 492         printf("testing utf8_uint32(0x00010000)... ");
 493         FLAC__bitbuffer_clear(bb);
 494         FLAC__bitbuffer_write_utf8_uint32(bb, 0x00010000);
 495         ok = bb->total_bits == 32 && bb->buffer[0] == 0xF0 && bb->buffer[1] == 0x90 && bb->buffer[2] == 0x80 && bb->buffer[3] == 0x80;
 496         printf("%s\n", ok?"OK":"FAILED");
 497         if(!ok) {
 498                 FLAC__bitbuffer_dump(bb, stdout);
 499                 return false;
 500         }
 501
 502         printf("testing utf8_uint32(0x001FFFFF)... ");
 503         FLAC__bitbuffer_clear(bb);
 504         FLAC__bitbuffer_write_utf8_uint32(bb, 0x001FFFFF);
 505         ok = bb->total_bits == 32 && bb->buffer[0] == 0xF7 && bb->buffer[1] == 0xBF && bb->buffer[2] == 0xBF && bb->buffer[3] == 0xBF;
 506         printf("%s\n", ok?"OK":"FAILED");
 507         if(!ok) {
 508                 FLAC__bitbuffer_dump(bb, stdout);
 509                 return false;
 510         }
 511
 512         printf("testing utf8_uint32(0x00200000)... ");
 513         FLAC__bitbuffer_clear(bb);
 514         FLAC__bitbuffer_write_utf8_uint32(bb, 0x00200000);
 515         ok = bb->total_bits == 40 && bb->buffer[0] == 0xF8 && bb->buffer[1] == 0x88 && bb->buffer[2] == 0x80 && bb->buffer[3] == 0x80 && bb->buffer[4] == 0x80;
 516         printf("%s\n", ok?"OK":"FAILED");
 517         if(!ok) {
 518                 FLAC__bitbuffer_dump(bb, stdout);
 519                 return false;
 520         }
 521
 522         printf("testing utf8_uint32(0x03FFFFFF)... ");
 523         FLAC__bitbuffer_clear(bb);
 524         FLAC__bitbuffer_write_utf8_uint32(bb, 0x03FFFFFF);
 525         ok = bb->total_bits == 40 && bb->buffer[0] == 0xFB && bb->buffer[1] == 0xBF && bb->buffer[2] == 0xBF && bb->buffer[3] == 0xBF && bb->buffer[4] == 0xBF;
 526         printf("%s\n", ok?"OK":"FAILED");
 527         if(!ok) {
 528                 FLAC__bitbuffer_dump(bb, stdout);
 529                 return false;
 530         }
 531
 532         printf("testing utf8_uint32(0x04000000)... ");
 533         FLAC__bitbuffer_clear(bb);
 534         FLAC__bitbuffer_write_utf8_uint32(bb, 0x04000000);
 535         ok = bb->total_bits == 48 && bb->buffer[0] == 0xFC && bb->buffer[1] == 0x84 && bb->buffer[2] == 0x80 && bb->buffer[3] == 0x80 && bb->buffer[4] == 0x80 && bb->buffer[5] == 0x80;
 536         printf("%s\n", ok?"OK":"FAILED");
 537         if(!ok) {
 538                 FLAC__bitbuffer_dump(bb, stdout);
 539                 return false;
 540         }
 541
 542         printf("testing utf8_uint32(0x7FFFFFFF)... ");
 543         FLAC__bitbuffer_clear(bb);
 544         FLAC__bitbuffer_write_utf8_uint32(bb, 0x7FFFFFFF);
 545         ok = bb->total_bits == 48 && bb->buffer[0] == 0xFD && bb->buffer[1] == 0xBF && bb->buffer[2] == 0xBF && bb->buffer[3] == 0xBF && bb->buffer[4] == 0xBF && bb->buffer[5] == 0xBF;
 546         printf("%s\n", ok?"OK":"FAILED");
 547         if(!ok) {
 548                 FLAC__bitbuffer_dump(bb, stdout);
 549                 return false;
 550         }
 551
 552         printf("testing utf8_uint64(0x0000000000000000)... ");
 553         FLAC__bitbuffer_clear(bb);
 554         FLAC__bitbuffer_write_utf8_uint64(bb, 0x0000000000000000);
 555         ok = bb->total_bits == 8 && bb->buffer[0] == 0;
 556         printf("%s\n", ok?"OK":"FAILED");
 557         if(!ok) {
 558                 FLAC__bitbuffer_dump(bb, stdout);
 559                 return false;
 560         }
 561
 562         printf("testing utf8_uint64(0x000000000000007F)... ");
 563         FLAC__bitbuffer_clear(bb);
 564         FLAC__bitbuffer_write_utf8_uint64(bb, 0x000000000000007F);
 565         ok = bb->total_bits == 8 && bb->buffer[0] == 0x7F;
 566         printf("%s\n", ok?"OK":"FAILED");
 567         if(!ok) {
 568                 FLAC__bitbuffer_dump(bb, stdout);
 569                 return false;
 570         }
 571
 572         printf("testing utf8_uint64(0x0000000000000080)... ");
 573         FLAC__bitbuffer_clear(bb);
 574         FLAC__bitbuffer_write_utf8_uint64(bb, 0x0000000000000080);
 575         ok = bb->total_bits == 16 && bb->buffer[0] == 0xC2 && bb->buffer[1] == 0x80;
 576         printf("%s\n", ok?"OK":"FAILED");
 577         if(!ok) {
 578                 FLAC__bitbuffer_dump(bb, stdout);
 579                 return false;
 580         }
 581
 582         printf("testing utf8_uint64(0x00000000000007FF)... ");
 583         FLAC__bitbuffer_clear(bb);
 584         FLAC__bitbuffer_write_utf8_uint64(bb, 0x00000000000007FF);
 585         ok = bb->total_bits == 16 && bb->buffer[0] == 0xDF && bb->buffer[1] == 0xBF;
 586         printf("%s\n", ok?"OK":"FAILED");
 587         if(!ok) {
 588                 FLAC__bitbuffer_dump(bb, stdout);
 589                 return false;
 590         }
 591
 592         printf("testing utf8_uint64(0x0000000000000800)... ");
 593         FLAC__bitbuffer_clear(bb);
 594         FLAC__bitbuffer_write_utf8_uint64(bb, 0x0000000000000800);
 595         ok = bb->total_bits == 24 && bb->buffer[0] == 0xE0 && bb->buffer[1] == 0xA0 && bb->buffer[2] == 0x80;
 596         printf("%s\n", ok?"OK":"FAILED");
 597         if(!ok) {
 598                 FLAC__bitbuffer_dump(bb, stdout);
 599                 return false;
 600         }
 601
 602         printf("testing utf8_uint64(0x000000000000FFFF)... ");
 603         FLAC__bitbuffer_clear(bb);
 604         FLAC__bitbuffer_write_utf8_uint64(bb, 0x000000000000FFFF);
 605         ok = bb->total_bits == 24 && bb->buffer[0] == 0xEF && bb->buffer[1] == 0xBF && bb->buffer[2] == 0xBF;
 606         printf("%s\n", ok?"OK":"FAILED");
 607         if(!ok) {
 608                 FLAC__bitbuffer_dump(bb, stdout);
 609                 return false;
 610         }
 611
 612         printf("testing utf8_uint64(0x0000000000010000)... ");
 613         FLAC__bitbuffer_clear(bb);
 614         FLAC__bitbuffer_write_utf8_uint64(bb, 0x0000000000010000);
 615         ok = bb->total_bits == 32 && bb->buffer[0] == 0xF0 && bb->buffer[1] == 0x90 && bb->buffer[2] == 0x80 && bb->buffer[3] == 0x80;
 616         printf("%s\n", ok?"OK":"FAILED");
 617         if(!ok) {
 618                 FLAC__bitbuffer_dump(bb, stdout);
 619                 return false;
 620         }
 621
 622         printf("testing utf8_uint64(0x00000000001FFFFF)... ");
 623         FLAC__bitbuffer_clear(bb);
 624         FLAC__bitbuffer_write_utf8_uint64(bb, 0x00000000001FFFFF);
 625         ok = bb->total_bits == 32 && bb->buffer[0] == 0xF7 && bb->buffer[1] == 0xBF && bb->buffer[2] == 0xBF && bb->buffer[3] == 0xBF;
 626         printf("%s\n", ok?"OK":"FAILED");
 627         if(!ok) {
 628                 FLAC__bitbuffer_dump(bb, stdout);
 629                 return false;
 630         }
 631
 632         printf("testing utf8_uint64(0x0000000000200000)... ");
 633         FLAC__bitbuffer_clear(bb);
 634         FLAC__bitbuffer_write_utf8_uint64(bb, 0x0000000000200000);
 635         ok = bb->total_bits == 40 && bb->buffer[0] == 0xF8 && bb->buffer[1] == 0x88 && bb->buffer[2] == 0x80 && bb->buffer[3] == 0x80 && bb->buffer[4] == 0x80;
 636         printf("%s\n", ok?"OK":"FAILED");
 637         if(!ok) {
 638                 FLAC__bitbuffer_dump(bb, stdout);
 639                 return false;
 640         }
 641
 642         printf("testing utf8_uint64(0x0000000003FFFFFF)... ");
 643         FLAC__bitbuffer_clear(bb);
 644         FLAC__bitbuffer_write_utf8_uint64(bb, 0x0000000003FFFFFF);
 645         ok = bb->total_bits == 40 && bb->buffer[0] == 0xFB && bb->buffer[1] == 0xBF && bb->buffer[2] == 0xBF && bb->buffer[3] == 0xBF && bb->buffer[4] == 0xBF;
 646         printf("%s\n", ok?"OK":"FAILED");
 647         if(!ok) {
 648                 FLAC__bitbuffer_dump(bb, stdout);
 649                 return false;
 650         }
 651
 652         printf("testing utf8_uint64(0x0000000004000000)... ");
 653         FLAC__bitbuffer_clear(bb);
 654         FLAC__bitbuffer_write_utf8_uint64(bb, 0x0000000004000000);
 655         ok = bb->total_bits == 48 && bb->buffer[0] == 0xFC && bb->buffer[1] == 0x84 && bb->buffer[2] == 0x80 && bb->buffer[3] == 0x80 && bb->buffer[4] == 0x80 && bb->buffer[5] == 0x80;
 656         printf("%s\n", ok?"OK":"FAILED");
 657         if(!ok) {
 658                 FLAC__bitbuffer_dump(bb, stdout);
 659                 return false;
 660         }
 661
 662         printf("testing utf8_uint64(0x000000007FFFFFFF)... ");
 663         FLAC__bitbuffer_clear(bb);
 664         FLAC__bitbuffer_write_utf8_uint64(bb, 0x000000007FFFFFFF);
 665         ok = bb->total_bits == 48 && bb->buffer[0] == 0xFD && bb->buffer[1] == 0xBF && bb->buffer[2] == 0xBF && bb->buffer[3] == 0xBF && bb->buffer[4] == 0xBF && bb->buffer[5] == 0xBF;
 666         printf("%s\n", ok?"OK":"FAILED");
 667         if(!ok) {
 668                 FLAC__bitbuffer_dump(bb, stdout);
 669                 return false;
 670         }
 671
 672         printf("testing utf8_uint64(0x0000000080000000)... ");
 673         FLAC__bitbuffer_clear(bb);
 674         FLAC__bitbuffer_write_utf8_uint64(bb, 0x0000000080000000);
 675         ok = bb->total_bits == 56 && bb->buffer[0] == 0xFE && bb->buffer[1] == 0x82 && bb->buffer[2] == 0x80 && bb->buffer[3] == 0x80 && bb->buffer[4] == 0x80 && bb->buffer[5] == 0x80 && bb->buffer[6] == 0x80;
 676         printf("%s\n", ok?"OK":"FAILED");
 677         if(!ok) {
 678                 FLAC__bitbuffer_dump(bb, stdout);
 679                 return false;
 680         }
 681
 682         printf("testing utf8_uint64(0x0000000FFFFFFFFF)... ");
 683         FLAC__bitbuffer_clear(bb);
 684         FLAC__bitbuffer_write_utf8_uint64(bb, FLAC__U64L(0x0000000FFFFFFFFF));
 685         ok = bb->total_bits == 56 && bb->buffer[0] == 0xFE && bb->buffer[1] == 0xBF && bb->buffer[2] == 0xBF && bb->buffer[3] == 0xBF && bb->buffer[4] == 0xBF && bb->buffer[5] == 0xBF && bb->buffer[6] == 0xBF;
 686         printf("%s\n", ok?"OK":"FAILED");
 687         if(!ok) {
 688                 FLAC__bitbuffer_dump(bb, stdout);
 689                 return false;
 690         }
 691
 692         printf("testing grow... ");
 693         FLAC__bitbuffer_clear(bb);
 694         FLAC__bitbuffer_write_raw_uint32(bb, 0xa, 4);
 695         j = bb->capacity;
 696         for(i = 0; i < j; i++)
 697                 FLAC__bitbuffer_write_raw_uint32(bb, 0xaa, 8);
 698         ok = bb->total_bits = i*8+4 && bb->buffer[0] == 0xaa && bb->buffer[i] == 0xa;
 699         printf("%s\n", ok?"OK":"FAILED");
 700         if(!ok) {
 701                 FLAC__bitbuffer_dump(bb, stdout);
 702                 return false;
 703         }
 704         printf("capacity = %u\n", bb->capacity);
 705
 706         printf("testing clone... ");
 707         ok = FLAC__bitbuffer_clone(bbcopy, bb);
 708         if(!ok) {
 709                 printf("FAILED\n");
 710                 FLAC__bitbuffer_dump(bb, stdout);
 711                 FLAC__bitbuffer_dump(bbcopy, stdout);
 712                 return false;
 713         }
 714         if(bb->blurbs != bbcopy->blurbs) {
 715                 printf("FAILED byte count %u != %u\n", bb->blurbs, bbcopy->blurbs);
 716                 FLAC__bitbuffer_dump(bb, stdout);
 717                 FLAC__bitbuffer_dump(bbcopy, stdout);
 718                 return false;
 719         }
 720         if(bb->bits != bbcopy->bits) {
 721                 printf("FAILED bit count %u != %u\n", bb->bits, bbcopy->bits);
 722                 FLAC__bitbuffer_dump(bb, stdout);
 723                 FLAC__bitbuffer_dump(bbcopy, stdout);
 724                 return false;
 725         }
 726         if(bb->total_bits != bbcopy->total_bits) {
 727                 printf("FAILED total_bits count %u != %u\n", bb->total_bits, bbcopy->total_bits);
 728                 FLAC__bitbuffer_dump(bb, stdout);
 729                 FLAC__bitbuffer_dump(bbcopy, stdout);
 730                 return false;
 731         }
 732         if(memcmp(bb->buffer, bbcopy->buffer, sizeof(FLAC__byte)*bb->capacity) != 0) {
 733                 printf("FAILED pattern match\n");
 734                 FLAC__bitbuffer_dump(bb, stdout);
 735                 FLAC__bitbuffer_dump(bbcopy, stdout);
 736                 return false;
 737         }
 738         printf("OK\n");
 739
 740         printf("testing free... ");
 741         FLAC__bitbuffer_free(bb);
 742         FLAC__bitbuffer_free(bbcopy);
 743         printf("OK\n");
 744
 745         printf("testing delete... ");
 746         FLAC__bitbuffer_delete(bb);
 747         FLAC__bitbuffer_delete(bb_zero);
 748         FLAC__bitbuffer_delete(bb_one);
 749         FLAC__bitbuffer_delete(bbcopy);
 750         printf("OK\n");
 751
 752         printf("\nPASSED!\n");
 753         return true;
 754 }