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
2.70k
{
35
2.70k
  FUZZ_dataProducer_t *producer = FUZZ_malloc(sizeof(FUZZ_dataProducer_t));
36
37
2.70k
  producer->data = data;
38
2.70k
  producer->size = size;
39
2.70k
  return producer;
40
2.70k
}
41
42
void FUZZ_dataProducer_free(FUZZ_dataProducer_t *producer)
43
2.70k
{
44
2.70k
  free(producer);
45
2.70k
}
46
47
uint32_t FUZZ_dataProducer_uint32Range(FUZZ_dataProducer_t *producer, uint32_t min,
48
               uint32_t max)
49
100k
{
50
100k
  uint32_t range = max - min;
51
100k
  uint32_t rolling = range;
52
100k
  uint32_t result = 0;
53
54
100k
  FUZZ_ASSERT(min <= max);
55
56
434k
  while (rolling > 0 && producer->size > 0) {
57
334k
    uint8_t next = *(producer->data + producer->size - 1);
58
59
334k
    producer->size -= 1;
60
334k
    result = (result << 8) | next;
61
334k
    rolling >>= 8;
62
334k
  }
63
64
100k
  if (range == 0xffffffff)
65
81.2k
    return result;
66
67
18.9k
  return min + result % (range + 1);
68
100k
}
69
70
uint32_t FUZZ_dataProducer_uint32(FUZZ_dataProducer_t *producer)
71
81.2k
{
72
81.2k
  return FUZZ_dataProducer_uint32Range(producer, 0, 0xffffffff);
73
81.2k
}
74
75
int32_t FUZZ_dataProducer_int32Range(FUZZ_dataProducer_t *producer,
76
             int32_t min, int32_t max)
77
5.41k
{
78
5.41k
  FUZZ_ASSERT(min <= max);
79
80
5.41k
  if (min < 0)
81
0
    return (int)FUZZ_dataProducer_uint32Range(producer, 0, max - min) + min;
82
83
5.41k
  return FUZZ_dataProducer_uint32Range(producer, min, max);
84
5.41k
}
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
2.70k
{
104
2.70k
  size_t remaining;
105
106
2.70k
  newSize = newSize > producer->size ? producer->size : newSize;
107
2.70k
  remaining = producer->size - newSize;
108
2.70k
  producer->data = producer->data + remaining;
109
2.70k
  producer->size = newSize;
110
2.70k
  return remaining;
111
2.70k
}
112
113
size_t FUZZ_dataProducer_reserveDataPrefix(FUZZ_dataProducer_t *producer)
114
2.70k
{
115
2.70k
  size_t producerSliceSize = FUZZ_dataProducer_uint32Range(
116
2.70k
                 producer, 0, producer->size);
117
2.70k
  return FUZZ_dataProducer_contract(producer, producerSliceSize);
118
2.70k
}
119
120
void FUZZ_dataProducer_cmp_par(FUZZ_dataProducer_t *producer, struct cmp_par *cmp_par)
121
2.70k
{
122
2.70k
  cmp_par->cmp_mode = (enum cmp_mode)FUZZ_dataProducer_uint32(producer);
123
2.70k
  cmp_par->model_value = FUZZ_dataProducer_uint32(producer);
124
2.70k
  cmp_par->lossy_par = FUZZ_dataProducer_uint32(producer);
125
126
2.70k
  cmp_par->nc_imagette = FUZZ_dataProducer_uint32(producer);
127
128
2.70k
  cmp_par->s_exp_flags = FUZZ_dataProducer_uint32(producer);
129
2.70k
  cmp_par->s_fx = FUZZ_dataProducer_uint32(producer);
130
2.70k
  cmp_par->s_ncob = FUZZ_dataProducer_uint32(producer);
131
2.70k
  cmp_par->s_efx = FUZZ_dataProducer_uint32(producer);
132
2.70k
  cmp_par->s_ecob = FUZZ_dataProducer_uint32(producer);
133
134
2.70k
  cmp_par->l_exp_flags = FUZZ_dataProducer_uint32(producer);
135
2.70k
  cmp_par->l_fx = FUZZ_dataProducer_uint32(producer);
136
2.70k
  cmp_par->l_ncob = FUZZ_dataProducer_uint32(producer);
137
2.70k
  cmp_par->l_efx = FUZZ_dataProducer_uint32(producer);
138
2.70k
  cmp_par->l_ecob = FUZZ_dataProducer_uint32(producer);
139
2.70k
  cmp_par->l_fx_cob_variance = FUZZ_dataProducer_uint32(producer);
140
141
2.70k
  cmp_par->saturated_imagette = FUZZ_dataProducer_uint32(producer);
142
143
2.70k
  cmp_par->nc_offset_mean = FUZZ_dataProducer_uint32(producer);
144
2.70k
  cmp_par->nc_offset_variance = FUZZ_dataProducer_uint32(producer);
145
2.70k
  cmp_par->nc_background_mean = FUZZ_dataProducer_uint32(producer);
146
2.70k
  cmp_par->nc_background_variance = FUZZ_dataProducer_uint32(producer);
147
2.70k
  cmp_par->nc_background_outlier_pixels = FUZZ_dataProducer_uint32(producer);
148
149
2.70k
  cmp_par->smearing_mean = FUZZ_dataProducer_uint32(producer);
150
2.70k
  cmp_par->smearing_variance_mean = FUZZ_dataProducer_uint32(producer);
151
2.70k
  cmp_par->smearing_outlier_pixels = FUZZ_dataProducer_uint32(producer);
152
153
2.70k
  cmp_par->fc_imagette = FUZZ_dataProducer_uint32(producer);
154
2.70k
  cmp_par->fc_offset_mean = FUZZ_dataProducer_uint32(producer);
155
2.70k
  cmp_par->fc_offset_variance = FUZZ_dataProducer_uint32(producer);
156
2.70k
  cmp_par->fc_background_mean = FUZZ_dataProducer_uint32(producer);
157
2.70k
  cmp_par->fc_background_variance = FUZZ_dataProducer_uint32(producer);
158
2.70k
  cmp_par->fc_background_outlier_pixels = FUZZ_dataProducer_uint32(producer);
159
2.70k
}