tests/test_stream_flags.c

   1 ///////////////////////////////////////////////////////////////////////////////
   2 //
   3 /// \file       test_stream_flags.c
   4 /// \brief      Tests Stream Header and Stream Footer coders
   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_stream_flags known_flags;
  24 static lzma_stream_flags decoded_flags;
  25 static uint8_t buffer[LZMA_STREAM_HEADER_SIZE];
  26
  27
  28 static bool
  29 validate(void)
  30 {
  31         return !lzma_stream_flags_equal(&known_flags, &decoded_flags);
  32 }
  33
  34
  35 static bool
  36 test_header_decoder(lzma_ret expected_ret)
  37 {
  38         memcrap(&decoded_flags, sizeof(decoded_flags));
  39
  40         if (lzma_stream_header_decode(&decoded_flags, buffer) != expected_ret)
  41                 return true;
  42
  43         if (expected_ret != LZMA_OK)
  44                 return false;
  45
  46         // Header doesn't have Backward Size, so make
  47         // lzma_stream_flags_equal() ignore it.
  48         decoded_flags.backward_size = LZMA_VLI_VALUE_UNKNOWN;
  49         return validate();
  50 }
  51
  52
  53 static void
  54 test_header(void)
  55 {
  56         memcrap(buffer, sizeof(buffer));
  57         expect(lzma_stream_header_encode(&known_flags, buffer) == LZMA_OK);
  58         succeed(test_header_decoder(LZMA_OK));
  59 }
  60
  61
  62 static bool
  63 test_footer_decoder(lzma_ret expected_ret)
  64 {
  65         memcrap(&decoded_flags, sizeof(decoded_flags));
  66
  67         if (lzma_stream_footer_decode(&decoded_flags, buffer) != expected_ret)
  68                 return true;
  69
  70         if (expected_ret != LZMA_OK)
  71                 return false;
  72
  73         return validate();
  74 }
  75
  76
  77 static void
  78 test_footer(void)
  79 {
  80         memcrap(buffer, sizeof(buffer));
  81         expect(lzma_stream_footer_encode(&known_flags, buffer) == LZMA_OK);
  82         succeed(test_footer_decoder(LZMA_OK));
  83 }
  84
  85
  86 static void
  87 test_encode_invalid(void)
  88 {
  89         known_flags.check = LZMA_CHECK_ID_MAX + 1;
  90         known_flags.backward_size = 1024;
  91
  92         expect(lzma_stream_header_encode(&known_flags, buffer)
  93                         == LZMA_PROG_ERROR);
  94
  95         expect(lzma_stream_footer_encode(&known_flags, buffer)
  96                         == LZMA_PROG_ERROR);
  97
  98         known_flags.check = (lzma_check)(-1);
  99
 100         expect(lzma_stream_header_encode(&known_flags, buffer)
 101                         == LZMA_PROG_ERROR);
 102
 103         expect(lzma_stream_footer_encode(&known_flags, buffer)
 104                         == LZMA_PROG_ERROR);
 105
 106         known_flags.check = LZMA_CHECK_NONE;
 107         known_flags.backward_size = 0;
 108
 109         // Header encoder ignores backward_size.
 110         expect(lzma_stream_header_encode(&known_flags, buffer) == LZMA_OK);
 111
 112         expect(lzma_stream_footer_encode(&known_flags, buffer)
 113                         == LZMA_PROG_ERROR);
 114
 115         known_flags.backward_size = LZMA_VLI_VALUE_MAX;
 116
 117         expect(lzma_stream_header_encode(&known_flags, buffer) == LZMA_OK);
 118
 119         expect(lzma_stream_footer_encode(&known_flags, buffer)
 120                         == LZMA_PROG_ERROR);
 121 }
 122
 123
 124 static void
 125 test_decode_invalid(void)
 126 {
 127         known_flags.check = LZMA_CHECK_NONE;
 128         known_flags.backward_size = 1024;
 129
 130         expect(lzma_stream_header_encode(&known_flags, buffer) == LZMA_OK);
 131
 132         // Test 1 (invalid Magic Bytes)
 133         buffer[5] ^= 1;
 134         succeed(test_header_decoder(LZMA_FORMAT_ERROR));
 135         buffer[5] ^= 1;
 136
 137         // Test 2a (valid CRC32)
 138         uint32_t crc = lzma_crc32(buffer + 6, 2, 0);
 139         integer_write_32(buffer + 8, crc);
 140         succeed(test_header_decoder(LZMA_OK));
 141
 142         // Test 2b (invalid Stream Flags with valid CRC32)
 143         buffer[6] ^= 0x20;
 144         crc = lzma_crc32(buffer + 6, 2, 0);
 145         integer_write_32(buffer + 8, crc);
 146         succeed(test_header_decoder(LZMA_HEADER_ERROR));
 147
 148         // Test 3 (invalid CRC32)
 149         expect(lzma_stream_header_encode(&known_flags, buffer) == LZMA_OK);
 150         buffer[9] ^= 1;
 151         succeed(test_header_decoder(LZMA_DATA_ERROR));
 152
 153         // Test 4 (invalid Stream Flags with valid CRC32)
 154         expect(lzma_stream_footer_encode(&known_flags, buffer) == LZMA_OK);
 155         buffer[9] ^= 0x40;
 156         crc = lzma_crc32(buffer + 4, 6, 0);
 157         integer_write_32(buffer, crc);
 158         succeed(test_footer_decoder(LZMA_HEADER_ERROR));
 159
 160         // Test 5 (invalid Magic Bytes)
 161         expect(lzma_stream_footer_encode(&known_flags, buffer) == LZMA_OK);
 162         buffer[11] ^= 1;
 163         succeed(test_footer_decoder(LZMA_FORMAT_ERROR));
 164 }
 165
 166
 167 int
 168 main(void)
 169 {
 170         lzma_init();
 171
 172         // Valid headers
 173         known_flags.backward_size = 1024;
 174         for (lzma_check check = LZMA_CHECK_NONE;
 175                         check <= LZMA_CHECK_ID_MAX; ++check) {
 176                 test_header();
 177                 test_footer();
 178         }
 179
 180         // Invalid headers
 181         test_encode_invalid();
 182         test_decode_invalid();
 183
 184         return 0;
 185 }