src/test_libFLAC/bitbuffer.c

   1 /* test_libFLAC - Unit tester for libFLAC
   2  * Copyright (C) 2000,2001,2002  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 /*
  25  * WATCHOUT!  Since FLAC__BitBuffer is a private structure, we use a copy of
  26  * the definition here to get at the internals.  Make sure this is kept up
  27  * to date with what is in ../libFLAC/bitbuffer.c
  28  */
  29 struct FLAC__BitBuffer {
  30         FLAC__blurb *buffer;
  31         unsigned capacity; /* in blurbs */
  32         unsigned blurbs, bits;
  33         unsigned total_bits; /* must always == FLAC__BITS_PER_BLURB*blurbs+bits */
  34         unsigned consumed_blurbs, consumed_bits;
  35         unsigned total_consumed_bits; /* must always == FLAC__BITS_PER_BLURB*consumed_blurbs+consumed_bits */
  36         FLAC__uint16 read_crc16;
  37 #if FLAC__BITS_PER_BLURB == 32
  38         unsigned crc16_align;
  39 #endif
  40         FLAC__blurb save_head, save_tail;
  41 };
  42
  43
  44 static FLAC__bool dummy_read_callback(FLAC__byte buffer[], unsigned *bytes, void *client_data)
  45 {
  46         (void)buffer, (void)bytes, (void)client_data;
  47         return true;
  48 }
  49
  50 FLAC__bool test_bitbuffer()
  51 {
  52         FLAC__BitBuffer *bb, *bb_zero, *bb_one, *bbcopy;
  53         FLAC__bool ok;
  54         unsigned i, j;
  55         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 };
  56
  57         FLAC__ASSERT(FLAC__BITS_PER_BLURB == 8);
  58
  59         printf("\n+++ libFLAC unit test: bitbuffer\n\n");
  60
  61         printf("testing new... OK\n");
  62         bb = FLAC__bitbuffer_new();
  63         bb_zero = FLAC__bitbuffer_new();
  64         bb_one = FLAC__bitbuffer_new();
  65         bbcopy = FLAC__bitbuffer_new();
  66
  67         printf("testing init... OK\n");
  68         FLAC__bitbuffer_init(bb);
  69         FLAC__bitbuffer_init(bb_zero);
  70         FLAC__bitbuffer_init(bb_one);
  71         FLAC__bitbuffer_init(bbcopy);
  72
  73         printf("testing clear... ");
  74         ok = FLAC__bitbuffer_clear(bb) && FLAC__bitbuffer_clear(bb_zero) && FLAC__bitbuffer_clear(bb_one) && FLAC__bitbuffer_clear(bbcopy);
  75         printf("%s\n", ok?"OK":"FAILED");
  76         if(!ok)
  77                 return false;
  78
  79         printf("setting up bb_one... ");
  80         ok = FLAC__bitbuffer_write_raw_uint32(bb_one, 1, 7) && FLAC__bitbuffer_read_raw_uint32(bb_one, &i, 6, dummy_read_callback, 0);
  81         printf("%s\n", ok?"OK":"FAILED");
  82         if(!ok)
  83                 return false;
  84         FLAC__bitbuffer_dump(bb_one, stdout);
  85
  86         printf("capacity = %u\n", bb->capacity);
  87
  88         printf("testing zeroes, raw_uint32*... ");
  89         ok =
  90                 FLAC__bitbuffer_write_raw_uint32(bb, 0x1, 1) &&
  91                 FLAC__bitbuffer_write_raw_uint32(bb, 0x1, 2) &&
  92                 FLAC__bitbuffer_write_raw_uint32(bb, 0xa, 5) &&
  93                 FLAC__bitbuffer_write_raw_uint32(bb, 0xf0, 8) &&
  94                 FLAC__bitbuffer_write_raw_uint32(bb, 0x2aa, 10) &&
  95                 FLAC__bitbuffer_write_raw_uint32(bb, 0xf, 4) &&
  96                 FLAC__bitbuffer_write_raw_uint32(bb, 0xaaaaaaaa, 32) &&
  97                 FLAC__bitbuffer_write_zeroes(bb, 4) &&
  98                 FLAC__bitbuffer_write_raw_uint32(bb, 0x3, 2) &&
  99                 FLAC__bitbuffer_write_zeroes(bb, 8) &&
 100                 FLAC__bitbuffer_write_raw_uint64(bb, 0xaaaaaaaadeadbeef, 64) &&
 101                 FLAC__bitbuffer_write_raw_uint32(bb, 0xace, 12)
 102         ;
 103         if(!ok) {
 104                 printf("FAILED\n");
 105                 FLAC__bitbuffer_dump(bb, stdout);
 106                 return false;
 107         }
 108         if(bb->blurbs != sizeof(test_pattern1)) {
 109                 printf("FAILED byte count %u != %u\n", bb->blurbs, sizeof(test_pattern1));
 110                 FLAC__bitbuffer_dump(bb, stdout);
 111                 return false;
 112         }
 113         if(bb->bits != 0) {
 114                 printf("FAILED bit count %u != 0\n", bb->bits);
 115                 FLAC__bitbuffer_dump(bb, stdout);
 116                 return false;
 117         }
 118         if(bb->total_bits != 8*bb->blurbs+bb->bits) {
 119                 printf("FAILED total_bits count %u != %u (%u:%u)\n", bb->total_bits, 8*bb->blurbs+bb->bits, bb->blurbs, bb->bits);
 120                 FLAC__bitbuffer_dump(bb, stdout);
 121                 return false;
 122         }
 123         if(memcmp(bb->buffer, test_pattern1, sizeof(FLAC__byte)*sizeof(test_pattern1)) != 0) {
 124                 printf("FAILED pattern match\n");
 125                 FLAC__bitbuffer_dump(bb, stdout);
 126                 return false;
 127         }
 128         printf("OK\n");
 129         FLAC__bitbuffer_dump(bb, stdout);
 130
 131         printf("testing raw_uint32 some more... ");
 132         ok = FLAC__bitbuffer_write_raw_uint32(bb, 0x3d, 6);
 133         if(!ok) {
 134                 printf("FAILED\n");
 135                 FLAC__bitbuffer_dump(bb, stdout);
 136                 return false;
 137         }
 138         if(bb->blurbs != sizeof(test_pattern1)) {
 139                 printf("FAILED byte count %u != %u\n", bb->blurbs, sizeof(test_pattern1));
 140                 FLAC__bitbuffer_dump(bb, stdout);
 141                 return false;
 142         }
 143         if(bb->bits != 6) {
 144                 printf("FAILED bit count %u != 6\n", bb->bits);
 145                 FLAC__bitbuffer_dump(bb, stdout);
 146                 return false;
 147         }
 148         if(bb->total_bits != 8*bb->blurbs+bb->bits) {
 149                 printf("FAILED total_bits count %u != %u (%u:%u)\n", bb->total_bits, 8*bb->blurbs+bb->bits, bb->blurbs, bb->bits);
 150                 FLAC__bitbuffer_dump(bb, stdout);
 151                 return false;
 152         }
 153         if(memcmp(bb->buffer, test_pattern1, sizeof(FLAC__byte)*sizeof(test_pattern1)) != 0 || bb->buffer[bb->blurbs] != 0x3d) {
 154                 printf("FAILED pattern match\n");
 155                 FLAC__bitbuffer_dump(bb, stdout);
 156                 return false;
 157         }
 158         printf("OK\n");
 159         FLAC__bitbuffer_dump(bb, stdout);
 160
 161         printf("testing concatenate_aligned (bb_zero)... ");
 162         ok = FLAC__bitbuffer_concatenate_aligned(bb, bb_zero);
 163         if(!ok) {
 164                 printf("FAILED\n");
 165                 FLAC__bitbuffer_dump(bb, stdout);
 166                 return false;
 167         }
 168         if(bb->blurbs != sizeof(test_pattern1)) {
 169                 printf("FAILED byte count %u != %u\n", bb->blurbs, sizeof(test_pattern1));
 170                 FLAC__bitbuffer_dump(bb, stdout);
 171                 return false;
 172         }
 173         if(bb->bits != 6) {
 174                 printf("FAILED bit count %u != 6\n", bb->bits);
 175                 FLAC__bitbuffer_dump(bb, stdout);
 176                 return false;
 177         }
 178         if(bb->total_bits != 8*bb->blurbs+bb->bits) {
 179                 printf("FAILED total_bits count %u != %u (%u:%u)\n", bb->total_bits, 8*bb->blurbs+bb->bits, bb->blurbs, bb->bits);
 180                 FLAC__bitbuffer_dump(bb, stdout);
 181                 return false;
 182         }
 183         if(memcmp(bb->buffer, test_pattern1, sizeof(FLAC__byte)*sizeof(test_pattern1)) != 0 || bb->buffer[bb->blurbs] != 0x3d) {
 184                 printf("FAILED pattern match\n");
 185                 FLAC__bitbuffer_dump(bb, stdout);
 186                 return false;
 187         }
 188         printf("OK\n");
 189         FLAC__bitbuffer_dump(bb, stdout);
 190
 191         printf("testing concatenate_aligned (bb_one)... ");
 192         ok = FLAC__bitbuffer_concatenate_aligned(bb, bb_one);
 193         if(!ok) {
 194                 printf("FAILED\n");
 195                 FLAC__bitbuffer_dump(bb, stdout);
 196                 return false;
 197         }
 198         if(bb->blurbs != sizeof(test_pattern1)) {
 199                 printf("FAILED byte count %u != %u\n", bb->blurbs, sizeof(test_pattern1));
 200                 FLAC__bitbuffer_dump(bb, stdout);
 201                 return false;
 202         }
 203         if(bb->bits != 7) {
 204                 printf("FAILED bit count %u != 7\n", bb->bits);
 205                 FLAC__bitbuffer_dump(bb, stdout);
 206                 return false;
 207         }
 208         if(bb->total_bits != 8*bb->blurbs+bb->bits) {
 209                 printf("FAILED total_bits count %u != %u (%u:%u)\n", bb->total_bits, 8*bb->blurbs+bb->bits, bb->blurbs, bb->bits);
 210                 FLAC__bitbuffer_dump(bb, stdout);
 211                 return false;
 212         }
 213         if(memcmp(bb->buffer, test_pattern1, sizeof(FLAC__byte)*sizeof(test_pattern1)) != 0 || bb->buffer[bb->blurbs] != 0x7b) {
 214                 printf("FAILED pattern match\n");
 215                 FLAC__bitbuffer_dump(bb, stdout);
 216                 return false;
 217         }
 218         printf("OK\n");
 219         FLAC__bitbuffer_dump(bb, stdout);
 220
 221         printf("testing concatenate_aligned (bb_one again)... ");
 222         (void)FLAC__bitbuffer_write_raw_uint32(bb_one, 1, 1);
 223         (void)FLAC__bitbuffer_read_raw_uint32(bb_one, &i, 1, dummy_read_callback, 0);
 224         ok = FLAC__bitbuffer_concatenate_aligned(bb, bb_one);
 225         if(!ok) {
 226                 printf("FAILED\n");
 227                 FLAC__bitbuffer_dump(bb, stdout);
 228                 return false;
 229         }
 230         if(bb->blurbs != sizeof(test_pattern1)+1) {
 231                 printf("FAILED byte count %u != %u\n", bb->blurbs, sizeof(test_pattern1)+1);
 232                 FLAC__bitbuffer_dump(bb, stdout);
 233                 return false;
 234         }
 235         if(bb->bits != 0) {
 236                 printf("FAILED bit count %u != 0\n", bb->bits);
 237                 FLAC__bitbuffer_dump(bb, stdout);
 238                 return false;
 239         }
 240         if(bb->total_bits != 8*bb->blurbs+bb->bits) {
 241                 printf("FAILED total_bits count %u != %u (%u:%u)\n", bb->total_bits, 8*bb->blurbs+bb->bits, bb->blurbs, bb->bits);
 242                 FLAC__bitbuffer_dump(bb, stdout);
 243                 return false;
 244         }
 245         if(memcmp(bb->buffer, test_pattern1, sizeof(FLAC__byte)*sizeof(test_pattern1)) != 0 || bb->buffer[bb->blurbs-1] != 0xf7) {
 246                 printf("FAILED pattern match\n");
 247                 FLAC__bitbuffer_dump(bb, stdout);
 248                 return false;
 249         }
 250         printf("OK\n");
 251         FLAC__bitbuffer_dump(bb, stdout);
 252
 253         printf("testing concatenate_aligned (bb_four)... ");
 254         (void)FLAC__bitbuffer_clear(bb_one);
 255         (void)FLAC__bitbuffer_write_raw_uint32(bb_one, 8, 4);
 256         ok = FLAC__bitbuffer_concatenate_aligned(bb, bb_one);
 257         if(!ok) {
 258                 printf("FAILED\n");
 259                 FLAC__bitbuffer_dump(bb, stdout);
 260                 return false;
 261         }
 262         if(bb->blurbs != sizeof(test_pattern1)+1) {
 263                 printf("FAILED byte count %u != %u\n", bb->blurbs, sizeof(test_pattern1)+1);
 264                 FLAC__bitbuffer_dump(bb, stdout);
 265                 return false;
 266         }
 267         if(bb->bits != 4) {
 268                 printf("FAILED bit count %u != 4\n", bb->bits);
 269                 FLAC__bitbuffer_dump(bb, stdout);
 270                 return false;
 271         }
 272         if(bb->total_bits != 8*bb->blurbs+bb->bits) {
 273                 printf("FAILED total_bits count %u != %u (%u:%u)\n", bb->total_bits, 8*bb->blurbs+bb->bits, bb->blurbs, bb->bits);
 274                 FLAC__bitbuffer_dump(bb, stdout);
 275                 return false;
 276         }
 277         if(memcmp(bb->buffer, test_pattern1, sizeof(FLAC__byte)*sizeof(test_pattern1)) != 0 || bb->buffer[bb->blurbs] != 0x08) {
 278                 printf("FAILED pattern match\n");
 279                 FLAC__bitbuffer_dump(bb, stdout);
 280                 return false;
 281         }
 282         printf("OK\n");
 283         FLAC__bitbuffer_dump(bb, stdout);
 284
 285         printf("testing concatenate_aligned (bb_eight)... ");
 286         (void)FLAC__bitbuffer_read_raw_uint32(bb_one, &i, 4, dummy_read_callback, 0);
 287         (void)FLAC__bitbuffer_write_raw_uint32(bb_one, 0xaa, 8);
 288         ok = FLAC__bitbuffer_concatenate_aligned(bb, bb_one);
 289         if(!ok) {
 290                 printf("FAILED\n");
 291                 FLAC__bitbuffer_dump(bb, stdout);
 292                 return false;
 293         }
 294         if(bb->blurbs != sizeof(test_pattern1)+2) {
 295                 printf("FAILED byte count %u != %u\n", bb->blurbs, sizeof(test_pattern1)+2);
 296                 FLAC__bitbuffer_dump(bb, stdout);
 297                 return false;
 298         }
 299         if(bb->bits != 4) {
 300                 printf("FAILED bit count %u != 4\n", bb->bits);
 301                 FLAC__bitbuffer_dump(bb, stdout);
 302                 return false;
 303         }
 304         if(bb->total_bits != 8*bb->blurbs+bb->bits) {
 305                 printf("FAILED total_bits count %u != %u (%u:%u)\n", bb->total_bits, 8*bb->blurbs+bb->bits, bb->blurbs, bb->bits);
 306                 FLAC__bitbuffer_dump(bb, stdout);
 307                 return false;
 308         }
 309         if(memcmp(bb->buffer, test_pattern1, sizeof(FLAC__byte)*sizeof(test_pattern1)) != 0 || bb->buffer[bb->blurbs-1] != 0x8a || bb->buffer[bb->blurbs] != 0x0a) {
 310                 printf("FAILED pattern match\n");
 311                 FLAC__bitbuffer_dump(bb, stdout);
 312                 return false;
 313         }
 314         printf("OK\n");
 315         FLAC__bitbuffer_dump(bb, stdout);
 316
 317         printf("testing concatenate_aligned (bb_seventeen)... ");
 318         (void)FLAC__bitbuffer_write_raw_uint32(bb_one, 0x155, 9);
 319         ok = FLAC__bitbuffer_concatenate_aligned(bb, bb_one);
 320         if(!ok) {
 321                 printf("FAILED\n");
 322                 FLAC__bitbuffer_dump(bb, stdout);
 323                 return false;
 324         }
 325         if(bb->blurbs != sizeof(test_pattern1)+4) {
 326                 printf("FAILED byte count %u != %u\n", bb->blurbs, sizeof(test_pattern1)+4);
 327                 FLAC__bitbuffer_dump(bb, stdout);
 328                 return false;
 329         }
 330         if(bb->bits != 5) {
 331                 printf("FAILED bit count %u != 5\n", bb->bits);
 332                 FLAC__bitbuffer_dump(bb, stdout);
 333                 return false;
 334         }
 335         if(bb->total_bits != 8*bb->blurbs+bb->bits) {
 336                 printf("FAILED total_bits count %u != %u (%u:%u)\n", bb->total_bits, 8*bb->blurbs+bb->bits, bb->blurbs, bb->bits);
 337                 FLAC__bitbuffer_dump(bb, stdout);
 338                 return false;
 339         }
 340         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) {
 341                 printf("FAILED pattern match\n");
 342                 FLAC__bitbuffer_dump(bb, stdout);
 343                 return false;
 344         }
 345         printf("OK\n");
 346         FLAC__bitbuffer_dump(bb, stdout);
 347
 348         printf("testing utf8_uint32(0x00000000)... ");
 349         FLAC__bitbuffer_clear(bb);
 350         FLAC__bitbuffer_write_utf8_uint32(bb, 0x00000000);
 351         ok = bb->total_bits == 8 && bb->buffer[0] == 0;
 352         printf("%s\n", ok?"OK":"FAILED");
 353         if(!ok) {
 354                 FLAC__bitbuffer_dump(bb, stdout);
 355                 return false;
 356         }
 357
 358         printf("testing utf8_uint32(0x0000007F)... ");
 359         FLAC__bitbuffer_clear(bb);
 360         FLAC__bitbuffer_write_utf8_uint32(bb, 0x0000007F);
 361         ok = bb->total_bits == 8 && bb->buffer[0] == 0x7F;
 362         printf("%s\n", ok?"OK":"FAILED");
 363         if(!ok) {
 364                 FLAC__bitbuffer_dump(bb, stdout);
 365                 return false;
 366         }
 367
 368         printf("testing utf8_uint32(0x00000080)... ");
 369         FLAC__bitbuffer_clear(bb);
 370         FLAC__bitbuffer_write_utf8_uint32(bb, 0x00000080);
 371         ok = bb->total_bits == 16 && bb->buffer[0] == 0xC2 && bb->buffer[1] == 0x80;
 372         printf("%s\n", ok?"OK":"FAILED");
 373         if(!ok) {
 374                 FLAC__bitbuffer_dump(bb, stdout);
 375                 return false;
 376         }
 377
 378         printf("testing utf8_uint32(0x000007FF)... ");
 379         FLAC__bitbuffer_clear(bb);
 380         FLAC__bitbuffer_write_utf8_uint32(bb, 0x000007FF);
 381         ok = bb->total_bits == 16 && bb->buffer[0] == 0xDF && bb->buffer[1] == 0xBF;
 382         printf("%s\n", ok?"OK":"FAILED");
 383         if(!ok) {
 384                 FLAC__bitbuffer_dump(bb, stdout);
 385                 return false;
 386         }
 387
 388         printf("testing utf8_uint32(0x00000800)... ");
 389         FLAC__bitbuffer_clear(bb);
 390         FLAC__bitbuffer_write_utf8_uint32(bb, 0x00000800);
 391         ok = bb->total_bits == 24 && bb->buffer[0] == 0xE0 && bb->buffer[1] == 0xA0 && bb->buffer[2] == 0x80;
 392         printf("%s\n", ok?"OK":"FAILED");
 393         if(!ok) {
 394                 FLAC__bitbuffer_dump(bb, stdout);
 395                 return false;
 396         }
 397
 398         printf("testing utf8_uint32(0x0000FFFF)... ");
 399         FLAC__bitbuffer_clear(bb);
 400         FLAC__bitbuffer_write_utf8_uint32(bb, 0x0000FFFF);
 401         ok = bb->total_bits == 24 && bb->buffer[0] == 0xEF && bb->buffer[1] == 0xBF && bb->buffer[2] == 0xBF;
 402         printf("%s\n", ok?"OK":"FAILED");
 403         if(!ok) {
 404                 FLAC__bitbuffer_dump(bb, stdout);
 405                 return false;
 406         }
 407
 408         printf("testing utf8_uint32(0x00010000)... ");
 409         FLAC__bitbuffer_clear(bb);
 410         FLAC__bitbuffer_write_utf8_uint32(bb, 0x00010000);
 411         ok = bb->total_bits == 32 && bb->buffer[0] == 0xF0 && bb->buffer[1] == 0x90 && bb->buffer[2] == 0x80 && bb->buffer[3] == 0x80;
 412         printf("%s\n", ok?"OK":"FAILED");
 413         if(!ok) {
 414                 FLAC__bitbuffer_dump(bb, stdout);
 415                 return false;
 416         }
 417
 418         printf("testing utf8_uint32(0x001FFFFF)... ");
 419         FLAC__bitbuffer_clear(bb);
 420         FLAC__bitbuffer_write_utf8_uint32(bb, 0x001FFFFF);
 421         ok = bb->total_bits == 32 && bb->buffer[0] == 0xF7 && bb->buffer[1] == 0xBF && bb->buffer[2] == 0xBF && bb->buffer[3] == 0xBF;
 422         printf("%s\n", ok?"OK":"FAILED");
 423         if(!ok) {
 424                 FLAC__bitbuffer_dump(bb, stdout);
 425                 return false;
 426         }
 427
 428         printf("testing utf8_uint32(0x00200000)... ");
 429         FLAC__bitbuffer_clear(bb);
 430         FLAC__bitbuffer_write_utf8_uint32(bb, 0x00200000);
 431         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;
 432         printf("%s\n", ok?"OK":"FAILED");
 433         if(!ok) {
 434                 FLAC__bitbuffer_dump(bb, stdout);
 435                 return false;
 436         }
 437
 438         printf("testing utf8_uint32(0x03FFFFFF)... ");
 439         FLAC__bitbuffer_clear(bb);
 440         FLAC__bitbuffer_write_utf8_uint32(bb, 0x03FFFFFF);
 441         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;
 442         printf("%s\n", ok?"OK":"FAILED");
 443         if(!ok) {
 444                 FLAC__bitbuffer_dump(bb, stdout);
 445                 return false;
 446         }
 447
 448         printf("testing utf8_uint32(0x04000000)... ");
 449         FLAC__bitbuffer_clear(bb);
 450         FLAC__bitbuffer_write_utf8_uint32(bb, 0x04000000);
 451         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;
 452         printf("%s\n", ok?"OK":"FAILED");
 453         if(!ok) {
 454                 FLAC__bitbuffer_dump(bb, stdout);
 455                 return false;
 456         }
 457
 458         printf("testing utf8_uint32(0x7FFFFFFF)... ");
 459         FLAC__bitbuffer_clear(bb);
 460         FLAC__bitbuffer_write_utf8_uint32(bb, 0x7FFFFFFF);
 461         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;
 462         printf("%s\n", ok?"OK":"FAILED");
 463         if(!ok) {
 464                 FLAC__bitbuffer_dump(bb, stdout);
 465                 return false;
 466         }
 467
 468         printf("testing utf8_uint64(0x0000000000000000)... ");
 469         FLAC__bitbuffer_clear(bb);
 470         FLAC__bitbuffer_write_utf8_uint64(bb, 0x0000000000000000);
 471         ok = bb->total_bits == 8 && bb->buffer[0] == 0;
 472         printf("%s\n", ok?"OK":"FAILED");
 473         if(!ok) {
 474                 FLAC__bitbuffer_dump(bb, stdout);
 475                 return false;
 476         }
 477
 478         printf("testing utf8_uint64(0x000000000000007F)... ");
 479         FLAC__bitbuffer_clear(bb);
 480         FLAC__bitbuffer_write_utf8_uint64(bb, 0x000000000000007F);
 481         ok = bb->total_bits == 8 && bb->buffer[0] == 0x7F;
 482         printf("%s\n", ok?"OK":"FAILED");
 483         if(!ok) {
 484                 FLAC__bitbuffer_dump(bb, stdout);
 485                 return false;
 486         }
 487
 488         printf("testing utf8_uint64(0x0000000000000080)... ");
 489         FLAC__bitbuffer_clear(bb);
 490         FLAC__bitbuffer_write_utf8_uint64(bb, 0x0000000000000080);
 491         ok = bb->total_bits == 16 && bb->buffer[0] == 0xC2 && bb->buffer[1] == 0x80;
 492         printf("%s\n", ok?"OK":"FAILED");
 493         if(!ok) {
 494                 FLAC__bitbuffer_dump(bb, stdout);
 495                 return false;
 496         }
 497
 498         printf("testing utf8_uint64(0x00000000000007FF)... ");
 499         FLAC__bitbuffer_clear(bb);
 500         FLAC__bitbuffer_write_utf8_uint64(bb, 0x00000000000007FF);
 501         ok = bb->total_bits == 16 && bb->buffer[0] == 0xDF && bb->buffer[1] == 0xBF;
 502         printf("%s\n", ok?"OK":"FAILED");
 503         if(!ok) {
 504                 FLAC__bitbuffer_dump(bb, stdout);
 505                 return false;
 506         }
 507
 508         printf("testing utf8_uint64(0x0000000000000800)... ");
 509         FLAC__bitbuffer_clear(bb);
 510         FLAC__bitbuffer_write_utf8_uint64(bb, 0x0000000000000800);
 511         ok = bb->total_bits == 24 && bb->buffer[0] == 0xE0 && bb->buffer[1] == 0xA0 && bb->buffer[2] == 0x80;
 512         printf("%s\n", ok?"OK":"FAILED");
 513         if(!ok) {
 514                 FLAC__bitbuffer_dump(bb, stdout);
 515                 return false;
 516         }
 517
 518         printf("testing utf8_uint64(0x000000000000FFFF)... ");
 519         FLAC__bitbuffer_clear(bb);
 520         FLAC__bitbuffer_write_utf8_uint64(bb, 0x000000000000FFFF);
 521         ok = bb->total_bits == 24 && bb->buffer[0] == 0xEF && bb->buffer[1] == 0xBF && bb->buffer[2] == 0xBF;
 522         printf("%s\n", ok?"OK":"FAILED");
 523         if(!ok) {
 524                 FLAC__bitbuffer_dump(bb, stdout);
 525                 return false;
 526         }
 527
 528         printf("testing utf8_uint64(0x0000000000010000)... ");
 529         FLAC__bitbuffer_clear(bb);
 530         FLAC__bitbuffer_write_utf8_uint64(bb, 0x0000000000010000);
 531         ok = bb->total_bits == 32 && bb->buffer[0] == 0xF0 && bb->buffer[1] == 0x90 && bb->buffer[2] == 0x80 && bb->buffer[3] == 0x80;
 532         printf("%s\n", ok?"OK":"FAILED");
 533         if(!ok) {
 534                 FLAC__bitbuffer_dump(bb, stdout);
 535                 return false;
 536         }
 537
 538         printf("testing utf8_uint64(0x00000000001FFFFF)... ");
 539         FLAC__bitbuffer_clear(bb);
 540         FLAC__bitbuffer_write_utf8_uint64(bb, 0x00000000001FFFFF);
 541         ok = bb->total_bits == 32 && bb->buffer[0] == 0xF7 && bb->buffer[1] == 0xBF && bb->buffer[2] == 0xBF && bb->buffer[3] == 0xBF;
 542         printf("%s\n", ok?"OK":"FAILED");
 543         if(!ok) {
 544                 FLAC__bitbuffer_dump(bb, stdout);
 545                 return false;
 546         }
 547
 548         printf("testing utf8_uint64(0x0000000000200000)... ");
 549         FLAC__bitbuffer_clear(bb);
 550         FLAC__bitbuffer_write_utf8_uint64(bb, 0x0000000000200000);
 551         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;
 552         printf("%s\n", ok?"OK":"FAILED");
 553         if(!ok) {
 554                 FLAC__bitbuffer_dump(bb, stdout);
 555                 return false;
 556         }
 557
 558         printf("testing utf8_uint64(0x0000000003FFFFFF)... ");
 559         FLAC__bitbuffer_clear(bb);
 560         FLAC__bitbuffer_write_utf8_uint64(bb, 0x0000000003FFFFFF);
 561         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;
 562         printf("%s\n", ok?"OK":"FAILED");
 563         if(!ok) {
 564                 FLAC__bitbuffer_dump(bb, stdout);
 565                 return false;
 566         }
 567
 568         printf("testing utf8_uint64(0x0000000004000000)... ");
 569         FLAC__bitbuffer_clear(bb);
 570         FLAC__bitbuffer_write_utf8_uint64(bb, 0x0000000004000000);
 571         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;
 572         printf("%s\n", ok?"OK":"FAILED");
 573         if(!ok) {
 574                 FLAC__bitbuffer_dump(bb, stdout);
 575                 return false;
 576         }
 577
 578         printf("testing utf8_uint64(0x000000007FFFFFFF)... ");
 579         FLAC__bitbuffer_clear(bb);
 580         FLAC__bitbuffer_write_utf8_uint64(bb, 0x000000007FFFFFFF);
 581         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;
 582         printf("%s\n", ok?"OK":"FAILED");
 583         if(!ok) {
 584                 FLAC__bitbuffer_dump(bb, stdout);
 585                 return false;
 586         }
 587
 588         printf("testing utf8_uint64(0x0000000080000000)... ");
 589         FLAC__bitbuffer_clear(bb);
 590         FLAC__bitbuffer_write_utf8_uint64(bb, 0x0000000080000000);
 591         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;
 592         printf("%s\n", ok?"OK":"FAILED");
 593         if(!ok) {
 594                 FLAC__bitbuffer_dump(bb, stdout);
 595                 return false;
 596         }
 597
 598         printf("testing utf8_uint64(0x0000000FFFFFFFFF)... ");
 599         FLAC__bitbuffer_clear(bb);
 600         FLAC__bitbuffer_write_utf8_uint64(bb, 0x0000000FFFFFFFFF);
 601         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;
 602         printf("%s\n", ok?"OK":"FAILED");
 603         if(!ok) {
 604                 FLAC__bitbuffer_dump(bb, stdout);
 605                 return false;
 606         }
 607
 608         printf("testing grow... ");
 609         FLAC__bitbuffer_clear(bb);
 610         FLAC__bitbuffer_write_raw_uint32(bb, 0xa, 4);
 611         j = bb->capacity;
 612         for(i = 0; i < j; i++)
 613                 FLAC__bitbuffer_write_raw_uint32(bb, 0xaa, 8);
 614         ok = bb->total_bits = i*8+4 && bb->buffer[0] == 0xaa && bb->buffer[i] == 0xa;
 615         printf("%s\n", ok?"OK":"FAILED");
 616         if(!ok) {
 617                 FLAC__bitbuffer_dump(bb, stdout);
 618                 return false;
 619         }
 620         printf("capacity = %u\n", bb->capacity);
 621
 622         printf("testing clone... ");
 623         ok = FLAC__bitbuffer_clone(bbcopy, bb);
 624         if(!ok) {
 625                 printf("FAILED\n");
 626                 FLAC__bitbuffer_dump(bb, stdout);
 627                 FLAC__bitbuffer_dump(bbcopy, stdout);
 628                 return false;
 629         }
 630         if(bb->blurbs != bbcopy->blurbs) {
 631                 printf("FAILED byte count %u != %u\n", bb->blurbs, bbcopy->blurbs);
 632                 FLAC__bitbuffer_dump(bb, stdout);
 633                 FLAC__bitbuffer_dump(bbcopy, stdout);
 634                 return false;
 635         }
 636         if(bb->bits != bbcopy->bits) {
 637                 printf("FAILED bit count %u != %u\n", bb->bits, bbcopy->bits);
 638                 FLAC__bitbuffer_dump(bb, stdout);
 639                 FLAC__bitbuffer_dump(bbcopy, stdout);
 640                 return false;
 641         }
 642         if(bb->total_bits != bbcopy->total_bits) {
 643                 printf("FAILED total_bits count %u != %u\n", bb->total_bits, bbcopy->total_bits);
 644                 FLAC__bitbuffer_dump(bb, stdout);
 645                 FLAC__bitbuffer_dump(bbcopy, stdout);
 646                 return false;
 647         }
 648         if(memcmp(bb->buffer, bbcopy->buffer, sizeof(FLAC__byte)*bb->capacity) != 0) {
 649                 printf("FAILED pattern match\n");
 650                 FLAC__bitbuffer_dump(bb, stdout);
 651                 FLAC__bitbuffer_dump(bbcopy, stdout);
 652                 return false;
 653         }
 654         printf("OK\n");
 655
 656         printf("testing free... OK\n");
 657         FLAC__bitbuffer_free(bb);
 658         FLAC__bitbuffer_free(bbcopy);
 659
 660         printf("\nPASSED!\n");
 661         return true;
 662 }