tests/test_info.c

   1 ///////////////////////////////////////////////////////////////////////////////
   2 //
   3 /// \file       test_info.c
   4 /// \brief      Tests functions handling the lzma_info structure
   5 //
   6 //  Copyright (C) 2007 Lasse Collin
   7 //
   8 //  This library is free software; you can redistribute it and/or
   9 //  modify it under the terms of the GNU Lesser General Public
  10 //  License as published by the Free Software Foundation; either
  11 //  version 2.1 of the License, or (at your option) any later version.
  12 //
  13 //  This library is distributed in the hope that it will be useful,
  14 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16 //  Lesser General Public License for more details.
  17 //
  18 ///////////////////////////////////////////////////////////////////////////////
  19
  20 #include "tests.h"
  21
  22
  23 static lzma_info *info = NULL;
  24 static lzma_info_iter iter;
  25
  26 static lzma_vli stream_start = 0;
  27 static lzma_vli header_metadata_size = LZMA_VLI_VALUE_UNKNOWN;
  28 static lzma_vli total_size = LZMA_VLI_VALUE_UNKNOWN;
  29 static lzma_vli uncompressed_size = LZMA_VLI_VALUE_UNKNOWN;
  30 static lzma_vli footer_metadata_size = LZMA_VLI_VALUE_UNKNOWN;
  31
  32 static lzma_index my_index[3] = {
  33         { 22, 33, my_index + 1 },
  34         { 44, 55, my_index + 2 },
  35         { 66, 77, NULL },
  36 };
  37
  38 static lzma_metadata my_metadata = {
  39         .header_metadata_size = 11,
  40         .total_size = 22 + 44 + 66,
  41         .uncompressed_size = 33 + 55 + 77,
  42         .index = my_index,
  43         .extra = NULL,
  44 };
  45
  46
  47 static void
  48 reset(void)
  49 {
  50         expect(lzma_info_init(info, NULL) == info);
  51         stream_start = 0;
  52         header_metadata_size = LZMA_VLI_VALUE_UNKNOWN;
  53         total_size = LZMA_VLI_VALUE_UNKNOWN;
  54         uncompressed_size = LZMA_VLI_VALUE_UNKNOWN;
  55         footer_metadata_size = LZMA_VLI_VALUE_UNKNOWN;
  56 }
  57
  58
  59 static void
  60 validate(void)
  61 {
  62         expect(lzma_info_size_get(info, LZMA_INFO_STREAM_START)
  63                         == stream_start);
  64         expect(lzma_info_size_get(info, LZMA_INFO_HEADER_METADATA)
  65                         == header_metadata_size);
  66         expect(lzma_info_size_get(info, LZMA_INFO_TOTAL) == total_size);
  67         expect(lzma_info_size_get(info, LZMA_INFO_UNCOMPRESSED)
  68                         == uncompressed_size);
  69         expect(lzma_info_size_get(info, LZMA_INFO_FOOTER_METADATA)
  70                         == footer_metadata_size);
  71 }
  72
  73
  74 static void
  75 test1(void)
  76 {
  77         // Basics
  78         expect(lzma_info_size_set(info, LZMA_INFO_STREAM_START,
  79                         stream_start = 1234) == LZMA_OK);
  80         validate();
  81         expect(lzma_info_size_set(info, LZMA_INFO_HEADER_METADATA,
  82                         header_metadata_size = 2345) == LZMA_OK);
  83         validate();
  84         expect(lzma_info_size_set(info, LZMA_INFO_TOTAL, total_size = 3456)
  85                         == LZMA_OK);
  86         validate();
  87         expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED,
  88                         uncompressed_size = 4567) == LZMA_OK);
  89         validate();
  90         expect(lzma_info_size_set(info, LZMA_INFO_FOOTER_METADATA,
  91                         footer_metadata_size = 5432) == LZMA_OK);
  92         validate();
  93
  94         // Not everything allow zero size
  95         reset();
  96         expect(lzma_info_size_set(info, LZMA_INFO_STREAM_START,
  97                         stream_start = 0) == LZMA_OK);
  98         expect(lzma_info_size_set(info, LZMA_INFO_HEADER_METADATA,
  99                         header_metadata_size = 0) == LZMA_OK);
 100         expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED,
 101                         uncompressed_size = 0) == LZMA_OK);
 102         validate();
 103
 104         reset();
 105         expect(lzma_info_size_set(info, LZMA_INFO_TOTAL, 0)
 106                         == LZMA_PROG_ERROR);
 107
 108         reset();
 109         expect(lzma_info_size_set(info, LZMA_INFO_FOOTER_METADATA, 0)
 110                         == LZMA_PROG_ERROR);
 111
 112         // Invalid sizes
 113         reset();
 114         expect(lzma_info_size_set(info, LZMA_INFO_STREAM_START,
 115                         LZMA_VLI_VALUE_MAX + 1) == LZMA_PROG_ERROR);
 116         reset();
 117         expect(lzma_info_size_set(info, LZMA_INFO_HEADER_METADATA,
 118                         LZMA_VLI_VALUE_MAX + 1) == LZMA_PROG_ERROR);
 119         reset();
 120         expect(lzma_info_size_set(info, LZMA_INFO_TOTAL,
 121                         LZMA_VLI_VALUE_MAX + 1) == LZMA_PROG_ERROR);
 122         reset();
 123         expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED,
 124                         LZMA_VLI_VALUE_MAX + 1) == LZMA_PROG_ERROR);
 125         reset();
 126         expect(lzma_info_size_set(info, LZMA_INFO_FOOTER_METADATA,
 127                         LZMA_VLI_VALUE_MAX + 1) == LZMA_PROG_ERROR);
 128
 129         reset();
 130 }
 131
 132
 133 static bool
 134 test2_helper(lzma_vli *num, lzma_info_size type)
 135 {
 136         expect(lzma_info_size_set(info, type, *num = 1234) == LZMA_OK);
 137         validate();
 138         const bool ret = lzma_info_size_set(info, type, 4321) != LZMA_OK;
 139         reset();
 140         return ret;
 141 }
 142
 143
 144 static void
 145 test2(void)
 146 {
 147         // Excluding start offset of Stream, once a size has been set,
 148         // trying to set some other known value fails.
 149         expect(!test2_helper(&stream_start, LZMA_INFO_STREAM_START));
 150         expect(test2_helper(&header_metadata_size, LZMA_INFO_HEADER_METADATA));
 151         expect(test2_helper(&total_size, LZMA_INFO_TOTAL));
 152         expect(test2_helper(&uncompressed_size, LZMA_INFO_UNCOMPRESSED));
 153         expect(test2_helper(&footer_metadata_size, LZMA_INFO_FOOTER_METADATA));
 154 }
 155
 156
 157 static void
 158 test3_init(void)
 159 {
 160         reset();
 161         lzma_info_iter_begin(info, &iter);
 162         expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
 163 }
 164
 165
 166 static void
 167 test3(void)
 168 {
 169         // Setting the same sizes multiple times for the same Index Record
 170         // is OK, but the values must always be the same.
 171         test3_init();
 172         expect(lzma_info_index_count_get(info) == 1);
 173         expect(lzma_info_iter_set(&iter, 1234, 2345) == LZMA_OK);
 174         expect(lzma_info_index_count_get(info) == 1);
 175         expect(lzma_info_iter_set(&iter, 1234, 2345) == LZMA_OK);
 176         expect(lzma_info_index_count_get(info) == 1);
 177         expect(lzma_info_iter_set(&iter, 1111, 2345) == LZMA_DATA_ERROR);
 178
 179         // Cannot finish an empty Index.
 180         test3_init();
 181         expect(lzma_info_index_finish(info) == LZMA_DATA_ERROR);
 182
 183         test3_init();
 184         expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
 185         expect(lzma_info_index_count_get(info) == 2);
 186         expect(lzma_info_iter_set(&iter, 1234, 2345) == LZMA_OK);
 187         expect(lzma_info_index_count_get(info) == 2);
 188         expect(lzma_info_index_finish(info) == LZMA_DATA_ERROR);
 189
 190         test3_init();
 191         expect(lzma_info_iter_set(&iter, 1234, 2345) == LZMA_OK);
 192         expect(lzma_info_index_count_get(info) == 1);
 193         expect(lzma_info_index_finish(info) == LZMA_OK);
 194         expect(lzma_info_size_set(info, LZMA_INFO_TOTAL, 1234) == LZMA_OK);
 195         expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED, 2345)
 196                         == LZMA_OK);
 197         expect(lzma_info_size_set(info, LZMA_INFO_TOTAL, 1111)
 198                         == LZMA_DATA_ERROR);
 199
 200         test3_init();
 201         expect(lzma_info_iter_set(&iter, 1234, 2345) == LZMA_OK);
 202         expect(lzma_info_index_count_get(info) == 1);
 203         expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
 204         expect(lzma_info_index_count_get(info) == 2);
 205         expect(lzma_info_iter_set(&iter, 4321, 5432) == LZMA_OK);
 206         expect(lzma_info_index_count_get(info) == 2);
 207         expect(lzma_info_index_finish(info) == LZMA_OK);
 208         expect(lzma_info_size_set(info, LZMA_INFO_TOTAL, 1234 + 4321)
 209                         == LZMA_OK);
 210         expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED, 2345 + 5432)
 211                         == LZMA_OK);
 212         expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED, 1111)
 213                         == LZMA_DATA_ERROR);
 214
 215         test3_init();
 216         expect(lzma_info_size_set(info, LZMA_INFO_TOTAL, 1234 + 4321)
 217                         == LZMA_OK);
 218         expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED, 2345 + 5432)
 219                         == LZMA_OK);
 220         expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED, 1111)
 221                         == LZMA_DATA_ERROR);
 222         expect(lzma_info_iter_set(&iter, 1234, 2345) == LZMA_OK);
 223         expect(lzma_info_index_count_get(info) == 1);
 224         expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
 225         expect(lzma_info_index_count_get(info) == 2);
 226         expect(lzma_info_iter_set(&iter, 4321, 5432) == LZMA_OK);
 227         expect(lzma_info_index_count_get(info) == 2);
 228         expect(lzma_info_index_finish(info) == LZMA_OK);
 229
 230         test3_init();
 231         expect(lzma_info_size_set(info, LZMA_INFO_TOTAL, 1000) == LZMA_OK);
 232         expect(lzma_info_iter_set(&iter, 1001, 2001) == LZMA_DATA_ERROR);
 233
 234         test3_init();
 235         expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED, 2000)
 236                         == LZMA_OK);
 237         expect(lzma_info_iter_set(&iter, 1001, 2001) == LZMA_DATA_ERROR);
 238
 239         reset();
 240 }
 241
 242
 243 static void
 244 test4(void)
 245 {
 246         // 4a
 247         lzma_info_iter_begin(info, &iter);
 248         expect(lzma_info_index_count_get(info) == 0);
 249
 250         expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
 251         expect(iter.total_size == LZMA_VLI_VALUE_UNKNOWN);
 252         expect(iter.uncompressed_size == LZMA_VLI_VALUE_UNKNOWN);
 253         expect(iter.stream_offset == LZMA_VLI_VALUE_UNKNOWN);
 254         expect(iter.uncompressed_offset == 0);
 255         expect(lzma_info_index_count_get(info) == 1);
 256
 257         expect(lzma_info_iter_set(&iter, 22, 33) == LZMA_OK);
 258         expect(iter.total_size == 22);
 259         expect(iter.uncompressed_size == 33);
 260         expect(iter.stream_offset == LZMA_VLI_VALUE_UNKNOWN);
 261         expect(iter.uncompressed_offset == 0);
 262         expect(lzma_info_index_count_get(info) == 1);
 263
 264         expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
 265         expect(iter.total_size == LZMA_VLI_VALUE_UNKNOWN);
 266         expect(iter.uncompressed_size == LZMA_VLI_VALUE_UNKNOWN);
 267         expect(iter.stream_offset == LZMA_VLI_VALUE_UNKNOWN);
 268         expect(iter.uncompressed_offset == 33);
 269
 270         // 4b
 271         reset();
 272         lzma_info_iter_begin(info, &iter);
 273         expect(lzma_info_index_count_get(info) == 0);
 274         expect(lzma_info_size_set(info, LZMA_INFO_STREAM_START, 5) == LZMA_OK);
 275         expect(lzma_info_size_set(info, LZMA_INFO_HEADER_METADATA, 11)
 276                         == LZMA_OK);
 277
 278         expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
 279         expect(iter.total_size == LZMA_VLI_VALUE_UNKNOWN);
 280         expect(iter.uncompressed_size == LZMA_VLI_VALUE_UNKNOWN);
 281         expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE + 11);
 282         expect(iter.uncompressed_offset == 0);
 283         expect(lzma_info_index_count_get(info) == 1);
 284
 285         expect(lzma_info_iter_set(&iter, 22, 33) == LZMA_OK);
 286         expect(iter.total_size == 22);
 287         expect(iter.uncompressed_size == 33);
 288         expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE + 11);
 289         expect(iter.uncompressed_offset == 0);
 290         expect(lzma_info_index_count_get(info) == 1);
 291
 292         expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
 293         expect(iter.total_size == LZMA_VLI_VALUE_UNKNOWN);
 294         expect(iter.uncompressed_size == LZMA_VLI_VALUE_UNKNOWN);
 295         expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE + 11 + 22);
 296         expect(iter.uncompressed_offset == 33);
 297         expect(lzma_info_index_count_get(info) == 2);
 298
 299         expect(lzma_info_iter_set(&iter, 44, 55) == LZMA_OK);
 300         expect(iter.total_size == 44);
 301         expect(iter.uncompressed_size == 55);
 302         expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE + 11 + 22);
 303         expect(iter.uncompressed_offset == 33);
 304         expect(lzma_info_index_count_get(info) == 2);
 305
 306         expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
 307         expect(iter.total_size == LZMA_VLI_VALUE_UNKNOWN);
 308         expect(iter.uncompressed_size == LZMA_VLI_VALUE_UNKNOWN);
 309         expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE
 310                         + 11 + 22 + 44);
 311         expect(iter.uncompressed_offset == 33 + 55);
 312         expect(lzma_info_index_count_get(info) == 3);
 313
 314         expect(lzma_info_iter_set(&iter, 66, 77) == LZMA_OK);
 315         expect(iter.total_size == 66);
 316         expect(iter.uncompressed_size == 77);
 317         expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE
 318                         + 11 + 22 + 44);
 319         expect(iter.uncompressed_offset == 33 + 55);
 320         expect(lzma_info_index_count_get(info) == 3);
 321
 322         expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
 323         expect(iter.total_size == LZMA_VLI_VALUE_UNKNOWN);
 324         expect(iter.uncompressed_size == LZMA_VLI_VALUE_UNKNOWN);
 325         expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE
 326                         + 11 + 22 + 44 + 66);
 327         expect(iter.uncompressed_offset == 33 + 55 + 77);
 328         expect(lzma_info_index_count_get(info) == 4);
 329
 330         expect(lzma_info_iter_set(&iter, 88, 99) == LZMA_OK);
 331         expect(iter.total_size == 88);
 332         expect(iter.uncompressed_size == 99);
 333         expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE
 334                         + 11 + 22 + 44 + 66);
 335         expect(iter.uncompressed_offset == 33 + 55 + 77);
 336         expect(lzma_info_index_count_get(info) == 4);
 337
 338         // 4c (continues from 4b)
 339         lzma_info_iter_begin(info, &iter);
 340         expect(lzma_info_index_count_get(info) == 4);
 341
 342         expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
 343         expect(iter.total_size == 22);
 344         expect(iter.uncompressed_size == 33);
 345         expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE + 11);
 346         expect(iter.uncompressed_offset == 0);
 347         expect(lzma_info_index_count_get(info) == 4);
 348
 349         expect(lzma_info_iter_set(&iter, 22, LZMA_VLI_VALUE_UNKNOWN)
 350                         == LZMA_OK);
 351         expect(iter.total_size == 22);
 352         expect(iter.uncompressed_size == 33);
 353         expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE + 11);
 354         expect(iter.uncompressed_offset == 0);
 355         expect(lzma_info_index_count_get(info) == 4);
 356
 357         expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
 358         expect(iter.total_size == 44);
 359         expect(iter.uncompressed_size == 55);
 360         expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE + 11 + 22);
 361         expect(iter.uncompressed_offset == 33);
 362         expect(lzma_info_index_count_get(info) == 4);
 363
 364         expect(lzma_info_iter_set(&iter, LZMA_VLI_VALUE_UNKNOWN, 55)
 365                         == LZMA_OK);
 366         expect(iter.total_size == 44);
 367         expect(iter.uncompressed_size == 55);
 368         expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE + 11 + 22);
 369         expect(iter.uncompressed_offset == 33);
 370         expect(lzma_info_index_count_get(info) == 4);
 371
 372         expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
 373         expect(iter.total_size == 66);
 374         expect(iter.uncompressed_size == 77);
 375         expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE
 376                         + 11 + 22 + 44);
 377         expect(iter.uncompressed_offset == 33 + 55);
 378         expect(lzma_info_index_count_get(info) == 4);
 379
 380         expect(lzma_info_iter_set(&iter, LZMA_VLI_VALUE_UNKNOWN,
 381                         LZMA_VLI_VALUE_UNKNOWN) == LZMA_OK);
 382         expect(iter.total_size == 66);
 383         expect(iter.uncompressed_size == 77);
 384         expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE
 385                         + 11 + 22 + 44);
 386         expect(iter.uncompressed_offset == 33 + 55);
 387         expect(lzma_info_index_count_get(info) == 4);
 388
 389         expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
 390         expect(iter.total_size == 88);
 391         expect(iter.uncompressed_size == 99);
 392         expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE
 393                         + 11 + 22 + 44 + 66);
 394         expect(iter.uncompressed_offset == 33 + 55 + 77);
 395         expect(lzma_info_index_count_get(info) == 4);
 396
 397         expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
 398         expect(iter.total_size == LZMA_VLI_VALUE_UNKNOWN);
 399         expect(iter.uncompressed_size == LZMA_VLI_VALUE_UNKNOWN);
 400         expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE
 401                         + 11 + 22 + 44 + 66 + 88);
 402         expect(iter.uncompressed_offset == 33 + 55 + 77 + 99);
 403         expect(lzma_info_index_count_get(info) == 5);
 404
 405         expect(lzma_info_iter_set(&iter, 1234, LZMA_VLI_VALUE_UNKNOWN)
 406                         == LZMA_OK);
 407         expect(iter.total_size == 1234);
 408         expect(iter.uncompressed_size == LZMA_VLI_VALUE_UNKNOWN);
 409         expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE
 410                         + 11 + 22 + 44 + 66 + 88);
 411         expect(iter.uncompressed_offset == 33 + 55 + 77 + 99);
 412         expect(lzma_info_index_count_get(info) == 5);
 413
 414         // Test 4d (continues from 4c)
 415         lzma_info_iter_begin(info, &iter);
 416         for (size_t i = 0; i < 4; ++i)
 417                 expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
 418         expect(lzma_info_iter_set(&iter, 88, 99) == LZMA_OK);
 419         expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
 420         expect(iter.total_size == 1234);
 421         expect(iter.uncompressed_size == LZMA_VLI_VALUE_UNKNOWN);
 422         expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE
 423                         + 11 + 22 + 44 + 66 + 88);
 424         expect(iter.uncompressed_offset == 33 + 55 + 77 + 99);
 425         expect(lzma_info_index_count_get(info) == 5);
 426
 427         expect(lzma_info_iter_set(&iter, LZMA_VLI_VALUE_UNKNOWN, 4321)
 428                         == LZMA_OK);
 429         expect(iter.total_size == 1234);
 430         expect(iter.uncompressed_size == 4321);
 431         expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE
 432                         + 11 + 22 + 44 + 66 + 88);
 433         expect(iter.uncompressed_offset == 33 + 55 + 77 + 99);
 434         expect(lzma_info_index_count_get(info) == 5);
 435
 436         expect(lzma_info_index_finish(info) == LZMA_OK);
 437         expect(lzma_info_index_count_get(info) == 5);
 438
 439         // Test 4e (continues from 4d)
 440         lzma_info_iter_begin(info, &iter);
 441         for (size_t i = 0; i < 5; ++i)
 442                 expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
 443         expect(lzma_info_iter_set(&iter, 1234, 4321) == LZMA_OK);
 444         expect(lzma_info_iter_next(&iter, NULL) == LZMA_DATA_ERROR);
 445
 446         reset();
 447 }
 448
 449
 450 static void
 451 test5(void)
 452 {
 453         lzma_index *i;
 454
 455         expect(lzma_info_index_set(info, NULL, NULL, true)
 456                         == LZMA_PROG_ERROR);
 457
 458         reset();
 459         expect(lzma_info_index_set(info, NULL, my_index, false) == LZMA_OK);
 460         i = lzma_index_dup(my_index, NULL);
 461         expect(i != NULL);
 462         i->next->uncompressed_size = 99;
 463         expect(lzma_info_index_set(info, NULL, i, true) == LZMA_DATA_ERROR);
 464
 465         reset();
 466         expect(lzma_info_index_set(info, NULL, my_index, false) == LZMA_OK);
 467         i = lzma_index_dup(my_index, NULL);
 468         expect(i != NULL);
 469         lzma_index_free(i->next->next, NULL);
 470         i->next->next = NULL;
 471         expect(lzma_info_index_set(info, NULL, i, true) == LZMA_DATA_ERROR);
 472
 473         reset();
 474         expect(lzma_info_index_set(info, NULL, my_index, false) == LZMA_OK);
 475         i = lzma_index_dup(my_index, NULL);
 476         expect(i != NULL);
 477         lzma_index_free(i->next->next, NULL);
 478         i->next->next = lzma_index_dup(my_index, NULL);
 479         expect(i->next->next != NULL);
 480         expect(lzma_info_index_set(info, NULL, i, true) == LZMA_DATA_ERROR);
 481
 482         reset();
 483         expect(lzma_info_size_set(info, LZMA_INFO_TOTAL,
 484                         total_size = 22 + 44 + 66) == LZMA_OK);
 485         expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED,
 486                         uncompressed_size = 33 + 55 + 77) == LZMA_OK);
 487         validate();
 488         expect(lzma_info_index_set(info, NULL, my_index, false) == LZMA_OK);
 489         validate();
 490
 491         reset();
 492         expect(lzma_info_size_set(info, LZMA_INFO_TOTAL, total_size = 77)
 493                         == LZMA_OK);
 494         expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED,
 495                         uncompressed_size = 33 + 55 + 77) == LZMA_OK);
 496         validate();
 497         expect(lzma_info_index_set(info, NULL, my_index, false)
 498                         == LZMA_DATA_ERROR);
 499
 500         reset();
 501         expect(lzma_info_size_set(info, LZMA_INFO_TOTAL,
 502                         total_size = 22 + 44 + 66) == LZMA_OK);
 503         expect(lzma_info_size_set(info, LZMA_INFO_UNCOMPRESSED,
 504                         uncompressed_size = 777777) == LZMA_OK);
 505         validate();
 506         expect(lzma_info_index_set(info, NULL, my_index, false)
 507                         == LZMA_DATA_ERROR);
 508
 509         reset();
 510 }
 511
 512
 513 static void
 514 test6(void)
 515 {
 516         lzma_metadata metadata;
 517
 518         // Same complete Metadata in both Header and Footer
 519         expect(lzma_info_size_set(info, LZMA_INFO_HEADER_METADATA,
 520                         my_metadata.header_metadata_size) == LZMA_OK);
 521         expect(lzma_info_metadata_set(info, NULL, &my_metadata, true, false)
 522                         == LZMA_OK);
 523         expect(lzma_info_metadata_set(info, NULL, &my_metadata, false, false)
 524                         == LZMA_OK);
 525
 526         // Header Metadata is not present but Size of Header Metadata is
 527         // still present in Footer.
 528         reset();
 529         metadata = my_metadata;
 530         metadata.header_metadata_size = LZMA_VLI_VALUE_UNKNOWN;
 531         expect(lzma_info_size_set(info, LZMA_INFO_HEADER_METADATA, 0)
 532                         == LZMA_OK);
 533         expect(lzma_info_metadata_set(info, NULL, &metadata, true, false)
 534                         == LZMA_OK);
 535         expect(lzma_info_metadata_set(info, NULL, &my_metadata, false, false)
 536                         == LZMA_DATA_ERROR);
 537
 538         // Header Metadata is present but Size of Header Metadata is missing
 539         // from Footer.
 540         reset();
 541         metadata = my_metadata;
 542         metadata.header_metadata_size = LZMA_VLI_VALUE_UNKNOWN;
 543         expect(lzma_info_metadata_set(info, NULL, &my_metadata, true, false)
 544                         == LZMA_OK);
 545         expect(lzma_info_size_set(info, LZMA_INFO_HEADER_METADATA,
 546                         my_metadata.header_metadata_size) == LZMA_OK);
 547         expect(lzma_info_metadata_set(info, NULL, &metadata, false, false)
 548                         == LZMA_DATA_ERROR);
 549
 550         // Index missing
 551         reset();
 552         metadata = my_metadata;
 553         metadata.index = NULL;
 554         expect(lzma_info_metadata_set(info, NULL, &metadata, true, false)
 555                         == LZMA_OK);
 556         expect(lzma_info_metadata_set(info, NULL, &metadata, false, false)
 557                         == LZMA_DATA_ERROR);
 558
 559         // Index in Header Metadata but not in Footer Metadata
 560         reset();
 561         expect(lzma_info_metadata_set(info, NULL, &my_metadata, true, false)
 562                         == LZMA_OK);
 563         expect(lzma_info_metadata_set(info, NULL, &metadata, false, false)
 564                         == LZMA_OK);
 565
 566         // Index in Header Metadata but not in Footer Metadata but
 567         // Total Size is missing from Footer.
 568         reset();
 569         metadata.total_size = LZMA_VLI_VALUE_UNKNOWN;
 570         expect(lzma_info_metadata_set(info, NULL, &my_metadata, true, false)
 571                         == LZMA_OK);
 572         expect(lzma_info_metadata_set(info, NULL, &metadata, false, false)
 573                         == LZMA_DATA_ERROR);
 574
 575         // Total Size doesn't match the Index
 576         reset();
 577         metadata = my_metadata;
 578         metadata.total_size = 9999;
 579         expect(lzma_info_metadata_set(info, NULL, &metadata, true, false)
 580                         == LZMA_DATA_ERROR);
 581
 582         // Uncompressed Size doesn't match the Index
 583         reset();
 584         metadata = my_metadata;
 585         metadata.uncompressed_size = 9999;
 586         expect(lzma_info_metadata_set(info, NULL, &metadata, true, false)
 587                         == LZMA_DATA_ERROR);
 588
 589         reset();
 590 }
 591
 592
 593 static void
 594 test7(void)
 595 {
 596         // No info yet, so we cannot locate anything.
 597         expect(lzma_info_metadata_locate(info, true)
 598                         == LZMA_VLI_VALUE_UNKNOWN);
 599         expect(lzma_info_metadata_locate(info, false)
 600                         == LZMA_VLI_VALUE_UNKNOWN);
 601
 602         // Setting the Stream start offset doesn't change this situation.
 603         expect(lzma_info_size_set(info, LZMA_INFO_STREAM_START, 5) == LZMA_OK);
 604         expect(lzma_info_metadata_locate(info, true)
 605                         == LZMA_VLI_VALUE_UNKNOWN);
 606         expect(lzma_info_metadata_locate(info, false)
 607                         == LZMA_VLI_VALUE_UNKNOWN);
 608
 609         // Setting the Size of Header Metadata known allows us to locate
 610         // the Header Metadata Block.
 611         expect(lzma_info_size_set(info, LZMA_INFO_HEADER_METADATA, 11)
 612                         == LZMA_OK);
 613         expect(lzma_info_metadata_locate(info, true)
 614                         == 5 + LZMA_STREAM_HEADER_SIZE);
 615         expect(lzma_info_metadata_locate(info, false)
 616                         == LZMA_VLI_VALUE_UNKNOWN);
 617
 618         // Adding a Data Block. As long as Index is not Finished, we cannot
 619         // locate Footer Metadata Block.
 620         lzma_info_iter_begin(info, &iter);
 621         expect(lzma_info_iter_next(&iter, NULL) == LZMA_OK);
 622         expect(iter.stream_offset == 5 + LZMA_STREAM_HEADER_SIZE + 11);
 623         expect(iter.uncompressed_offset == 0);
 624         expect(lzma_info_iter_set(&iter, 22, 33) == LZMA_OK);
 625         expect(lzma_info_metadata_locate(info, true)
 626                         == 5 + LZMA_STREAM_HEADER_SIZE);
 627         expect(lzma_info_metadata_locate(info, false)
 628                         == LZMA_VLI_VALUE_UNKNOWN);
 629
 630         // Once the Index is finished, we can locate Footer Metadata Block too.
 631         expect(lzma_info_index_finish(info) == LZMA_OK);
 632         expect(lzma_info_metadata_locate(info, true)
 633                         == 5 + LZMA_STREAM_HEADER_SIZE);
 634         expect(lzma_info_metadata_locate(info, false)
 635                         == 5 + LZMA_STREAM_HEADER_SIZE + 11 + 22);
 636
 637         // A retry of most of the above but now with unknown Size of Header
 638         // Metadata Block, which makes locating Footer Metadata Block
 639         // impossible.
 640         reset();
 641         expect(lzma_info_size_set(info, LZMA_INFO_STREAM_START, 5) == LZMA_OK);
 642         expect(lzma_info_metadata_locate(info, true)
 643                         == LZMA_VLI_VALUE_UNKNOWN);
 644         expect(lzma_info_metadata_locate(info, false)
 645                         == LZMA_VLI_VALUE_UNKNOWN);
 646
 647         expect(lzma_info_index_set(info, NULL, my_index, false) == LZMA_OK);
 648         expect(lzma_info_metadata_locate(info, true)
 649                         == LZMA_VLI_VALUE_UNKNOWN);
 650         expect(lzma_info_metadata_locate(info, false)
 651                         == LZMA_VLI_VALUE_UNKNOWN);
 652
 653         expect(lzma_info_size_set(info, LZMA_INFO_HEADER_METADATA, 11)
 654                         == LZMA_OK);
 655         expect(lzma_info_metadata_locate(info, true)
 656                         == 5 + LZMA_STREAM_HEADER_SIZE);
 657         expect(lzma_info_metadata_locate(info, false)
 658                         == LZMA_STREAM_HEADER_SIZE + 5 + 11 + 22 + 44 + 66);
 659
 660         reset();
 661 }
 662
 663
 664 static void
 665 test8(void)
 666 {
 667         expect(lzma_info_size_set(info, LZMA_INFO_STREAM_START, 5) == LZMA_OK);
 668         expect(lzma_info_size_set(info, LZMA_INFO_HEADER_METADATA, 11)
 669                         == LZMA_OK);
 670
 671         lzma_info_iter_begin(info, &iter);
 672         expect(lzma_info_iter_locate(&iter, NULL, 0, false)
 673                         == LZMA_DATA_ERROR);
 674         expect(lzma_info_index_count_get(info) == 0);
 675
 676         lzma_info_iter_begin(info, &iter);
 677         expect(lzma_info_iter_locate(&iter, NULL, 0, true) == LZMA_OK);
 678         expect(lzma_info_index_count_get(info) == 1);
 679         expect(lzma_info_iter_locate(&iter, NULL, 0, false) == LZMA_OK);
 680         expect(lzma_info_index_count_get(info) == 1);
 681
 682         // TODO
 683 }
 684
 685
 686 /*
 687 static void
 688 test9(void)
 689 {
 690         // TODO Various integer overflow checks
 691 }
 692 */
 693
 694
 695 int
 696 main()
 697 {
 698         lzma_init();
 699
 700         info = lzma_info_init(NULL, NULL);
 701         if (info == NULL)
 702                 return 1;
 703
 704         validate();
 705
 706         test1();
 707         test2();
 708         test3();
 709         test4();
 710         test5();
 711         test6();
 712         test7();
 713         test8();
 714
 715         lzma_info_free(info, NULL);
 716         return 0;
 717 }