Coverage Report

Created: 2025-06-15 00:57

/src/cmp_tool/test/fuzz/fuzz_data_producer.c
Line
Count
Source (jump to first uncovered line)
1
/*
2
 * Copyright (c) Meta Platforms, Inc. and affiliates.
3
 * All rights reserved.
4
 *
5
 * This source code is licensed under both the BSD-style license (found in the
6
 * LICENSE.BSD-3.Zstandard file in the 3rdparty_licenses directory) and the GPLv2
7
 * (found in the LICENSE.GPL-2 file in the 3rdparty_licenses directory).
8
 * You may select, at your option, one of the above-listed licenses.
9
 */
10
11
/**
12
 * Modifications made by
13
 * @author Dominik Loidolt (dominik.loidolt@univie.ac.at)
14
 * @date 2024
15
 * @see https://github.com/facebook/zstd/issues/1723
16
 *
17
 * - Added function providing a cmp_par struct
18
 *
19
 * Modifications are also licensed under the same license for consistency
20
 *
21
 */
22
23
24
#include "fuzz_helpers.h"
25
#include "fuzz_data_producer.h"
26
#include <cmp_chunk.h>
27
28
struct FUZZ_dataProducer_s {
29
  const uint8_t *data;
30
  size_t size;
31
};
32
33
FUZZ_dataProducer_t *FUZZ_dataProducer_create(const uint8_t *data, size_t size)
34
1.75k
{
35
1.75k
  FUZZ_dataProducer_t *producer = FUZZ_malloc(sizeof(FUZZ_dataProducer_t));
36
37
1.75k
  producer->data = data;
38
1.75k
  producer->size = size;
39
1.75k
  return producer;
40
1.75k
}
41
42
void FUZZ_dataProducer_free(FUZZ_dataProducer_t *producer)
43
1.75k
{
44
1.75k
  free(producer);
45
1.75k
}
46
47
uint32_t FUZZ_dataProducer_uint32Range(FUZZ_dataProducer_t *producer, uint32_t min,
48
               uint32_t max)
49
21.0k
{
50
21.0k
  uint32_t range = max - min;
51
21.0k
  uint32_t rolling = range;
52
21.0k
  uint32_t result = 0;
53
54
21.0k
  FUZZ_ASSERT(min <= max);
55
56
41.9k
  while (rolling > 0 && producer->size > 0) {
57
20.9k
    uint8_t next = *(producer->data + producer->size - 1);
58
59
20.9k
    producer->size -= 1;
60
20.9k
    result = (result << 8) | next;
61
20.9k
    rolling >>= 8;
62
20.9k
  }
63
64
21.0k
  if (range == 0xffffffff)
65
0
    return result;
66
67
21.0k
  return min + result % (range + 1);
68
21.0k
}
69
70
uint32_t FUZZ_dataProducer_uint32(FUZZ_dataProducer_t *producer)
71
0
{
72
0
  return FUZZ_dataProducer_uint32Range(producer, 0, 0xffffffff);
73
0
}
74
75
int32_t FUZZ_dataProducer_int32Range(FUZZ_dataProducer_t *producer,
76
             int32_t min, int32_t max)
77
1.75k
{
78
1.75k
  FUZZ_ASSERT(min <= max);
79
80
1.75k
  if (min < 0)
81
0
    return (int)FUZZ_dataProducer_uint32Range(producer, 0, max - min) + min;
82
83
1.75k
  return FUZZ_dataProducer_uint32Range(producer, min, max);
84
1.75k
}
85
86
size_t FUZZ_dataProducer_remainingBytes(FUZZ_dataProducer_t *producer)
87
0
{
88
0
  return producer->size;
89
0
}
90
91
void FUZZ_dataProducer_rollBack(FUZZ_dataProducer_t *producer, size_t remainingBytes)
92
0
{
93
0
  FUZZ_ASSERT(remainingBytes >= producer->size);
94
0
  producer->size = remainingBytes;
95
0
}
96
97
int FUZZ_dataProducer_empty(FUZZ_dataProducer_t *producer)
98
0
{
99
0
  return producer->size == 0;
100
0
}
101
102
size_t FUZZ_dataProducer_contract(FUZZ_dataProducer_t *producer, size_t newSize)
103
1.75k
{
104
1.75k
  size_t remaining;
105
106
1.75k
  newSize = newSize > producer->size ? producer->size : newSize;
107
1.75k
  remaining = producer->size - newSize;
108
1.75k
  producer->data = producer->data + remaining;
109
1.75k
  producer->size = newSize;
110
1.75k
  return remaining;
111
1.75k
}
112
113
size_t FUZZ_dataProducer_reserveDataPrefix(FUZZ_dataProducer_t *producer)
114
1.75k
{
115
1.75k
  size_t producerSliceSize = FUZZ_dataProducer_uint32Range(
116
1.75k
                 producer, 0, producer->size);
117
1.75k
  return FUZZ_dataProducer_contract(producer, producerSliceSize);
118
1.75k
}
119
120
void FUZZ_dataProducer_cmp_par(FUZZ_dataProducer_t *producer, struct cmp_par *cmp_par)
121
0
{
122
0
  cmp_par->cmp_mode = (enum cmp_mode)FUZZ_dataProducer_uint32(producer);
123
0
  cmp_par->model_value = FUZZ_dataProducer_uint32(producer);
124
0
  cmp_par->lossy_par = FUZZ_dataProducer_uint32(producer);
125
126
0
  cmp_par->nc_imagette = FUZZ_dataProducer_uint32(producer);
127
128
0
  cmp_par->s_exp_flags = FUZZ_dataProducer_uint32(producer);
129
0
  cmp_par->s_fx = FUZZ_dataProducer_uint32(producer);
130
0
  cmp_par->s_ncob = FUZZ_dataProducer_uint32(producer);
131
0
  cmp_par->s_efx = FUZZ_dataProducer_uint32(producer);
132
0
  cmp_par->s_ecob = FUZZ_dataProducer_uint32(producer);
133
134
0
  cmp_par->l_exp_flags = FUZZ_dataProducer_uint32(producer);
135
0
  cmp_par->l_fx = FUZZ_dataProducer_uint32(producer);
136
0
  cmp_par->l_ncob = FUZZ_dataProducer_uint32(producer);
137
0
  cmp_par->l_efx = FUZZ_dataProducer_uint32(producer);
138
0
  cmp_par->l_ecob = FUZZ_dataProducer_uint32(producer);
139
0
  cmp_par->l_fx_cob_variance = FUZZ_dataProducer_uint32(producer);
140
141
0
  cmp_par->saturated_imagette = FUZZ_dataProducer_uint32(producer);
142
143
0
  cmp_par->nc_offset_mean = FUZZ_dataProducer_uint32(producer);
144
0
  cmp_par->nc_offset_variance = FUZZ_dataProducer_uint32(producer);
145
0
  cmp_par->nc_background_mean = FUZZ_dataProducer_uint32(producer);
146
0
  cmp_par->nc_background_variance = FUZZ_dataProducer_uint32(producer);
147
0
  cmp_par->nc_background_outlier_pixels = FUZZ_dataProducer_uint32(producer);
148
149
0
  cmp_par->smearing_mean = FUZZ_dataProducer_uint32(producer);
150
0
  cmp_par->smearing_variance_mean = FUZZ_dataProducer_uint32(producer);
151
0
  cmp_par->smearing_outlier_pixels = FUZZ_dataProducer_uint32(producer);
152
153
0
  cmp_par->fc_imagette = FUZZ_dataProducer_uint32(producer);
154
0
  cmp_par->fc_offset_mean = FUZZ_dataProducer_uint32(producer);
155
0
  cmp_par->fc_offset_variance = FUZZ_dataProducer_uint32(producer);
156
0
  cmp_par->fc_background_mean = FUZZ_dataProducer_uint32(producer);
157
0
  cmp_par->fc_background_variance = FUZZ_dataProducer_uint32(producer);
158
0
  cmp_par->fc_background_outlier_pixels = FUZZ_dataProducer_uint32(producer);
159
0
}