xref: /openbsd-src/gnu/llvm/compiler-rt/lib/fuzzer/tests/FuzzedDataProviderUnittest.cpp (revision 46035553bfdd96e63c94e32da0210227ec2e3cf1)
1 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
2 // See https://llvm.org/LICENSE.txt for license information.
3 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
4 
5 #include "gtest/gtest.h"
6 #include <cstdint>
7 #include <cstdlib>
8 
9 #include <fuzzer/FuzzedDataProvider.h>
10 
11 // The test is intentionally extensive, as behavior of |FuzzedDataProvider| must
12 // not be broken, given than many fuzz targets depend on it. Changing the
13 // behavior might invalidate existing corpora and make the fuzz targets using
14 // |FuzzedDataProvider| to lose code coverage accumulated over time.
15 
16 /* A random 1KB buffer generated by:
17 $ python -c "import os; print ',\n'.join([', '.join(['0x%02X' % ord(i) for i \
18       in list(os.urandom(8))]) for _ in xrange(128)])"
19 */
20 const uint8_t Data[] = {
21     0x8A, 0x19, 0x0D, 0x44, 0x37, 0x0D, 0x38, 0x5E, 0x9B, 0xAA, 0xF3, 0xDA,
22     0xAA, 0x88, 0xF2, 0x9B, 0x6C, 0xBA, 0xBE, 0xB1, 0xF2, 0xCF, 0x13, 0xB8,
23     0xAC, 0x1A, 0x7F, 0x1C, 0xC9, 0x90, 0xD0, 0xD9, 0x5C, 0x42, 0xB3, 0xFD,
24     0xE3, 0x05, 0xA4, 0x03, 0x37, 0x49, 0x50, 0x4B, 0xBC, 0x39, 0xA2, 0x09,
25     0x6C, 0x2F, 0xAF, 0xD1, 0xB5, 0x47, 0xBF, 0x92, 0xBD, 0x79, 0xE5, 0xC5,
26     0x6E, 0x51, 0xA4, 0xED, 0xE9, 0xBD, 0x40, 0x4A, 0xFC, 0x25, 0x7A, 0x27,
27     0xC8, 0x92, 0xF7, 0x30, 0xDE, 0x40, 0x66, 0x66, 0xE8, 0x5F, 0x65, 0x39,
28     0x7E, 0x9E, 0x80, 0x2B, 0x01, 0x71, 0x2A, 0xFF, 0xD3, 0x0A, 0xAC, 0x6E,
29     0x49, 0x32, 0x79, 0x10, 0x6A, 0x6F, 0x97, 0x96, 0x70, 0x7E, 0x50, 0x65,
30     0xC9, 0x1D, 0xBD, 0x4E, 0x17, 0x04, 0x1E, 0xBA, 0x26, 0xAC, 0x1F, 0xE3,
31     0x37, 0x1C, 0x15, 0x43, 0x60, 0x41, 0x2A, 0x7C, 0xCA, 0x70, 0xCE, 0xAB,
32     0x20, 0x24, 0xF8, 0xD9, 0x1F, 0x14, 0x7C, 0x5C, 0xDD, 0x6F, 0xB3, 0xD7,
33     0x8B, 0x63, 0x10, 0xB7, 0xDA, 0x99, 0xAF, 0x99, 0x01, 0x21, 0xE6, 0xE1,
34     0x86, 0x27, 0xBE, 0x8D, 0xDF, 0x1E, 0xEA, 0x80, 0x0B, 0x8A, 0x60, 0xC3,
35     0x3A, 0x85, 0x33, 0x53, 0x59, 0xE1, 0xB5, 0xF1, 0x62, 0xA6, 0x7B, 0x24,
36     0x94, 0xE3, 0x8C, 0x10, 0x93, 0xF8, 0x6E, 0xC2, 0x00, 0x91, 0x90, 0x0B,
37     0x5D, 0x52, 0x4F, 0x21, 0xE3, 0x40, 0x3A, 0x6E, 0xB6, 0x32, 0x15, 0xDB,
38     0x5D, 0x01, 0x86, 0x63, 0x83, 0x24, 0xC5, 0xDE, 0xAB, 0x31, 0x84, 0xAA,
39     0xE5, 0x64, 0x02, 0x8D, 0x23, 0x82, 0x86, 0x14, 0x16, 0x18, 0x9F, 0x3D,
40     0x31, 0xBE, 0x3B, 0xF0, 0x6C, 0x26, 0x42, 0x9A, 0x67, 0xFE, 0x28, 0xEC,
41     0x28, 0xDB, 0x01, 0xB4, 0x52, 0x41, 0x81, 0x7C, 0x54, 0xD3, 0xC8, 0x00,
42     0x01, 0x66, 0xB0, 0x2C, 0x3F, 0xBC, 0xAF, 0xAC, 0x87, 0xCD, 0x83, 0xCF,
43     0x23, 0xFC, 0xC8, 0x97, 0x8C, 0x71, 0x32, 0x8B, 0xBF, 0x70, 0xC0, 0x48,
44     0x31, 0x92, 0x18, 0xFE, 0xE5, 0x33, 0x48, 0x82, 0x98, 0x1E, 0x30, 0xCC,
45     0xAD, 0x5D, 0x97, 0xC4, 0xB4, 0x39, 0x7C, 0xCD, 0x39, 0x44, 0xF1, 0xA9,
46     0xD0, 0xF4, 0x27, 0xB7, 0x78, 0x85, 0x9E, 0x72, 0xFC, 0xCC, 0xEE, 0x98,
47     0x25, 0x3B, 0x69, 0x6B, 0x0C, 0x11, 0xEA, 0x22, 0xB6, 0xD0, 0xCD, 0xBF,
48     0x6D, 0xBE, 0x12, 0xDE, 0xFE, 0x78, 0x2E, 0x54, 0xCB, 0xBA, 0xD7, 0x2E,
49     0x54, 0x25, 0x14, 0x84, 0xFE, 0x1A, 0x10, 0xCE, 0xCC, 0x20, 0xE6, 0xE2,
50     0x7F, 0xE0, 0x5F, 0xDB, 0xA7, 0xF3, 0xE2, 0x4C, 0x52, 0x82, 0xFC, 0x0B,
51     0xA0, 0xBD, 0x34, 0x21, 0xF7, 0xEB, 0x1C, 0x5B, 0x67, 0xD0, 0xAF, 0x22,
52     0x15, 0xA1, 0xFF, 0xC2, 0x68, 0x25, 0x5B, 0xB2, 0x13, 0x3F, 0xFF, 0x98,
53     0x53, 0x25, 0xC5, 0x58, 0x39, 0xD0, 0x43, 0x86, 0x6C, 0x5B, 0x57, 0x8E,
54     0x83, 0xBA, 0xB9, 0x09, 0x09, 0x14, 0x0C, 0x9E, 0x99, 0x83, 0x88, 0x53,
55     0x79, 0xFD, 0xF7, 0x49, 0xE9, 0x2C, 0xCE, 0xE6, 0x7B, 0xF5, 0xC2, 0x27,
56     0x5E, 0x56, 0xB5, 0xB4, 0x46, 0x90, 0x91, 0x7F, 0x99, 0x88, 0xA7, 0x23,
57     0xC1, 0x80, 0xB8, 0x2D, 0xCD, 0xF7, 0x6F, 0x9A, 0xEC, 0xBD, 0x16, 0x9F,
58     0x7D, 0x87, 0x1E, 0x15, 0x51, 0xC4, 0x96, 0xE2, 0xBF, 0x61, 0x66, 0xB5,
59     0xFD, 0x01, 0x67, 0xD6, 0xFF, 0xD2, 0x14, 0x20, 0x98, 0x8E, 0xEF, 0xF3,
60     0x22, 0xDB, 0x7E, 0xCE, 0x70, 0x2D, 0x4C, 0x06, 0x5A, 0xA0, 0x4F, 0xC8,
61     0xB0, 0x4D, 0xA6, 0x52, 0xB2, 0xD6, 0x2F, 0xD8, 0x57, 0xE5, 0xEF, 0xF9,
62     0xEE, 0x52, 0x0F, 0xEC, 0xC4, 0x90, 0x33, 0xAD, 0x25, 0xDA, 0xCD, 0x12,
63     0x44, 0x5F, 0x32, 0xF6, 0x6F, 0xEF, 0x85, 0xB8, 0xDC, 0x3C, 0x01, 0x48,
64     0x28, 0x5D, 0x2D, 0x9C, 0x9B, 0xC0, 0x49, 0x36, 0x1E, 0x6A, 0x0A, 0x0C,
65     0xB0, 0x6E, 0x81, 0x89, 0xCB, 0x0A, 0x89, 0xCF, 0x73, 0xC6, 0x63, 0x3D,
66     0x8E, 0x13, 0x57, 0x91, 0x4E, 0xA3, 0x93, 0x8C, 0x61, 0x67, 0xFD, 0x13,
67     0xE0, 0x14, 0x72, 0xB3, 0xE4, 0x23, 0x45, 0x08, 0x4E, 0x4E, 0xF5, 0xA7,
68     0xA8, 0xEE, 0x30, 0xFD, 0x81, 0x80, 0x1F, 0xF3, 0x4F, 0xD7, 0xE7, 0xF2,
69     0x16, 0xC0, 0xD6, 0x15, 0x6A, 0x0F, 0x89, 0x15, 0xA9, 0xCF, 0x35, 0x50,
70     0x6B, 0x49, 0x3E, 0x12, 0x4A, 0x72, 0xE4, 0x59, 0x9D, 0xD7, 0xDB, 0xD2,
71     0xD1, 0x61, 0x7D, 0x52, 0x4A, 0x36, 0xF6, 0xBA, 0x0E, 0xFA, 0x88, 0x6F,
72     0x3C, 0x82, 0x16, 0xF0, 0xD5, 0xED, 0x4D, 0x78, 0xEF, 0x38, 0x17, 0x90,
73     0xEA, 0x28, 0x32, 0xA9, 0x79, 0x40, 0xFF, 0xAA, 0xE6, 0xF5, 0xC7, 0x96,
74     0x56, 0x65, 0x61, 0x83, 0x3D, 0xBD, 0xD7, 0xED, 0xD6, 0xB6, 0xC0, 0xED,
75     0x34, 0xAA, 0x60, 0xA9, 0xE8, 0x82, 0x78, 0xEA, 0x69, 0xF6, 0x47, 0xAF,
76     0x39, 0xAB, 0x11, 0xDB, 0xE9, 0xFB, 0x68, 0x0C, 0xFE, 0xDF, 0x97, 0x9F,
77     0x3A, 0xF4, 0xF3, 0x32, 0x27, 0x30, 0x57, 0x0E, 0xF7, 0xB2, 0xEE, 0xFB,
78     0x1E, 0x98, 0xA8, 0xA3, 0x25, 0x45, 0xE4, 0x6D, 0x2D, 0xAE, 0xFE, 0xDA,
79     0xB3, 0x32, 0x9B, 0x5D, 0xF5, 0x32, 0x74, 0xEA, 0xE5, 0x02, 0x30, 0x53,
80     0x95, 0x13, 0x7A, 0x23, 0x1F, 0x10, 0x30, 0xEA, 0x78, 0xE4, 0x36, 0x1D,
81     0x92, 0x96, 0xB9, 0x91, 0x2D, 0xFA, 0x43, 0xAB, 0xE6, 0xEF, 0x14, 0x14,
82     0xC9, 0xBC, 0x46, 0xC6, 0x05, 0x7C, 0xC6, 0x11, 0x23, 0xCF, 0x3D, 0xC8,
83     0xBE, 0xEC, 0xA3, 0x58, 0x31, 0x55, 0x65, 0x14, 0xA7, 0x94, 0x93, 0xDD,
84     0x2D, 0x76, 0xC9, 0x66, 0x06, 0xBD, 0xF5, 0xE7, 0x30, 0x65, 0x42, 0x52,
85     0xA2, 0x50, 0x9B, 0xE6, 0x40, 0xA2, 0x4B, 0xEC, 0xA6, 0xB7, 0x39, 0xAA,
86     0xD7, 0x61, 0x2C, 0xBF, 0x37, 0x5A, 0xDA, 0xB3, 0x5D, 0x2F, 0x5D, 0x11,
87     0x82, 0x97, 0x32, 0x8A, 0xC1, 0xA1, 0x13, 0x20, 0x17, 0xBD, 0xA2, 0x91,
88     0x94, 0x2A, 0x4E, 0xBE, 0x3E, 0x77, 0x63, 0x67, 0x5C, 0x0A, 0xE1, 0x22,
89     0x0A, 0x4F, 0x63, 0xE2, 0x84, 0xE9, 0x9F, 0x14, 0x86, 0xE2, 0x4B, 0x20,
90     0x9F, 0x50, 0xB3, 0x56, 0xED, 0xDE, 0x39, 0xD8, 0x75, 0x64, 0x45, 0x54,
91     0xE5, 0x34, 0x57, 0x8C, 0x3B, 0xF2, 0x0E, 0x94, 0x1B, 0x10, 0xA2, 0xA2,
92     0x38, 0x76, 0x21, 0x8E, 0x2A, 0x57, 0x64, 0x58, 0x0A, 0x27, 0x6D, 0x4C,
93     0xD0, 0xB5, 0xC1, 0xFC, 0x75, 0xD0, 0x01, 0x86, 0x66, 0xA8, 0xF1, 0x98,
94     0x58, 0xFB, 0xFC, 0x64, 0xD2, 0x31, 0x77, 0xAD, 0x0E, 0x46, 0x87, 0xCC,
95     0x9B, 0x86, 0x90, 0xFF, 0xB6, 0x64, 0x35, 0xA5, 0x5D, 0x9E, 0x44, 0x51,
96     0x87, 0x9E, 0x1E, 0xEE, 0xF3, 0x3B, 0x5C, 0xDD, 0x94, 0x03, 0xAA, 0x18,
97     0x2C, 0xB7, 0xC4, 0x37, 0xD5, 0x53, 0x28, 0x60, 0xEF, 0x77, 0xEF, 0x3B,
98     0x9E, 0xD2, 0xCE, 0xE9, 0x53, 0x2D, 0xF5, 0x19, 0x7E, 0xBB, 0xB5, 0x46,
99     0xE2, 0xF7, 0xD6, 0x4D, 0x6D, 0x5B, 0x81, 0x56, 0x6B, 0x12, 0x55, 0x63,
100     0xC3, 0xAB, 0x08, 0xBB, 0x2E, 0xD5, 0x11, 0xBC, 0x18, 0xCB, 0x8B, 0x12,
101     0x2E, 0x3E, 0x75, 0x32, 0x98, 0x8A, 0xDE, 0x3C, 0xEA, 0x33, 0x46, 0xE7,
102     0x7A, 0xA5, 0x12, 0x09, 0x26, 0x7E, 0x7E, 0x03, 0x4F, 0xFD, 0xC0, 0xFD,
103     0xEA, 0x4F, 0x83, 0x85, 0x39, 0x62, 0xFB, 0xA2, 0x33, 0xD9, 0x2D, 0xB1,
104     0x30, 0x6F, 0x88, 0xAB, 0x61, 0xCB, 0x32, 0xEB, 0x30, 0xF9, 0x51, 0xF6,
105     0x1F, 0x3A, 0x11, 0x4D, 0xFD, 0x54, 0xD6, 0x3D, 0x43, 0x73, 0x39, 0x16,
106     0xCF, 0x3D, 0x29, 0x4A};
107 
108 TEST(FuzzedDataProvider, ConsumeBytes) {
109   FuzzedDataProvider DataProv(Data, sizeof(Data));
110   EXPECT_EQ(std::vector<unsigned char>(1, 0x8A),
111             DataProv.ConsumeBytes<unsigned char>(1));
112   EXPECT_EQ(std::vector<uint8_t>(
113                 {0x19, 0x0D, 0x44, 0x37, 0x0D, 0x38, 0x5E, 0x9B, 0xAA, 0xF3}),
114             DataProv.ConsumeBytes<uint8_t>(10));
115 
116   std::vector<unsigned char> UChars = DataProv.ConsumeBytes<unsigned char>(24);
117   EXPECT_EQ(std::vector<unsigned char>({0xDA, 0xAA, 0x88, 0xF2, 0x9B, 0x6C,
118                                         0xBA, 0xBE, 0xB1, 0xF2, 0xCF, 0x13,
119                                         0xB8, 0xAC, 0x1A, 0x7F, 0x1C, 0xC9,
120                                         0x90, 0xD0, 0xD9, 0x5C, 0x42, 0xB3}),
121             UChars);
122 
123   EXPECT_EQ(std::vector<signed char>(Data + 1 + 10 + 24, Data + sizeof(Data)),
124             DataProv.ConsumeBytes<signed char>(31337));
125 }
126 
127 TEST(FuzzedDataProvider, ConsumeBytesWithTerminator) {
128   FuzzedDataProvider DataProv(Data, sizeof(Data));
129   EXPECT_EQ(std::vector<unsigned char>({0x8A, 0x00}),
130             DataProv.ConsumeBytesWithTerminator<unsigned char>(1));
131   EXPECT_EQ(std::vector<uint8_t>({0x19, 0x0D, 0x44, 0x37, 0x0D, 0x38, 0x5E,
132                                   0x9B, 0xAA, 0xF3, 111}),
133             DataProv.ConsumeBytesWithTerminator<uint8_t>(10, 111));
134 
135   std::vector<unsigned char> UChars =
136       DataProv.ConsumeBytesWithTerminator<unsigned char>(24);
137   EXPECT_EQ(std::vector<unsigned char>(
138                 {0xDA, 0xAA, 0x88, 0xF2, 0x9B, 0x6C, 0xBA, 0xBE, 0xB1,
139                  0xF2, 0xCF, 0x13, 0xB8, 0xAC, 0x1A, 0x7F, 0x1C, 0xC9,
140                  0x90, 0xD0, 0xD9, 0x5C, 0x42, 0xB3, 0x00}),
141             UChars);
142 
143   std::vector<signed char> Expected(Data + 1 + 10 + 24, Data + sizeof(Data));
144   Expected.push_back(65);
145   EXPECT_EQ(Expected,
146             DataProv.ConsumeBytesWithTerminator<signed char>(31337, 65));
147 }
148 
149 TEST(FuzzedDataProvider, ConsumeBytesAsString) {
150   FuzzedDataProvider DataProv(Data, sizeof(Data));
151   EXPECT_EQ(std::string("\x8A\x19\x0D\x44\x37\x0D\x38\x5E\x9B\xAA\xF3\xDA"),
152             DataProv.ConsumeBytesAsString(12));
153   EXPECT_EQ(std::string(Data + 12, Data + sizeof(Data)),
154             DataProv.ConsumeBytesAsString(31337));
155 }
156 
157 TEST(FuzzedDataProvider, ConsumeIntegralInRange) {
158   FuzzedDataProvider DataProv(Data, sizeof(Data));
159   EXPECT_EQ(int32_t(21), DataProv.ConsumeIntegralInRange<int32_t>(10, 30));
160   EXPECT_EQ(int32_t(1337),
161             DataProv.ConsumeIntegralInRange<int32_t>(1337, 1337));
162   EXPECT_EQ(int8_t(-59), DataProv.ConsumeIntegralInRange<int8_t>(-100, 100));
163   EXPECT_EQ(uint16_t(15823),
164             DataProv.ConsumeIntegralInRange<uint16_t>(0, 65535));
165   EXPECT_EQ((signed char)(-101),
166             DataProv.ConsumeIntegralInRange<signed char>(-123, 123));
167   EXPECT_EQ(int64_t(-53253077544), DataProv.ConsumeIntegralInRange<int64_t>(
168                                        -99999999999, 99999999999));
169 
170   // Exhaust the buffer.
171   auto String = DataProv.ConsumeBytesAsString(31337);
172   EXPECT_EQ(size_t(1014), String.length());
173   EXPECT_EQ(uint64_t(123456789),
174             DataProv.ConsumeIntegralInRange<uint64_t>(123456789, 987654321));
175 }
176 
177 TEST(FuzzedDataProvider, ConsumeRandomLengthString) {
178   FuzzedDataProvider DataProv(Data, sizeof(Data));
179   EXPECT_EQ(
180       std::string(
181           "\x8A\x19\x0D\x44\x37\x0D\x38\x5E\x9B\xAA\xF3\xDA\xAA\x88\xF2\x9B\x6C"
182           "\xBA\xBE\xB1\xF2\xCF\x13\xB8\xAC\x1A\x7F\x1C\xC9\x90\xD0\xD9"),
183       DataProv.ConsumeRandomLengthString(1337));
184   EXPECT_EQ(std::string(
185                 "\xB3\xFD\xE3\x05\xA4\x03\x37\x49\x50\x4B\xBC\x39\xA2\x09\x6C"
186                 "\x2F\xAF\xD1\xB5\x47\xBF\x92\xBD\x79\xE5\xC5\x6E\x51\xA4\xED"
187                 "\xE9\xBD\x40\x4A\xFC\x25\x7A\x27\xC8\x92\xF7\x30\xDE\x40\x66"
188                 "\x66\xE8\x5F\x65\x39\x7E\x9E\x80\x2B\x01\x71\x2A\xFF\xD3\x0A"
189                 "\xAC\x6E\x49\x32\x79\x10\x6A\x6F\x97\x96\x70\x7E\x50\x65\xC9"
190                 "\x1D\xBD\x4E\x17\x04\x1E\xBA\x26\xAC\x1F\xE3\x37\x1C\x15\x43"
191                 "\x60\x41\x2A\x7C\xCA\x70\xCE\xAB\x20\x24\xF8\xD9\x1F\x14\x7C"),
192             DataProv.ConsumeRandomLengthString(31337));
193   size_t Offset = 141;
194   EXPECT_EQ(std::string(Data + Offset, Data + Offset + 5),
195             DataProv.ConsumeRandomLengthString(5));
196   Offset += 5;
197   EXPECT_EQ(std::string(Data + Offset, Data + Offset + 2),
198             DataProv.ConsumeRandomLengthString(2));
199   Offset += 2;
200 
201   // Call the overloaded method without arguments (uses max length available).
202   EXPECT_EQ(std::string(Data + Offset, Data + Offset + 664),
203             DataProv.ConsumeRandomLengthString());
204   Offset += 664 + 2; // +2 because of '\' character followed by any other byte.
205 
206   EXPECT_EQ(std::string(Data + Offset, Data + Offset + 92),
207             DataProv.ConsumeRandomLengthString());
208   Offset += 92 + 2;
209 
210   // Exhaust the buffer.
211   auto String = DataProv.ConsumeBytesAsString(31337);
212   EXPECT_EQ(size_t(116), String.length());
213   EXPECT_EQ(std::string(), DataProv.ConsumeRandomLengthString(1));
214 }
215 
216 TEST(FuzzedDataProvider, ConsumeRemainingBytes) {
217   {
218     FuzzedDataProvider DataProv(Data, sizeof(Data));
219     EXPECT_EQ(std::vector<uint8_t>(Data, Data + sizeof(Data)),
220               DataProv.ConsumeRemainingBytes<uint8_t>());
221     EXPECT_EQ(std::vector<uint8_t>(),
222               DataProv.ConsumeRemainingBytes<uint8_t>());
223   }
224 
225   {
226     FuzzedDataProvider DataProv(Data, sizeof(Data));
227     EXPECT_EQ(std::vector<uint8_t>(Data, Data + 123),
228               DataProv.ConsumeBytes<uint8_t>(123));
229     EXPECT_EQ(std::vector<char>(Data + 123, Data + sizeof(Data)),
230               DataProv.ConsumeRemainingBytes<char>());
231   }
232 }
233 
234 TEST(FuzzedDataProvider, ConsumeRemainingBytesAsString) {
235   {
236     FuzzedDataProvider DataProv(Data, sizeof(Data));
237     EXPECT_EQ(std::string(Data, Data + sizeof(Data)),
238               DataProv.ConsumeRemainingBytesAsString());
239     EXPECT_EQ(std::string(""), DataProv.ConsumeRemainingBytesAsString());
240   }
241 
242   {
243     FuzzedDataProvider DataProv(Data, sizeof(Data));
244     EXPECT_EQ(std::vector<uint8_t>(Data, Data + 123),
245               DataProv.ConsumeBytes<uint8_t>(123));
246     EXPECT_EQ(std::string(Data + 123, Data + sizeof(Data)),
247               DataProv.ConsumeRemainingBytesAsString());
248   }
249 }
250 
251 TEST(FuzzedDataProvider, ConsumeIntegral) {
252   FuzzedDataProvider DataProv(Data, sizeof(Data));
253   EXPECT_EQ(int32_t(-903266865), DataProv.ConsumeIntegral<int32_t>());
254   EXPECT_EQ(uint32_t(372863811), DataProv.ConsumeIntegral<uint32_t>());
255   EXPECT_EQ(uint8_t(61), DataProv.ConsumeIntegral<uint8_t>());
256   EXPECT_EQ(int16_t(22100), DataProv.ConsumeIntegral<int16_t>());
257   EXPECT_EQ(uint64_t(18252263806144500217u),
258             DataProv.ConsumeIntegral<uint64_t>());
259 
260   // Exhaust the buffer.
261   auto String = DataProv.ConsumeBytesAsString(31337);
262   EXPECT_EQ(size_t(1005), String.length());
263   EXPECT_EQ(std::numeric_limits<int64_t>::min(),
264             DataProv.ConsumeIntegral<int64_t>());
265 }
266 
267 TEST(FuzzedDataProvider, ConsumeBool) {
268   FuzzedDataProvider DataProv(Data, sizeof(Data));
269   EXPECT_EQ(false, DataProv.ConsumeBool());
270   EXPECT_EQ(true, DataProv.ConsumeBool());
271   EXPECT_EQ(true, DataProv.ConsumeBool());
272   EXPECT_EQ(true, DataProv.ConsumeBool());
273   EXPECT_EQ(false, DataProv.ConsumeBool());
274   EXPECT_EQ(true, DataProv.ConsumeBool());
275   EXPECT_EQ(true, DataProv.ConsumeBool());
276   EXPECT_EQ(true, DataProv.ConsumeBool());
277   EXPECT_EQ(true, DataProv.ConsumeBool());
278   EXPECT_EQ(false, DataProv.ConsumeBool());
279 
280   // Exhaust the buffer.
281   auto String = DataProv.ConsumeBytesAsString(31337);
282   EXPECT_EQ(size_t(1014), String.length());
283   EXPECT_EQ(false, DataProv.ConsumeBool());
284 }
285 
286 TEST(FuzzedDataProvider, PickValueInArray) {
287   FuzzedDataProvider DataProv(Data, sizeof(Data));
288   const int Array[] = {1, 2, 3, 4, 5};
289   EXPECT_EQ(5, DataProv.PickValueInArray(Array));
290   EXPECT_EQ(2, DataProv.PickValueInArray(Array));
291   EXPECT_EQ(2, DataProv.PickValueInArray(Array));
292   EXPECT_EQ(3, DataProv.PickValueInArray(Array));
293   EXPECT_EQ(3, DataProv.PickValueInArray(Array));
294   EXPECT_EQ(3, DataProv.PickValueInArray(Array));
295   EXPECT_EQ(1, DataProv.PickValueInArray(Array));
296   EXPECT_EQ(3, DataProv.PickValueInArray(Array));
297   EXPECT_EQ(2, DataProv.PickValueInArray(Array));
298 
299   EXPECT_EQ(uint8_t(0x9D), DataProv.PickValueInArray(Data));
300   EXPECT_EQ(uint8_t(0xBA), DataProv.PickValueInArray(Data));
301   EXPECT_EQ(uint8_t(0x69), DataProv.PickValueInArray(Data));
302   EXPECT_EQ(uint8_t(0xD6), DataProv.PickValueInArray(Data));
303 
304   EXPECT_EQ(uint32_t(777), DataProv.PickValueInArray<uint32_t>({1337, 777}));
305   EXPECT_EQ(uint32_t(777), DataProv.PickValueInArray<uint32_t>({1337, 777}));
306   EXPECT_EQ(uint64_t(1337), DataProv.PickValueInArray<uint64_t>({1337, 777}));
307   EXPECT_EQ(size_t(777), DataProv.PickValueInArray<size_t>({1337, 777}));
308   EXPECT_EQ(int16_t(1337), DataProv.PickValueInArray<int16_t>({1337, 777}));
309   EXPECT_EQ(int32_t(777), DataProv.PickValueInArray<int32_t>({1337, 777}));
310   EXPECT_EQ(int64_t(777), DataProv.PickValueInArray<int64_t>({1337, 777}));
311 
312   // Exhaust the buffer.
313   auto String = DataProv.ConsumeBytesAsString(31337);
314   EXPECT_EQ(size_t(1000), String.length());
315   EXPECT_EQ(uint8_t(0x8A), DataProv.PickValueInArray(Data));
316 }
317 
318 TEST(FuzzedDataProvider, ConsumeEnum) {
319   FuzzedDataProvider DataProv(Data, sizeof(Data));
320   enum class Enum {
321     Zero,
322     One,
323     Two,
324     Three,
325     Four,
326     Five,
327     Six,
328     Seven,
329     kMaxValue = Seven
330   };
331   EXPECT_EQ(Enum::Two, DataProv.ConsumeEnum<Enum>());
332   EXPECT_EQ(Enum::One, DataProv.ConsumeEnum<Enum>());
333   EXPECT_EQ(Enum::Five, DataProv.ConsumeEnum<Enum>());
334   EXPECT_EQ(Enum::Seven, DataProv.ConsumeEnum<Enum>());
335   EXPECT_EQ(Enum::Six, DataProv.ConsumeEnum<Enum>());
336   EXPECT_EQ(Enum::One, DataProv.ConsumeEnum<Enum>());
337   EXPECT_EQ(Enum::Three, DataProv.ConsumeEnum<Enum>());
338   EXPECT_EQ(Enum::Three, DataProv.ConsumeEnum<Enum>());
339   EXPECT_EQ(Enum::Five, DataProv.ConsumeEnum<Enum>());
340   EXPECT_EQ(Enum::Six, DataProv.ConsumeEnum<Enum>());
341 
342   // Exhaust the buffer.
343   auto String = DataProv.ConsumeBytesAsString(31337);
344   EXPECT_EQ(size_t(1014), String.length());
345   EXPECT_EQ(Enum::Zero, DataProv.ConsumeEnum<Enum>());
346 }
347 
348 TEST(FuzzedDataProvider, remaining_bytes) {
349   FuzzedDataProvider DataProv(Data, sizeof(Data));
350   EXPECT_EQ(size_t(1024), DataProv.remaining_bytes());
351   EXPECT_EQ(false, DataProv.ConsumeBool());
352   EXPECT_EQ(size_t(1024 - 1), DataProv.remaining_bytes());
353   EXPECT_EQ(std::vector<uint8_t>(Data, Data + 8),
354             DataProv.ConsumeBytes<uint8_t>(8));
355   EXPECT_EQ(size_t(1024 - 1 - 8), DataProv.remaining_bytes());
356 
357   // Exhaust the buffer.
358   EXPECT_EQ(std::vector<uint8_t>(Data + 8, Data + sizeof(Data) - 1),
359             DataProv.ConsumeRemainingBytes<uint8_t>());
360   EXPECT_EQ(size_t(0), DataProv.remaining_bytes());
361 }
362 
363 TEST(FuzzedDataProvider, ConsumeProbability) {
364   FuzzedDataProvider DataProv(Data, sizeof(Data));
365   ASSERT_FLOAT_EQ(float(0.28969181), DataProv.ConsumeProbability<float>());
366   ASSERT_DOUBLE_EQ(double(0.086814121166605432),
367                    DataProv.ConsumeProbability<double>());
368   ASSERT_FLOAT_EQ(float(0.30104411), DataProv.ConsumeProbability<float>());
369   ASSERT_DOUBLE_EQ(double(0.96218831486039413),
370                    DataProv.ConsumeProbability<double>());
371   ASSERT_FLOAT_EQ(float(0.67005056), DataProv.ConsumeProbability<float>());
372   ASSERT_DOUBLE_EQ(double(0.69210584173832279),
373                    DataProv.ConsumeProbability<double>());
374 
375   // Exhaust the buffer.
376   EXPECT_EQ(std::vector<uint8_t>(Data, Data + sizeof(Data) - 36),
377             DataProv.ConsumeRemainingBytes<uint8_t>());
378   ASSERT_FLOAT_EQ(float(0.0), DataProv.ConsumeProbability<float>());
379 }
380 
381 TEST(FuzzedDataProvider, ConsumeFloatingPoint) {
382   FuzzedDataProvider DataProv(Data, sizeof(Data));
383   ASSERT_FLOAT_EQ(float(-2.8546307e+38),
384                   DataProv.ConsumeFloatingPoint<float>());
385   ASSERT_DOUBLE_EQ(double(8.0940194040236032e+307),
386                    DataProv.ConsumeFloatingPoint<double>());
387   ASSERT_FLOAT_EQ(float(271.49084),
388                   DataProv.ConsumeFloatingPointInRange<float>(123.0, 777.0));
389   ASSERT_DOUBLE_EQ(double(30.859126145478349),
390                    DataProv.ConsumeFloatingPointInRange<double>(13.37, 31.337));
391   ASSERT_FLOAT_EQ(
392       float(-903.47729),
393       DataProv.ConsumeFloatingPointInRange<float>(-999.9999, -777.77));
394   ASSERT_DOUBLE_EQ(
395       double(24.561393182922771),
396       DataProv.ConsumeFloatingPointInRange<double>(-13.37, 31.337));
397   ASSERT_FLOAT_EQ(float(1.0),
398                   DataProv.ConsumeFloatingPointInRange<float>(1.0, 1.0));
399   ASSERT_DOUBLE_EQ(double(-1.0),
400                    DataProv.ConsumeFloatingPointInRange<double>(-1.0, -1.0));
401 
402   // Exhaust the buffer.
403   EXPECT_EQ((std::vector<uint8_t>(Data, Data + sizeof(Data) - 50)).size(),
404             DataProv.ConsumeRemainingBytes<uint8_t>().size());
405   ASSERT_FLOAT_EQ(float(0.0), DataProv.ConsumeProbability<float>());
406   ASSERT_NEAR(std::numeric_limits<double>::lowest(),
407               DataProv.ConsumeFloatingPoint<double>(), 1e-10);
408   ASSERT_FLOAT_EQ(float(123.0),
409                   DataProv.ConsumeFloatingPointInRange<float>(123.0, 777.0));
410   ASSERT_DOUBLE_EQ(double(-13.37), DataProv.ConsumeFloatingPointInRange<double>(
411                                        -13.37, 31.337));
412 }
413 
414 TEST(FuzzedDataProvider, ConsumeData) {
415   FuzzedDataProvider DataProv(Data, sizeof(Data));
416   uint8_t Buffer[10] = {};
417   EXPECT_EQ(sizeof(Buffer), DataProv.ConsumeData(Buffer, sizeof(Buffer)));
418   std::vector<uint8_t> Expected(Data, Data + sizeof(Buffer));
419   EXPECT_EQ(Expected, std::vector<uint8_t>(Buffer, Buffer + sizeof(Buffer)));
420 
421   EXPECT_EQ(size_t(2), DataProv.ConsumeData(Buffer, 2));
422   Expected[0] = Data[sizeof(Buffer)];
423   Expected[1] = Data[sizeof(Buffer) + 1];
424   EXPECT_EQ(Expected, std::vector<uint8_t>(Buffer, Buffer + sizeof(Buffer)));
425 
426   // Exhaust the buffer.
427   EXPECT_EQ(std::vector<uint8_t>(Data + 12, Data + sizeof(Data)),
428             DataProv.ConsumeRemainingBytes<uint8_t>());
429   EXPECT_EQ(size_t(0), DataProv.ConsumeData(Buffer, sizeof(Buffer)));
430   EXPECT_EQ(Expected, std::vector<uint8_t>(Buffer, Buffer + sizeof(Buffer)));
431 }
432 
433 int main(int argc, char **argv) {
434   testing::InitGoogleTest(&argc, argv);
435   return RUN_ALL_TESTS();
436 }
437