Coverage Report

Created: 2025-12-14 06:55

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/fmt/test/fuzzing/chrono-duration.cc
Line
Count
Source
1
// Copyright (c) 2019, Paul Dreik
2
// For the license information refer to format.h.
3
4
#include <fmt/chrono.h>
5
6
#include <cstdint>
7
8
#include "fuzzer-common.h"
9
10
template <typename Period, typename Rep>
11
58.6k
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
58.6k
  auto value = std::chrono::duration<Rep, Period>(rep);
13
58.6k
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
58.6k
    auto buf = fmt::memory_buffer();
18
58.6k
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
58.6k
#endif
20
58.6k
  } catch (std::exception&) {
21
53.1k
  }
22
58.6k
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
270
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
270
  auto value = std::chrono::duration<Rep, Period>(rep);
13
270
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
270
    auto buf = fmt::memory_buffer();
18
270
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
270
#endif
20
270
  } catch (std::exception&) {
21
239
  }
22
270
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
245
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
245
  auto value = std::chrono::duration<Rep, Period>(rep);
13
245
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
245
    auto buf = fmt::memory_buffer();
18
245
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
245
#endif
20
245
  } catch (std::exception&) {
21
231
  }
22
245
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
254
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
254
  auto value = std::chrono::duration<Rep, Period>(rep);
13
254
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
254
    auto buf = fmt::memory_buffer();
18
254
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
254
#endif
20
254
  } catch (std::exception&) {
21
231
  }
22
254
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
248
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
248
  auto value = std::chrono::duration<Rep, Period>(rep);
13
248
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
248
    auto buf = fmt::memory_buffer();
18
248
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
248
#endif
20
248
  } catch (std::exception&) {
21
216
  }
22
248
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
254
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
254
  auto value = std::chrono::duration<Rep, Period>(rep);
13
254
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
254
    auto buf = fmt::memory_buffer();
18
254
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
254
#endif
20
254
  } catch (std::exception&) {
21
222
  }
22
254
}
void invoke_inner<std::__1::ratio<1l, 1000l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
248
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
248
  auto value = std::chrono::duration<Rep, Period>(rep);
13
248
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
248
    auto buf = fmt::memory_buffer();
18
248
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
248
#endif
20
248
  } catch (std::exception&) {
21
217
  }
22
248
}
void invoke_inner<std::__1::ratio<1l, 100l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
257
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
257
  auto value = std::chrono::duration<Rep, Period>(rep);
13
257
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
257
    auto buf = fmt::memory_buffer();
18
257
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
257
#endif
20
257
  } catch (std::exception&) {
21
240
  }
22
257
}
void invoke_inner<std::__1::ratio<1l, 10l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
233
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
233
  auto value = std::chrono::duration<Rep, Period>(rep);
13
233
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
233
    auto buf = fmt::memory_buffer();
18
233
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
233
#endif
20
233
  } catch (std::exception&) {
21
207
  }
22
233
}
void invoke_inner<std::__1::ratio<10l, 1l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
310
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
310
  auto value = std::chrono::duration<Rep, Period>(rep);
13
310
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
310
    auto buf = fmt::memory_buffer();
18
310
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
310
#endif
20
310
  } catch (std::exception&) {
21
282
  }
22
310
}
void invoke_inner<std::__1::ratio<1000l, 1l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
302
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
302
  auto value = std::chrono::duration<Rep, Period>(rep);
13
302
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
302
    auto buf = fmt::memory_buffer();
18
302
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
302
#endif
20
302
  } catch (std::exception&) {
21
279
  }
22
302
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
316
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
316
  auto value = std::chrono::duration<Rep, Period>(rep);
13
316
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
316
    auto buf = fmt::memory_buffer();
18
316
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
316
#endif
20
316
  } catch (std::exception&) {
21
286
  }
22
316
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
289
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
289
  auto value = std::chrono::duration<Rep, Period>(rep);
13
289
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
289
    auto buf = fmt::memory_buffer();
18
289
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
289
#endif
20
289
  } catch (std::exception&) {
21
272
  }
22
289
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
249
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
249
  auto value = std::chrono::duration<Rep, Period>(rep);
13
249
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
249
    auto buf = fmt::memory_buffer();
18
249
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
249
#endif
20
249
  } catch (std::exception&) {
21
232
  }
22
249
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
271
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
271
  auto value = std::chrono::duration<Rep, Period>(rep);
13
271
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
271
    auto buf = fmt::memory_buffer();
18
271
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
271
#endif
20
271
  } catch (std::exception&) {
21
246
  }
22
271
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
246
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
246
  auto value = std::chrono::duration<Rep, Period>(rep);
13
246
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
246
    auto buf = fmt::memory_buffer();
18
246
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
246
#endif
20
246
  } catch (std::exception&) {
21
219
  }
22
246
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
273
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
273
  auto value = std::chrono::duration<Rep, Period>(rep);
13
273
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
273
    auto buf = fmt::memory_buffer();
18
273
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
273
#endif
20
273
  } catch (std::exception&) {
21
248
  }
22
273
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
267
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
267
  auto value = std::chrono::duration<Rep, Period>(rep);
13
267
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
267
    auto buf = fmt::memory_buffer();
18
267
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
267
#endif
20
267
  } catch (std::exception&) {
21
243
  }
22
267
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
266
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
266
  auto value = std::chrono::duration<Rep, Period>(rep);
13
266
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
266
    auto buf = fmt::memory_buffer();
18
266
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
266
#endif
20
266
  } catch (std::exception&) {
21
245
  }
22
266
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
252
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
252
  auto value = std::chrono::duration<Rep, Period>(rep);
13
252
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
252
    auto buf = fmt::memory_buffer();
18
252
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
252
#endif
20
252
  } catch (std::exception&) {
21
231
  }
22
252
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
259
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
259
  auto value = std::chrono::duration<Rep, Period>(rep);
13
259
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
259
    auto buf = fmt::memory_buffer();
18
259
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
259
#endif
20
259
  } catch (std::exception&) {
21
227
  }
22
259
}
void invoke_inner<std::__1::ratio<1l, 1000l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
250
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
250
  auto value = std::chrono::duration<Rep, Period>(rep);
13
250
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
250
    auto buf = fmt::memory_buffer();
18
250
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
250
#endif
20
250
  } catch (std::exception&) {
21
229
  }
22
250
}
void invoke_inner<std::__1::ratio<1l, 100l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
257
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
257
  auto value = std::chrono::duration<Rep, Period>(rep);
13
257
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
257
    auto buf = fmt::memory_buffer();
18
257
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
257
#endif
20
257
  } catch (std::exception&) {
21
226
  }
22
257
}
void invoke_inner<std::__1::ratio<1l, 10l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
283
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
283
  auto value = std::chrono::duration<Rep, Period>(rep);
13
283
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
283
    auto buf = fmt::memory_buffer();
18
283
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
283
#endif
20
283
  } catch (std::exception&) {
21
257
  }
22
283
}
void invoke_inner<std::__1::ratio<10l, 1l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
330
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
330
  auto value = std::chrono::duration<Rep, Period>(rep);
13
330
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
330
    auto buf = fmt::memory_buffer();
18
330
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
330
#endif
20
330
  } catch (std::exception&) {
21
303
  }
22
330
}
void invoke_inner<std::__1::ratio<1000l, 1l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
304
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
304
  auto value = std::chrono::duration<Rep, Period>(rep);
13
304
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
304
    auto buf = fmt::memory_buffer();
18
304
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
304
#endif
20
304
  } catch (std::exception&) {
21
270
  }
22
304
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
328
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
328
  auto value = std::chrono::duration<Rep, Period>(rep);
13
328
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
328
    auto buf = fmt::memory_buffer();
18
328
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
328
#endif
20
328
  } catch (std::exception&) {
21
292
  }
22
328
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
319
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
319
  auto value = std::chrono::duration<Rep, Period>(rep);
13
319
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
319
    auto buf = fmt::memory_buffer();
18
319
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
319
#endif
20
319
  } catch (std::exception&) {
21
281
  }
22
319
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
251
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
251
  auto value = std::chrono::duration<Rep, Period>(rep);
13
251
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
251
    auto buf = fmt::memory_buffer();
18
251
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
251
#endif
20
251
  } catch (std::exception&) {
21
220
  }
22
251
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
247
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
247
  auto value = std::chrono::duration<Rep, Period>(rep);
13
247
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
247
    auto buf = fmt::memory_buffer();
18
247
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
247
#endif
20
247
  } catch (std::exception&) {
21
224
  }
22
247
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
253
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
253
  auto value = std::chrono::duration<Rep, Period>(rep);
13
253
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
253
    auto buf = fmt::memory_buffer();
18
253
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
253
#endif
20
253
  } catch (std::exception&) {
21
231
  }
22
253
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
237
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
237
  auto value = std::chrono::duration<Rep, Period>(rep);
13
237
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
237
    auto buf = fmt::memory_buffer();
18
237
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
237
#endif
20
237
  } catch (std::exception&) {
21
205
  }
22
237
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
243
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
243
  auto value = std::chrono::duration<Rep, Period>(rep);
13
243
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
243
    auto buf = fmt::memory_buffer();
18
243
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
243
#endif
20
243
  } catch (std::exception&) {
21
216
  }
22
243
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
242
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
242
  auto value = std::chrono::duration<Rep, Period>(rep);
13
242
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
242
    auto buf = fmt::memory_buffer();
18
242
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
242
#endif
20
242
  } catch (std::exception&) {
21
215
  }
22
242
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
240
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
240
  auto value = std::chrono::duration<Rep, Period>(rep);
13
240
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
240
    auto buf = fmt::memory_buffer();
18
240
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
240
#endif
20
240
  } catch (std::exception&) {
21
217
  }
22
240
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
216
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
216
  auto value = std::chrono::duration<Rep, Period>(rep);
13
216
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
216
    auto buf = fmt::memory_buffer();
18
216
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
216
#endif
20
216
  } catch (std::exception&) {
21
199
  }
22
216
}
void invoke_inner<std::__1::ratio<1l, 1000l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
239
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
239
  auto value = std::chrono::duration<Rep, Period>(rep);
13
239
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
239
    auto buf = fmt::memory_buffer();
18
239
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
239
#endif
20
239
  } catch (std::exception&) {
21
215
  }
22
239
}
void invoke_inner<std::__1::ratio<1l, 100l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
222
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
222
  auto value = std::chrono::duration<Rep, Period>(rep);
13
222
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
222
    auto buf = fmt::memory_buffer();
18
222
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
222
#endif
20
222
  } catch (std::exception&) {
21
200
  }
22
222
}
void invoke_inner<std::__1::ratio<1l, 10l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
228
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
228
  auto value = std::chrono::duration<Rep, Period>(rep);
13
228
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
228
    auto buf = fmt::memory_buffer();
18
228
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
228
#endif
20
228
  } catch (std::exception&) {
21
214
  }
22
228
}
void invoke_inner<std::__1::ratio<10l, 1l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
283
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
283
  auto value = std::chrono::duration<Rep, Period>(rep);
13
283
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
283
    auto buf = fmt::memory_buffer();
18
283
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
283
#endif
20
283
  } catch (std::exception&) {
21
254
  }
22
283
}
void invoke_inner<std::__1::ratio<1000l, 1l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
299
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
299
  auto value = std::chrono::duration<Rep, Period>(rep);
13
299
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
299
    auto buf = fmt::memory_buffer();
18
299
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
299
#endif
20
299
  } catch (std::exception&) {
21
271
  }
22
299
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
277
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
277
  auto value = std::chrono::duration<Rep, Period>(rep);
13
277
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
277
    auto buf = fmt::memory_buffer();
18
277
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
277
#endif
20
277
  } catch (std::exception&) {
21
248
  }
22
277
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
281
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
281
  auto value = std::chrono::duration<Rep, Period>(rep);
13
281
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
281
    auto buf = fmt::memory_buffer();
18
281
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
281
#endif
20
281
  } catch (std::exception&) {
21
244
  }
22
281
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
259
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
259
  auto value = std::chrono::duration<Rep, Period>(rep);
13
259
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
259
    auto buf = fmt::memory_buffer();
18
259
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
259
#endif
20
259
  } catch (std::exception&) {
21
233
  }
22
259
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
242
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
242
  auto value = std::chrono::duration<Rep, Period>(rep);
13
242
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
242
    auto buf = fmt::memory_buffer();
18
242
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
242
#endif
20
242
  } catch (std::exception&) {
21
220
  }
22
242
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
248
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
248
  auto value = std::chrono::duration<Rep, Period>(rep);
13
248
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
248
    auto buf = fmt::memory_buffer();
18
248
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
248
#endif
20
248
  } catch (std::exception&) {
21
219
  }
22
248
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
280
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
280
  auto value = std::chrono::duration<Rep, Period>(rep);
13
280
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
280
    auto buf = fmt::memory_buffer();
18
280
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
280
#endif
20
280
  } catch (std::exception&) {
21
259
  }
22
280
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
258
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
258
  auto value = std::chrono::duration<Rep, Period>(rep);
13
258
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
258
    auto buf = fmt::memory_buffer();
18
258
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
258
#endif
20
258
  } catch (std::exception&) {
21
218
  }
22
258
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
266
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
266
  auto value = std::chrono::duration<Rep, Period>(rep);
13
266
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
266
    auto buf = fmt::memory_buffer();
18
266
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
266
#endif
20
266
  } catch (std::exception&) {
21
238
  }
22
266
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
264
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
264
  auto value = std::chrono::duration<Rep, Period>(rep);
13
264
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
264
    auto buf = fmt::memory_buffer();
18
264
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
264
#endif
20
264
  } catch (std::exception&) {
21
236
  }
22
264
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
265
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
265
  auto value = std::chrono::duration<Rep, Period>(rep);
13
265
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
265
    auto buf = fmt::memory_buffer();
18
265
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
265
#endif
20
265
  } catch (std::exception&) {
21
236
  }
22
265
}
void invoke_inner<std::__1::ratio<1l, 1000l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
269
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
269
  auto value = std::chrono::duration<Rep, Period>(rep);
13
269
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
269
    auto buf = fmt::memory_buffer();
18
269
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
269
#endif
20
269
  } catch (std::exception&) {
21
250
  }
22
269
}
void invoke_inner<std::__1::ratio<1l, 100l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
275
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
275
  auto value = std::chrono::duration<Rep, Period>(rep);
13
275
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
275
    auto buf = fmt::memory_buffer();
18
275
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
275
#endif
20
275
  } catch (std::exception&) {
21
250
  }
22
275
}
void invoke_inner<std::__1::ratio<1l, 10l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
270
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
270
  auto value = std::chrono::duration<Rep, Period>(rep);
13
270
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
270
    auto buf = fmt::memory_buffer();
18
270
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
270
#endif
20
270
  } catch (std::exception&) {
21
255
  }
22
270
}
void invoke_inner<std::__1::ratio<10l, 1l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
318
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
318
  auto value = std::chrono::duration<Rep, Period>(rep);
13
318
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
318
    auto buf = fmt::memory_buffer();
18
318
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
318
#endif
20
318
  } catch (std::exception&) {
21
291
  }
22
318
}
void invoke_inner<std::__1::ratio<1000l, 1l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
313
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
313
  auto value = std::chrono::duration<Rep, Period>(rep);
13
313
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
313
    auto buf = fmt::memory_buffer();
18
313
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
313
#endif
20
313
  } catch (std::exception&) {
21
282
  }
22
313
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
319
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
319
  auto value = std::chrono::duration<Rep, Period>(rep);
13
319
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
319
    auto buf = fmt::memory_buffer();
18
319
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
319
#endif
20
319
  } catch (std::exception&) {
21
295
  }
22
319
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
336
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
336
  auto value = std::chrono::duration<Rep, Period>(rep);
13
336
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
336
    auto buf = fmt::memory_buffer();
18
336
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
336
#endif
20
336
  } catch (std::exception&) {
21
305
  }
22
336
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
266
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
266
  auto value = std::chrono::duration<Rep, Period>(rep);
13
266
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
266
    auto buf = fmt::memory_buffer();
18
266
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
266
#endif
20
266
  } catch (std::exception&) {
21
235
  }
22
266
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
261
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
261
  auto value = std::chrono::duration<Rep, Period>(rep);
13
261
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
261
    auto buf = fmt::memory_buffer();
18
261
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
261
#endif
20
261
  } catch (std::exception&) {
21
234
  }
22
261
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
239
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
239
  auto value = std::chrono::duration<Rep, Period>(rep);
13
239
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
239
    auto buf = fmt::memory_buffer();
18
239
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
239
#endif
20
239
  } catch (std::exception&) {
21
216
  }
22
239
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
239
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
239
  auto value = std::chrono::duration<Rep, Period>(rep);
13
239
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
239
    auto buf = fmt::memory_buffer();
18
239
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
239
#endif
20
239
  } catch (std::exception&) {
21
214
  }
22
239
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
251
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
251
  auto value = std::chrono::duration<Rep, Period>(rep);
13
251
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
251
    auto buf = fmt::memory_buffer();
18
251
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
251
#endif
20
251
  } catch (std::exception&) {
21
228
  }
22
251
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
240
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
240
  auto value = std::chrono::duration<Rep, Period>(rep);
13
240
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
240
    auto buf = fmt::memory_buffer();
18
240
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
240
#endif
20
240
  } catch (std::exception&) {
21
226
  }
22
240
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
235
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
235
  auto value = std::chrono::duration<Rep, Period>(rep);
13
235
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
235
    auto buf = fmt::memory_buffer();
18
235
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
235
#endif
20
235
  } catch (std::exception&) {
21
222
  }
22
235
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
238
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
238
  auto value = std::chrono::duration<Rep, Period>(rep);
13
238
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
238
    auto buf = fmt::memory_buffer();
18
238
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
238
#endif
20
238
  } catch (std::exception&) {
21
219
  }
22
238
}
void invoke_inner<std::__1::ratio<1l, 1000l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
250
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
250
  auto value = std::chrono::duration<Rep, Period>(rep);
13
250
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
250
    auto buf = fmt::memory_buffer();
18
250
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
250
#endif
20
250
  } catch (std::exception&) {
21
222
  }
22
250
}
void invoke_inner<std::__1::ratio<1l, 100l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
230
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
230
  auto value = std::chrono::duration<Rep, Period>(rep);
13
230
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
230
    auto buf = fmt::memory_buffer();
18
230
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
230
#endif
20
230
  } catch (std::exception&) {
21
205
  }
22
230
}
void invoke_inner<std::__1::ratio<1l, 10l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
231
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
231
  auto value = std::chrono::duration<Rep, Period>(rep);
13
231
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
231
    auto buf = fmt::memory_buffer();
18
231
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
231
#endif
20
231
  } catch (std::exception&) {
21
212
  }
22
231
}
void invoke_inner<std::__1::ratio<10l, 1l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
302
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
302
  auto value = std::chrono::duration<Rep, Period>(rep);
13
302
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
302
    auto buf = fmt::memory_buffer();
18
302
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
302
#endif
20
302
  } catch (std::exception&) {
21
277
  }
22
302
}
void invoke_inner<std::__1::ratio<1000l, 1l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
310
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
310
  auto value = std::chrono::duration<Rep, Period>(rep);
13
310
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
310
    auto buf = fmt::memory_buffer();
18
310
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
310
#endif
20
310
  } catch (std::exception&) {
21
279
  }
22
310
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
278
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
278
  auto value = std::chrono::duration<Rep, Period>(rep);
13
278
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
278
    auto buf = fmt::memory_buffer();
18
278
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
278
#endif
20
278
  } catch (std::exception&) {
21
245
  }
22
278
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
285
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
285
  auto value = std::chrono::duration<Rep, Period>(rep);
13
285
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
285
    auto buf = fmt::memory_buffer();
18
285
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
285
#endif
20
285
  } catch (std::exception&) {
21
259
  }
22
285
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
255
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
255
  auto value = std::chrono::duration<Rep, Period>(rep);
13
255
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
255
    auto buf = fmt::memory_buffer();
18
255
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
255
#endif
20
255
  } catch (std::exception&) {
21
232
  }
22
255
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
253
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
253
  auto value = std::chrono::duration<Rep, Period>(rep);
13
253
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
253
    auto buf = fmt::memory_buffer();
18
253
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
253
#endif
20
253
  } catch (std::exception&) {
21
219
  }
22
253
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
234
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
234
  auto value = std::chrono::duration<Rep, Period>(rep);
13
234
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
234
    auto buf = fmt::memory_buffer();
18
234
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
234
#endif
20
234
  } catch (std::exception&) {
21
217
  }
22
234
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
291
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
291
  auto value = std::chrono::duration<Rep, Period>(rep);
13
291
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
291
    auto buf = fmt::memory_buffer();
18
291
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
291
#endif
20
291
  } catch (std::exception&) {
21
250
  }
22
291
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
276
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
276
  auto value = std::chrono::duration<Rep, Period>(rep);
13
276
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
276
    auto buf = fmt::memory_buffer();
18
276
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
276
#endif
20
276
  } catch (std::exception&) {
21
248
  }
22
276
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
287
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
287
  auto value = std::chrono::duration<Rep, Period>(rep);
13
287
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
287
    auto buf = fmt::memory_buffer();
18
287
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
287
#endif
20
287
  } catch (std::exception&) {
21
263
  }
22
287
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
297
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
297
  auto value = std::chrono::duration<Rep, Period>(rep);
13
297
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
297
    auto buf = fmt::memory_buffer();
18
297
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
297
#endif
20
297
  } catch (std::exception&) {
21
258
  }
22
297
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
279
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
279
  auto value = std::chrono::duration<Rep, Period>(rep);
13
279
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
279
    auto buf = fmt::memory_buffer();
18
279
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
279
#endif
20
279
  } catch (std::exception&) {
21
243
  }
22
279
}
void invoke_inner<std::__1::ratio<1l, 1000l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
294
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
294
  auto value = std::chrono::duration<Rep, Period>(rep);
13
294
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
294
    auto buf = fmt::memory_buffer();
18
294
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
294
#endif
20
294
  } catch (std::exception&) {
21
277
  }
22
294
}
void invoke_inner<std::__1::ratio<1l, 100l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
299
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
299
  auto value = std::chrono::duration<Rep, Period>(rep);
13
299
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
299
    auto buf = fmt::memory_buffer();
18
299
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
299
#endif
20
299
  } catch (std::exception&) {
21
273
  }
22
299
}
void invoke_inner<std::__1::ratio<1l, 10l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
287
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
287
  auto value = std::chrono::duration<Rep, Period>(rep);
13
287
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
287
    auto buf = fmt::memory_buffer();
18
287
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
287
#endif
20
287
  } catch (std::exception&) {
21
261
  }
22
287
}
void invoke_inner<std::__1::ratio<10l, 1l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
343
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
343
  auto value = std::chrono::duration<Rep, Period>(rep);
13
343
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
343
    auto buf = fmt::memory_buffer();
18
343
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
343
#endif
20
343
  } catch (std::exception&) {
21
311
  }
22
343
}
void invoke_inner<std::__1::ratio<1000l, 1l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
328
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
328
  auto value = std::chrono::duration<Rep, Period>(rep);
13
328
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
328
    auto buf = fmt::memory_buffer();
18
328
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
328
#endif
20
328
  } catch (std::exception&) {
21
311
  }
22
328
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
344
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
344
  auto value = std::chrono::duration<Rep, Period>(rep);
13
344
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
344
    auto buf = fmt::memory_buffer();
18
344
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
344
#endif
20
344
  } catch (std::exception&) {
21
317
  }
22
344
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
336
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
336
  auto value = std::chrono::duration<Rep, Period>(rep);
13
336
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
336
    auto buf = fmt::memory_buffer();
18
336
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
336
#endif
20
336
  } catch (std::exception&) {
21
298
  }
22
336
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
285
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
285
  auto value = std::chrono::duration<Rep, Period>(rep);
13
285
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
285
    auto buf = fmt::memory_buffer();
18
285
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
285
#endif
20
285
  } catch (std::exception&) {
21
260
  }
22
285
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
287
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
287
  auto value = std::chrono::duration<Rep, Period>(rep);
13
287
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
287
    auto buf = fmt::memory_buffer();
18
287
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
287
#endif
20
287
  } catch (std::exception&) {
21
264
  }
22
287
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
280
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
280
  auto value = std::chrono::duration<Rep, Period>(rep);
13
280
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
280
    auto buf = fmt::memory_buffer();
18
280
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
280
#endif
20
280
  } catch (std::exception&) {
21
263
  }
22
280
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
290
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
290
  auto value = std::chrono::duration<Rep, Period>(rep);
13
290
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
290
    auto buf = fmt::memory_buffer();
18
290
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
290
#endif
20
290
  } catch (std::exception&) {
21
263
  }
22
290
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
261
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
261
  auto value = std::chrono::duration<Rep, Period>(rep);
13
261
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
261
    auto buf = fmt::memory_buffer();
18
261
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
261
#endif
20
261
  } catch (std::exception&) {
21
229
  }
22
261
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
250
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
250
  auto value = std::chrono::duration<Rep, Period>(rep);
13
250
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
250
    auto buf = fmt::memory_buffer();
18
250
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
250
#endif
20
250
  } catch (std::exception&) {
21
223
  }
22
250
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
269
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
269
  auto value = std::chrono::duration<Rep, Period>(rep);
13
269
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
269
    auto buf = fmt::memory_buffer();
18
269
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
269
#endif
20
269
  } catch (std::exception&) {
21
247
  }
22
269
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
243
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
243
  auto value = std::chrono::duration<Rep, Period>(rep);
13
243
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
243
    auto buf = fmt::memory_buffer();
18
243
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
243
#endif
20
243
  } catch (std::exception&) {
21
202
  }
22
243
}
void invoke_inner<std::__1::ratio<1l, 1000l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
242
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
242
  auto value = std::chrono::duration<Rep, Period>(rep);
13
242
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
242
    auto buf = fmt::memory_buffer();
18
242
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
242
#endif
20
242
  } catch (std::exception&) {
21
219
  }
22
242
}
void invoke_inner<std::__1::ratio<1l, 100l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
256
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
256
  auto value = std::chrono::duration<Rep, Period>(rep);
13
256
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
256
    auto buf = fmt::memory_buffer();
18
256
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
256
#endif
20
256
  } catch (std::exception&) {
21
236
  }
22
256
}
void invoke_inner<std::__1::ratio<1l, 10l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
237
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
237
  auto value = std::chrono::duration<Rep, Period>(rep);
13
237
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
237
    auto buf = fmt::memory_buffer();
18
237
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
237
#endif
20
237
  } catch (std::exception&) {
21
215
  }
22
237
}
void invoke_inner<std::__1::ratio<10l, 1l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
285
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
285
  auto value = std::chrono::duration<Rep, Period>(rep);
13
285
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
285
    auto buf = fmt::memory_buffer();
18
285
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
285
#endif
20
285
  } catch (std::exception&) {
21
245
  }
22
285
}
void invoke_inner<std::__1::ratio<1000l, 1l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
297
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
297
  auto value = std::chrono::duration<Rep, Period>(rep);
13
297
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
297
    auto buf = fmt::memory_buffer();
18
297
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
297
#endif
20
297
  } catch (std::exception&) {
21
270
  }
22
297
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
297
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
297
  auto value = std::chrono::duration<Rep, Period>(rep);
13
297
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
297
    auto buf = fmt::memory_buffer();
18
297
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
297
#endif
20
297
  } catch (std::exception&) {
21
269
  }
22
297
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
317
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
317
  auto value = std::chrono::duration<Rep, Period>(rep);
13
317
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
317
    auto buf = fmt::memory_buffer();
18
317
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
317
#endif
20
317
  } catch (std::exception&) {
21
296
  }
22
317
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
261
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
261
  auto value = std::chrono::duration<Rep, Period>(rep);
13
261
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
261
    auto buf = fmt::memory_buffer();
18
261
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
261
#endif
20
261
  } catch (std::exception&) {
21
239
  }
22
261
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
260
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
260
  auto value = std::chrono::duration<Rep, Period>(rep);
13
260
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
260
    auto buf = fmt::memory_buffer();
18
260
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
260
#endif
20
260
  } catch (std::exception&) {
21
230
  }
22
260
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
258
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
258
  auto value = std::chrono::duration<Rep, Period>(rep);
13
258
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
258
    auto buf = fmt::memory_buffer();
18
258
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
258
#endif
20
258
  } catch (std::exception&) {
21
227
  }
22
258
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
481
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
481
  auto value = std::chrono::duration<Rep, Period>(rep);
13
481
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
481
    auto buf = fmt::memory_buffer();
18
481
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
481
#endif
20
481
  } catch (std::exception&) {
21
453
  }
22
481
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
441
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
441
  auto value = std::chrono::duration<Rep, Period>(rep);
13
441
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
441
    auto buf = fmt::memory_buffer();
18
441
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
441
#endif
20
441
  } catch (std::exception&) {
21
404
  }
22
441
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
414
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
414
  auto value = std::chrono::duration<Rep, Period>(rep);
13
414
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
414
    auto buf = fmt::memory_buffer();
18
414
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
414
#endif
20
414
  } catch (std::exception&) {
21
389
  }
22
414
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
382
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
382
  auto value = std::chrono::duration<Rep, Period>(rep);
13
382
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
382
    auto buf = fmt::memory_buffer();
18
382
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
382
#endif
20
382
  } catch (std::exception&) {
21
361
  }
22
382
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
363
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
363
  auto value = std::chrono::duration<Rep, Period>(rep);
13
363
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
363
    auto buf = fmt::memory_buffer();
18
363
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
363
#endif
20
363
  } catch (std::exception&) {
21
338
  }
22
363
}
void invoke_inner<std::__1::ratio<1l, 1000l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
370
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
370
  auto value = std::chrono::duration<Rep, Period>(rep);
13
370
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
370
    auto buf = fmt::memory_buffer();
18
370
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
370
#endif
20
370
  } catch (std::exception&) {
21
333
  }
22
370
}
void invoke_inner<std::__1::ratio<1l, 100l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
365
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
365
  auto value = std::chrono::duration<Rep, Period>(rep);
13
365
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
365
    auto buf = fmt::memory_buffer();
18
365
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
365
#endif
20
365
  } catch (std::exception&) {
21
337
  }
22
365
}
void invoke_inner<std::__1::ratio<1l, 10l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
353
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
353
  auto value = std::chrono::duration<Rep, Period>(rep);
13
353
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
353
    auto buf = fmt::memory_buffer();
18
353
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
353
#endif
20
353
  } catch (std::exception&) {
21
317
  }
22
353
}
void invoke_inner<std::__1::ratio<10l, 1l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
388
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
388
  auto value = std::chrono::duration<Rep, Period>(rep);
13
388
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
388
    auto buf = fmt::memory_buffer();
18
388
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
388
#endif
20
388
  } catch (std::exception&) {
21
364
  }
22
388
}
void invoke_inner<std::__1::ratio<1000l, 1l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
410
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
410
  auto value = std::chrono::duration<Rep, Period>(rep);
13
410
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
410
    auto buf = fmt::memory_buffer();
18
410
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
410
#endif
20
410
  } catch (std::exception&) {
21
382
  }
22
410
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
389
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
389
  auto value = std::chrono::duration<Rep, Period>(rep);
13
389
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
389
    auto buf = fmt::memory_buffer();
18
389
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
389
#endif
20
389
  } catch (std::exception&) {
21
360
  }
22
389
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
397
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
397
  auto value = std::chrono::duration<Rep, Period>(rep);
13
397
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
397
    auto buf = fmt::memory_buffer();
18
397
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
397
#endif
20
397
  } catch (std::exception&) {
21
362
  }
22
397
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
393
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
393
  auto value = std::chrono::duration<Rep, Period>(rep);
13
393
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
393
    auto buf = fmt::memory_buffer();
18
393
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
393
#endif
20
393
  } catch (std::exception&) {
21
368
  }
22
393
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
324
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
324
  auto value = std::chrono::duration<Rep, Period>(rep);
13
324
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
324
    auto buf = fmt::memory_buffer();
18
324
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
324
#endif
20
324
  } catch (std::exception&) {
21
297
  }
22
324
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
359
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
359
  auto value = std::chrono::duration<Rep, Period>(rep);
13
359
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
359
    auto buf = fmt::memory_buffer();
18
359
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
359
#endif
20
359
  } catch (std::exception&) {
21
339
  }
22
359
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
Line
Count
Source
11
333
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
333
  auto value = std::chrono::duration<Rep, Period>(rep);
13
333
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
333
    auto buf = fmt::memory_buffer();
18
333
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
333
#endif
20
333
  } catch (std::exception&) {
21
311
  }
22
333
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
Line
Count
Source
11
298
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
298
  auto value = std::chrono::duration<Rep, Period>(rep);
13
298
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
298
    auto buf = fmt::memory_buffer();
18
298
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
298
#endif
20
298
  } catch (std::exception&) {
21
275
  }
22
298
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
Line
Count
Source
11
311
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
311
  auto value = std::chrono::duration<Rep, Period>(rep);
13
311
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
311
    auto buf = fmt::memory_buffer();
18
311
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
311
#endif
20
311
  } catch (std::exception&) {
21
283
  }
22
311
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
Line
Count
Source
11
329
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
329
  auto value = std::chrono::duration<Rep, Period>(rep);
13
329
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
329
    auto buf = fmt::memory_buffer();
18
329
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
329
#endif
20
329
  } catch (std::exception&) {
21
303
  }
22
329
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
Line
Count
Source
11
324
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
324
  auto value = std::chrono::duration<Rep, Period>(rep);
13
324
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
324
    auto buf = fmt::memory_buffer();
18
324
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
324
#endif
20
324
  } catch (std::exception&) {
21
288
  }
22
324
}
void invoke_inner<std::__1::ratio<1l, 1000l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
Line
Count
Source
11
322
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
322
  auto value = std::chrono::duration<Rep, Period>(rep);
13
322
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
322
    auto buf = fmt::memory_buffer();
18
322
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
322
#endif
20
322
  } catch (std::exception&) {
21
283
  }
22
322
}
void invoke_inner<std::__1::ratio<1l, 100l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
Line
Count
Source
11
311
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
311
  auto value = std::chrono::duration<Rep, Period>(rep);
13
311
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
311
    auto buf = fmt::memory_buffer();
18
311
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
311
#endif
20
311
  } catch (std::exception&) {
21
289
  }
22
311
}
void invoke_inner<std::__1::ratio<1l, 10l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
Line
Count
Source
11
292
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
292
  auto value = std::chrono::duration<Rep, Period>(rep);
13
292
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
292
    auto buf = fmt::memory_buffer();
18
292
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
292
#endif
20
292
  } catch (std::exception&) {
21
260
  }
22
292
}
void invoke_inner<std::__1::ratio<10l, 1l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
Line
Count
Source
11
342
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
342
  auto value = std::chrono::duration<Rep, Period>(rep);
13
342
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
342
    auto buf = fmt::memory_buffer();
18
342
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
342
#endif
20
342
  } catch (std::exception&) {
21
310
  }
22
342
}
void invoke_inner<std::__1::ratio<1000l, 1l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
Line
Count
Source
11
363
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
363
  auto value = std::chrono::duration<Rep, Period>(rep);
13
363
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
363
    auto buf = fmt::memory_buffer();
18
363
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
363
#endif
20
363
  } catch (std::exception&) {
21
334
  }
22
363
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
Line
Count
Source
11
334
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
334
  auto value = std::chrono::duration<Rep, Period>(rep);
13
334
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
334
    auto buf = fmt::memory_buffer();
18
334
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
334
#endif
20
334
  } catch (std::exception&) {
21
306
  }
22
334
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
Line
Count
Source
11
332
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
332
  auto value = std::chrono::duration<Rep, Period>(rep);
13
332
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
332
    auto buf = fmt::memory_buffer();
18
332
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
332
#endif
20
332
  } catch (std::exception&) {
21
308
  }
22
332
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
Line
Count
Source
11
317
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
317
  auto value = std::chrono::duration<Rep, Period>(rep);
13
317
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
317
    auto buf = fmt::memory_buffer();
18
317
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
317
#endif
20
317
  } catch (std::exception&) {
21
290
  }
22
317
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
Line
Count
Source
11
314
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
314
  auto value = std::chrono::duration<Rep, Period>(rep);
13
314
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
314
    auto buf = fmt::memory_buffer();
18
314
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
314
#endif
20
314
  } catch (std::exception&) {
21
289
  }
22
314
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
Line
Count
Source
11
313
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
313
  auto value = std::chrono::duration<Rep, Period>(rep);
13
313
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
313
    auto buf = fmt::memory_buffer();
18
313
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
313
#endif
20
313
  } catch (std::exception&) {
21
289
  }
22
313
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
455
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
455
  auto value = std::chrono::duration<Rep, Period>(rep);
13
455
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
455
    auto buf = fmt::memory_buffer();
18
455
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
455
#endif
20
455
  } catch (std::exception&) {
21
412
  }
22
455
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
416
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
416
  auto value = std::chrono::duration<Rep, Period>(rep);
13
416
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
416
    auto buf = fmt::memory_buffer();
18
416
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
416
#endif
20
416
  } catch (std::exception&) {
21
373
  }
22
416
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
402
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
402
  auto value = std::chrono::duration<Rep, Period>(rep);
13
402
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
402
    auto buf = fmt::memory_buffer();
18
402
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
402
#endif
20
402
  } catch (std::exception&) {
21
357
  }
22
402
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
417
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
417
  auto value = std::chrono::duration<Rep, Period>(rep);
13
417
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
417
    auto buf = fmt::memory_buffer();
18
417
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
417
#endif
20
417
  } catch (std::exception&) {
21
390
  }
22
417
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
430
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
430
  auto value = std::chrono::duration<Rep, Period>(rep);
13
430
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
430
    auto buf = fmt::memory_buffer();
18
430
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
430
#endif
20
430
  } catch (std::exception&) {
21
382
  }
22
430
}
void invoke_inner<std::__1::ratio<1l, 1000l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
428
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
428
  auto value = std::chrono::duration<Rep, Period>(rep);
13
428
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
428
    auto buf = fmt::memory_buffer();
18
428
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
428
#endif
20
428
  } catch (std::exception&) {
21
392
  }
22
428
}
void invoke_inner<std::__1::ratio<1l, 100l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
422
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
422
  auto value = std::chrono::duration<Rep, Period>(rep);
13
422
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
422
    auto buf = fmt::memory_buffer();
18
422
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
422
#endif
20
422
  } catch (std::exception&) {
21
386
  }
22
422
}
void invoke_inner<std::__1::ratio<1l, 10l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
418
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
418
  auto value = std::chrono::duration<Rep, Period>(rep);
13
418
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
418
    auto buf = fmt::memory_buffer();
18
418
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
418
#endif
20
418
  } catch (std::exception&) {
21
382
  }
22
418
}
void invoke_inner<std::__1::ratio<10l, 1l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
451
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
451
  auto value = std::chrono::duration<Rep, Period>(rep);
13
451
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
451
    auto buf = fmt::memory_buffer();
18
451
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
451
#endif
20
451
  } catch (std::exception&) {
21
417
  }
22
451
}
void invoke_inner<std::__1::ratio<1000l, 1l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
451
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
451
  auto value = std::chrono::duration<Rep, Period>(rep);
13
451
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
451
    auto buf = fmt::memory_buffer();
18
451
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
451
#endif
20
451
  } catch (std::exception&) {
21
401
  }
22
451
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
444
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
444
  auto value = std::chrono::duration<Rep, Period>(rep);
13
444
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
444
    auto buf = fmt::memory_buffer();
18
444
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
444
#endif
20
444
  } catch (std::exception&) {
21
399
  }
22
444
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
425
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
425
  auto value = std::chrono::duration<Rep, Period>(rep);
13
425
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
425
    auto buf = fmt::memory_buffer();
18
425
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
425
#endif
20
425
  } catch (std::exception&) {
21
383
  }
22
425
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
458
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
458
  auto value = std::chrono::duration<Rep, Period>(rep);
13
458
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
458
    auto buf = fmt::memory_buffer();
18
458
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
458
#endif
20
458
  } catch (std::exception&) {
21
416
  }
22
458
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
438
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
438
  auto value = std::chrono::duration<Rep, Period>(rep);
13
438
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
438
    auto buf = fmt::memory_buffer();
18
438
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
438
#endif
20
438
  } catch (std::exception&) {
21
398
  }
22
438
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
433
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
433
  auto value = std::chrono::duration<Rep, Period>(rep);
13
433
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
433
    auto buf = fmt::memory_buffer();
18
433
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
433
#endif
20
433
  } catch (std::exception&) {
21
378
  }
22
433
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
466
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
466
  auto value = std::chrono::duration<Rep, Period>(rep);
13
466
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
466
    auto buf = fmt::memory_buffer();
18
466
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
466
#endif
20
466
  } catch (std::exception&) {
21
426
  }
22
466
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
430
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
430
  auto value = std::chrono::duration<Rep, Period>(rep);
13
430
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
430
    auto buf = fmt::memory_buffer();
18
430
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
430
#endif
20
430
  } catch (std::exception&) {
21
391
  }
22
430
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
410
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
410
  auto value = std::chrono::duration<Rep, Period>(rep);
13
410
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
410
    auto buf = fmt::memory_buffer();
18
410
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
410
#endif
20
410
  } catch (std::exception&) {
21
362
  }
22
410
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
407
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
407
  auto value = std::chrono::duration<Rep, Period>(rep);
13
407
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
407
    auto buf = fmt::memory_buffer();
18
407
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
407
#endif
20
407
  } catch (std::exception&) {
21
375
  }
22
407
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
445
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
445
  auto value = std::chrono::duration<Rep, Period>(rep);
13
445
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
445
    auto buf = fmt::memory_buffer();
18
445
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
445
#endif
20
445
  } catch (std::exception&) {
21
396
  }
22
445
}
void invoke_inner<std::__1::ratio<1l, 1000l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
419
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
419
  auto value = std::chrono::duration<Rep, Period>(rep);
13
419
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
419
    auto buf = fmt::memory_buffer();
18
419
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
419
#endif
20
419
  } catch (std::exception&) {
21
380
  }
22
419
}
void invoke_inner<std::__1::ratio<1l, 100l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
427
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
427
  auto value = std::chrono::duration<Rep, Period>(rep);
13
427
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
427
    auto buf = fmt::memory_buffer();
18
427
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
427
#endif
20
427
  } catch (std::exception&) {
21
387
  }
22
427
}
void invoke_inner<std::__1::ratio<1l, 10l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
433
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
433
  auto value = std::chrono::duration<Rep, Period>(rep);
13
433
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
433
    auto buf = fmt::memory_buffer();
18
433
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
433
#endif
20
433
  } catch (std::exception&) {
21
401
  }
22
433
}
void invoke_inner<std::__1::ratio<10l, 1l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
438
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
438
  auto value = std::chrono::duration<Rep, Period>(rep);
13
438
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
438
    auto buf = fmt::memory_buffer();
18
438
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
438
#endif
20
438
  } catch (std::exception&) {
21
407
  }
22
438
}
void invoke_inner<std::__1::ratio<1000l, 1l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
404
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
404
  auto value = std::chrono::duration<Rep, Period>(rep);
13
404
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
404
    auto buf = fmt::memory_buffer();
18
404
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
404
#endif
20
404
  } catch (std::exception&) {
21
368
  }
22
404
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
437
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
437
  auto value = std::chrono::duration<Rep, Period>(rep);
13
437
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
437
    auto buf = fmt::memory_buffer();
18
437
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
437
#endif
20
437
  } catch (std::exception&) {
21
409
  }
22
437
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
451
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
451
  auto value = std::chrono::duration<Rep, Period>(rep);
13
451
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
451
    auto buf = fmt::memory_buffer();
18
451
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
451
#endif
20
451
  } catch (std::exception&) {
21
413
  }
22
451
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
439
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
439
  auto value = std::chrono::duration<Rep, Period>(rep);
13
439
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
439
    auto buf = fmt::memory_buffer();
18
439
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
439
#endif
20
439
  } catch (std::exception&) {
21
395
  }
22
439
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
445
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
445
  auto value = std::chrono::duration<Rep, Period>(rep);
13
445
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
445
    auto buf = fmt::memory_buffer();
18
445
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
445
#endif
20
445
  } catch (std::exception&) {
21
412
  }
22
445
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
422
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
422
  auto value = std::chrono::duration<Rep, Period>(rep);
13
422
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
422
    auto buf = fmt::memory_buffer();
18
422
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
422
#endif
20
422
  } catch (std::exception&) {
21
378
  }
22
422
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
461
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
461
  auto value = std::chrono::duration<Rep, Period>(rep);
13
461
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
461
    auto buf = fmt::memory_buffer();
18
461
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
461
#endif
20
461
  } catch (std::exception&) {
21
409
  }
22
461
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
427
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
427
  auto value = std::chrono::duration<Rep, Period>(rep);
13
427
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
427
    auto buf = fmt::memory_buffer();
18
427
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
427
#endif
20
427
  } catch (std::exception&) {
21
389
  }
22
427
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
453
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
453
  auto value = std::chrono::duration<Rep, Period>(rep);
13
453
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
453
    auto buf = fmt::memory_buffer();
18
453
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
453
#endif
20
453
  } catch (std::exception&) {
21
404
  }
22
453
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
434
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
434
  auto value = std::chrono::duration<Rep, Period>(rep);
13
434
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
434
    auto buf = fmt::memory_buffer();
18
434
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
434
#endif
20
434
  } catch (std::exception&) {
21
397
  }
22
434
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
443
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
443
  auto value = std::chrono::duration<Rep, Period>(rep);
13
443
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
443
    auto buf = fmt::memory_buffer();
18
443
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
443
#endif
20
443
  } catch (std::exception&) {
21
395
  }
22
443
}
void invoke_inner<std::__1::ratio<1l, 1000l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
432
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
432
  auto value = std::chrono::duration<Rep, Period>(rep);
13
432
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
432
    auto buf = fmt::memory_buffer();
18
432
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
432
#endif
20
432
  } catch (std::exception&) {
21
378
  }
22
432
}
void invoke_inner<std::__1::ratio<1l, 100l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
444
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
444
  auto value = std::chrono::duration<Rep, Period>(rep);
13
444
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
444
    auto buf = fmt::memory_buffer();
18
444
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
444
#endif
20
444
  } catch (std::exception&) {
21
395
  }
22
444
}
void invoke_inner<std::__1::ratio<1l, 10l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
430
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
430
  auto value = std::chrono::duration<Rep, Period>(rep);
13
430
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
430
    auto buf = fmt::memory_buffer();
18
430
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
430
#endif
20
430
  } catch (std::exception&) {
21
381
  }
22
430
}
void invoke_inner<std::__1::ratio<10l, 1l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
427
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
427
  auto value = std::chrono::duration<Rep, Period>(rep);
13
427
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
427
    auto buf = fmt::memory_buffer();
18
427
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
427
#endif
20
427
  } catch (std::exception&) {
21
396
  }
22
427
}
void invoke_inner<std::__1::ratio<1000l, 1l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
456
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
456
  auto value = std::chrono::duration<Rep, Period>(rep);
13
456
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
456
    auto buf = fmt::memory_buffer();
18
456
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
456
#endif
20
456
  } catch (std::exception&) {
21
422
  }
22
456
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
434
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
434
  auto value = std::chrono::duration<Rep, Period>(rep);
13
434
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
434
    auto buf = fmt::memory_buffer();
18
434
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
434
#endif
20
434
  } catch (std::exception&) {
21
396
  }
22
434
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
441
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
441
  auto value = std::chrono::duration<Rep, Period>(rep);
13
441
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
441
    auto buf = fmt::memory_buffer();
18
441
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
441
#endif
20
441
  } catch (std::exception&) {
21
391
  }
22
441
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
442
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
442
  auto value = std::chrono::duration<Rep, Period>(rep);
13
442
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
442
    auto buf = fmt::memory_buffer();
18
442
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
442
#endif
20
442
  } catch (std::exception&) {
21
393
  }
22
442
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
432
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
432
  auto value = std::chrono::duration<Rep, Period>(rep);
13
432
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
432
    auto buf = fmt::memory_buffer();
18
432
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
432
#endif
20
432
  } catch (std::exception&) {
21
402
  }
22
432
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
422
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
422
  auto value = std::chrono::duration<Rep, Period>(rep);
13
422
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
422
    auto buf = fmt::memory_buffer();
18
422
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
422
#endif
20
422
  } catch (std::exception&) {
21
338
  }
22
422
}
23
24
// Rep is a duration's representation type.
25
template <typename Rep>
26
58.7k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
58.7k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
58.7k
  if (size <= fixed_size + 1) return;
30
31
58.6k
  const Rep rep = assign_from_buf<Rep>(data);
32
58.6k
  data += fixed_size;
33
58.6k
  size -= fixed_size;
34
35
  // data is already allocated separately in libFuzzer so reading past the end
36
  // will most likely be detected anyway.
37
58.6k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
58.6k
  switch (period) {
41
4.07k
  case 1:
42
4.07k
    invoke_inner<std::atto>(format_str, rep);
43
4.07k
    break;
44
3.81k
  case 2:
45
3.81k
    invoke_inner<std::femto>(format_str, rep);
46
3.81k
    break;
47
3.79k
  case 3:
48
3.79k
    invoke_inner<std::pico>(format_str, rep);
49
3.79k
    break;
50
3.77k
  case 4:
51
3.77k
    invoke_inner<std::nano>(format_str, rep);
52
3.77k
    break;
53
3.75k
  case 5:
54
3.75k
    invoke_inner<std::micro>(format_str, rep);
55
3.75k
    break;
56
3.76k
  case 6:
57
3.76k
    invoke_inner<std::milli>(format_str, rep);
58
3.76k
    break;
59
3.76k
  case 7:
60
3.76k
    invoke_inner<std::centi>(format_str, rep);
61
3.76k
    break;
62
3.69k
  case 8:
63
3.69k
    invoke_inner<std::deci>(format_str, rep);
64
3.69k
    break;
65
4.21k
  case 9:
66
4.21k
    invoke_inner<std::deca>(format_str, rep);
67
4.21k
    break;
68
4.23k
  case 10:
69
4.23k
    invoke_inner<std::kilo>(format_str, rep);
70
4.23k
    break;
71
4.19k
  case 11:
72
4.19k
    invoke_inner<std::mega>(format_str, rep);
73
4.19k
    break;
74
4.20k
  case 12:
75
4.20k
    invoke_inner<std::giga>(format_str, rep);
76
4.20k
    break;
77
3.87k
  case 13:
78
3.87k
    invoke_inner<std::tera>(format_str, rep);
79
3.87k
    break;
80
3.77k
  case 14:
81
3.77k
    invoke_inner<std::peta>(format_str, rep);
82
3.77k
    break;
83
3.70k
  case 15:
84
3.70k
    invoke_inner<std::exa>(format_str, rep);
85
3.70k
    break;
86
58.6k
  }
87
58.6k
}
void invoke_outer<char>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
3.99k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
3.99k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
3.99k
  if (size <= fixed_size + 1) return;
30
31
3.99k
  const Rep rep = assign_from_buf<Rep>(data);
32
3.99k
  data += fixed_size;
33
3.99k
  size -= fixed_size;
34
35
  // data is already allocated separately in libFuzzer so reading past the end
36
  // will most likely be detected anyway.
37
3.99k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
3.99k
  switch (period) {
41
270
  case 1:
42
270
    invoke_inner<std::atto>(format_str, rep);
43
270
    break;
44
245
  case 2:
45
245
    invoke_inner<std::femto>(format_str, rep);
46
245
    break;
47
254
  case 3:
48
254
    invoke_inner<std::pico>(format_str, rep);
49
254
    break;
50
248
  case 4:
51
248
    invoke_inner<std::nano>(format_str, rep);
52
248
    break;
53
254
  case 5:
54
254
    invoke_inner<std::micro>(format_str, rep);
55
254
    break;
56
248
  case 6:
57
248
    invoke_inner<std::milli>(format_str, rep);
58
248
    break;
59
257
  case 7:
60
257
    invoke_inner<std::centi>(format_str, rep);
61
257
    break;
62
233
  case 8:
63
233
    invoke_inner<std::deci>(format_str, rep);
64
233
    break;
65
310
  case 9:
66
310
    invoke_inner<std::deca>(format_str, rep);
67
310
    break;
68
302
  case 10:
69
302
    invoke_inner<std::kilo>(format_str, rep);
70
302
    break;
71
316
  case 11:
72
316
    invoke_inner<std::mega>(format_str, rep);
73
316
    break;
74
289
  case 12:
75
289
    invoke_inner<std::giga>(format_str, rep);
76
289
    break;
77
249
  case 13:
78
249
    invoke_inner<std::tera>(format_str, rep);
79
249
    break;
80
271
  case 14:
81
271
    invoke_inner<std::peta>(format_str, rep);
82
271
    break;
83
246
  case 15:
84
246
    invoke_inner<std::exa>(format_str, rep);
85
246
    break;
86
3.99k
  }
87
3.99k
}
void invoke_outer<signed char>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
4.14k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
4.14k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
4.14k
  if (size <= fixed_size + 1) return;
30
31
4.14k
  const Rep rep = assign_from_buf<Rep>(data);
32
4.14k
  data += fixed_size;
33
4.14k
  size -= fixed_size;
34
35
  // data is already allocated separately in libFuzzer so reading past the end
36
  // will most likely be detected anyway.
37
4.14k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
4.14k
  switch (period) {
41
273
  case 1:
42
273
    invoke_inner<std::atto>(format_str, rep);
43
273
    break;
44
267
  case 2:
45
267
    invoke_inner<std::femto>(format_str, rep);
46
267
    break;
47
266
  case 3:
48
266
    invoke_inner<std::pico>(format_str, rep);
49
266
    break;
50
252
  case 4:
51
252
    invoke_inner<std::nano>(format_str, rep);
52
252
    break;
53
259
  case 5:
54
259
    invoke_inner<std::micro>(format_str, rep);
55
259
    break;
56
250
  case 6:
57
250
    invoke_inner<std::milli>(format_str, rep);
58
250
    break;
59
257
  case 7:
60
257
    invoke_inner<std::centi>(format_str, rep);
61
257
    break;
62
283
  case 8:
63
283
    invoke_inner<std::deci>(format_str, rep);
64
283
    break;
65
330
  case 9:
66
330
    invoke_inner<std::deca>(format_str, rep);
67
330
    break;
68
304
  case 10:
69
304
    invoke_inner<std::kilo>(format_str, rep);
70
304
    break;
71
328
  case 11:
72
328
    invoke_inner<std::mega>(format_str, rep);
73
328
    break;
74
319
  case 12:
75
319
    invoke_inner<std::giga>(format_str, rep);
76
319
    break;
77
251
  case 13:
78
251
    invoke_inner<std::tera>(format_str, rep);
79
251
    break;
80
247
  case 14:
81
247
    invoke_inner<std::peta>(format_str, rep);
82
247
    break;
83
253
  case 15:
84
253
    invoke_inner<std::exa>(format_str, rep);
85
253
    break;
86
4.14k
  }
87
4.14k
}
void invoke_outer<unsigned char>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
3.76k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
3.76k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
3.76k
  if (size <= fixed_size + 1) return;
30
31
3.75k
  const Rep rep = assign_from_buf<Rep>(data);
32
3.75k
  data += fixed_size;
33
3.75k
  size -= fixed_size;
34
35
  // data is already allocated separately in libFuzzer so reading past the end
36
  // will most likely be detected anyway.
37
3.75k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
3.75k
  switch (period) {
41
237
  case 1:
42
237
    invoke_inner<std::atto>(format_str, rep);
43
237
    break;
44
243
  case 2:
45
243
    invoke_inner<std::femto>(format_str, rep);
46
243
    break;
47
242
  case 3:
48
242
    invoke_inner<std::pico>(format_str, rep);
49
242
    break;
50
240
  case 4:
51
240
    invoke_inner<std::nano>(format_str, rep);
52
240
    break;
53
216
  case 5:
54
216
    invoke_inner<std::micro>(format_str, rep);
55
216
    break;
56
239
  case 6:
57
239
    invoke_inner<std::milli>(format_str, rep);
58
239
    break;
59
222
  case 7:
60
222
    invoke_inner<std::centi>(format_str, rep);
61
222
    break;
62
228
  case 8:
63
228
    invoke_inner<std::deci>(format_str, rep);
64
228
    break;
65
283
  case 9:
66
283
    invoke_inner<std::deca>(format_str, rep);
67
283
    break;
68
299
  case 10:
69
299
    invoke_inner<std::kilo>(format_str, rep);
70
299
    break;
71
277
  case 11:
72
277
    invoke_inner<std::mega>(format_str, rep);
73
277
    break;
74
281
  case 12:
75
281
    invoke_inner<std::giga>(format_str, rep);
76
281
    break;
77
259
  case 13:
78
259
    invoke_inner<std::tera>(format_str, rep);
79
259
    break;
80
242
  case 14:
81
242
    invoke_inner<std::peta>(format_str, rep);
82
242
    break;
83
248
  case 15:
84
248
    invoke_inner<std::exa>(format_str, rep);
85
248
    break;
86
3.75k
  }
87
3.75k
}
void invoke_outer<short>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
4.20k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
4.20k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
4.20k
  if (size <= fixed_size + 1) return;
30
31
4.20k
  const Rep rep = assign_from_buf<Rep>(data);
32
4.20k
  data += fixed_size;
33
4.20k
  size -= fixed_size;
34
35
  // data is already allocated separately in libFuzzer so reading past the end
36
  // will most likely be detected anyway.
37
4.20k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
4.20k
  switch (period) {
41
280
  case 1:
42
280
    invoke_inner<std::atto>(format_str, rep);
43
280
    break;
44
258
  case 2:
45
258
    invoke_inner<std::femto>(format_str, rep);
46
258
    break;
47
266
  case 3:
48
266
    invoke_inner<std::pico>(format_str, rep);
49
266
    break;
50
264
  case 4:
51
264
    invoke_inner<std::nano>(format_str, rep);
52
264
    break;
53
265
  case 5:
54
265
    invoke_inner<std::micro>(format_str, rep);
55
265
    break;
56
269
  case 6:
57
269
    invoke_inner<std::milli>(format_str, rep);
58
269
    break;
59
275
  case 7:
60
275
    invoke_inner<std::centi>(format_str, rep);
61
275
    break;
62
270
  case 8:
63
270
    invoke_inner<std::deci>(format_str, rep);
64
270
    break;
65
318
  case 9:
66
318
    invoke_inner<std::deca>(format_str, rep);
67
318
    break;
68
313
  case 10:
69
313
    invoke_inner<std::kilo>(format_str, rep);
70
313
    break;
71
319
  case 11:
72
319
    invoke_inner<std::mega>(format_str, rep);
73
319
    break;
74
336
  case 12:
75
336
    invoke_inner<std::giga>(format_str, rep);
76
336
    break;
77
266
  case 13:
78
266
    invoke_inner<std::tera>(format_str, rep);
79
266
    break;
80
261
  case 14:
81
261
    invoke_inner<std::peta>(format_str, rep);
82
261
    break;
83
239
  case 15:
84
239
    invoke_inner<std::exa>(format_str, rep);
85
239
    break;
86
4.20k
  }
87
4.20k
}
void invoke_outer<unsigned short>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
3.83k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
3.83k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
3.83k
  if (size <= fixed_size + 1) return;
30
31
3.83k
  const Rep rep = assign_from_buf<Rep>(data);
32
3.83k
  data += fixed_size;
33
3.83k
  size -= fixed_size;
34
35
  // data is already allocated separately in libFuzzer so reading past the end
36
  // will most likely be detected anyway.
37
3.83k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
3.83k
  switch (period) {
41
239
  case 1:
42
239
    invoke_inner<std::atto>(format_str, rep);
43
239
    break;
44
251
  case 2:
45
251
    invoke_inner<std::femto>(format_str, rep);
46
251
    break;
47
240
  case 3:
48
240
    invoke_inner<std::pico>(format_str, rep);
49
240
    break;
50
235
  case 4:
51
235
    invoke_inner<std::nano>(format_str, rep);
52
235
    break;
53
238
  case 5:
54
238
    invoke_inner<std::micro>(format_str, rep);
55
238
    break;
56
250
  case 6:
57
250
    invoke_inner<std::milli>(format_str, rep);
58
250
    break;
59
230
  case 7:
60
230
    invoke_inner<std::centi>(format_str, rep);
61
230
    break;
62
231
  case 8:
63
231
    invoke_inner<std::deci>(format_str, rep);
64
231
    break;
65
302
  case 9:
66
302
    invoke_inner<std::deca>(format_str, rep);
67
302
    break;
68
310
  case 10:
69
310
    invoke_inner<std::kilo>(format_str, rep);
70
310
    break;
71
278
  case 11:
72
278
    invoke_inner<std::mega>(format_str, rep);
73
278
    break;
74
285
  case 12:
75
285
    invoke_inner<std::giga>(format_str, rep);
76
285
    break;
77
255
  case 13:
78
255
    invoke_inner<std::tera>(format_str, rep);
79
255
    break;
80
253
  case 14:
81
253
    invoke_inner<std::peta>(format_str, rep);
82
253
    break;
83
234
  case 15:
84
234
    invoke_inner<std::exa>(format_str, rep);
85
234
    break;
86
3.83k
  }
87
3.83k
}
void invoke_outer<int>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
4.52k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
4.52k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
4.52k
  if (size <= fixed_size + 1) return;
30
31
4.51k
  const Rep rep = assign_from_buf<Rep>(data);
32
4.51k
  data += fixed_size;
33
4.51k
  size -= fixed_size;
34
35
  // data is already allocated separately in libFuzzer so reading past the end
36
  // will most likely be detected anyway.
37
4.51k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
4.51k
  switch (period) {
41
291
  case 1:
42
291
    invoke_inner<std::atto>(format_str, rep);
43
291
    break;
44
276
  case 2:
45
276
    invoke_inner<std::femto>(format_str, rep);
46
276
    break;
47
287
  case 3:
48
287
    invoke_inner<std::pico>(format_str, rep);
49
287
    break;
50
297
  case 4:
51
297
    invoke_inner<std::nano>(format_str, rep);
52
297
    break;
53
279
  case 5:
54
279
    invoke_inner<std::micro>(format_str, rep);
55
279
    break;
56
294
  case 6:
57
294
    invoke_inner<std::milli>(format_str, rep);
58
294
    break;
59
299
  case 7:
60
299
    invoke_inner<std::centi>(format_str, rep);
61
299
    break;
62
287
  case 8:
63
287
    invoke_inner<std::deci>(format_str, rep);
64
287
    break;
65
343
  case 9:
66
343
    invoke_inner<std::deca>(format_str, rep);
67
343
    break;
68
328
  case 10:
69
328
    invoke_inner<std::kilo>(format_str, rep);
70
328
    break;
71
344
  case 11:
72
344
    invoke_inner<std::mega>(format_str, rep);
73
344
    break;
74
336
  case 12:
75
336
    invoke_inner<std::giga>(format_str, rep);
76
336
    break;
77
285
  case 13:
78
285
    invoke_inner<std::tera>(format_str, rep);
79
285
    break;
80
287
  case 14:
81
287
    invoke_inner<std::peta>(format_str, rep);
82
287
    break;
83
280
  case 15:
84
280
    invoke_inner<std::exa>(format_str, rep);
85
280
    break;
86
4.51k
  }
87
4.51k
}
void invoke_outer<unsigned int>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
4.02k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
4.02k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
4.02k
  if (size <= fixed_size + 1) return;
30
31
4.02k
  const Rep rep = assign_from_buf<Rep>(data);
32
4.02k
  data += fixed_size;
33
4.02k
  size -= fixed_size;
34
35
  // data is already allocated separately in libFuzzer so reading past the end
36
  // will most likely be detected anyway.
37
4.02k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
4.02k
  switch (period) {
41
290
  case 1:
42
290
    invoke_inner<std::atto>(format_str, rep);
43
290
    break;
44
261
  case 2:
45
261
    invoke_inner<std::femto>(format_str, rep);
46
261
    break;
47
250
  case 3:
48
250
    invoke_inner<std::pico>(format_str, rep);
49
250
    break;
50
269
  case 4:
51
269
    invoke_inner<std::nano>(format_str, rep);
52
269
    break;
53
243
  case 5:
54
243
    invoke_inner<std::micro>(format_str, rep);
55
243
    break;
56
242
  case 6:
57
242
    invoke_inner<std::milli>(format_str, rep);
58
242
    break;
59
256
  case 7:
60
256
    invoke_inner<std::centi>(format_str, rep);
61
256
    break;
62
237
  case 8:
63
237
    invoke_inner<std::deci>(format_str, rep);
64
237
    break;
65
285
  case 9:
66
285
    invoke_inner<std::deca>(format_str, rep);
67
285
    break;
68
297
  case 10:
69
297
    invoke_inner<std::kilo>(format_str, rep);
70
297
    break;
71
297
  case 11:
72
297
    invoke_inner<std::mega>(format_str, rep);
73
297
    break;
74
317
  case 12:
75
317
    invoke_inner<std::giga>(format_str, rep);
76
317
    break;
77
261
  case 13:
78
261
    invoke_inner<std::tera>(format_str, rep);
79
261
    break;
80
260
  case 14:
81
260
    invoke_inner<std::peta>(format_str, rep);
82
260
    break;
83
258
  case 15:
84
258
    invoke_inner<std::exa>(format_str, rep);
85
258
    break;
86
4.02k
  }
87
4.02k
}
void invoke_outer<long>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
5.83k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
5.83k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
5.83k
  if (size <= fixed_size + 1) return;
30
31
5.83k
  const Rep rep = assign_from_buf<Rep>(data);
32
5.83k
  data += fixed_size;
33
5.83k
  size -= fixed_size;
34
35
  // data is already allocated separately in libFuzzer so reading past the end
36
  // will most likely be detected anyway.
37
5.83k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
5.83k
  switch (period) {
41
481
  case 1:
42
481
    invoke_inner<std::atto>(format_str, rep);
43
481
    break;
44
441
  case 2:
45
441
    invoke_inner<std::femto>(format_str, rep);
46
441
    break;
47
414
  case 3:
48
414
    invoke_inner<std::pico>(format_str, rep);
49
414
    break;
50
382
  case 4:
51
382
    invoke_inner<std::nano>(format_str, rep);
52
382
    break;
53
363
  case 5:
54
363
    invoke_inner<std::micro>(format_str, rep);
55
363
    break;
56
370
  case 6:
57
370
    invoke_inner<std::milli>(format_str, rep);
58
370
    break;
59
365
  case 7:
60
365
    invoke_inner<std::centi>(format_str, rep);
61
365
    break;
62
353
  case 8:
63
353
    invoke_inner<std::deci>(format_str, rep);
64
353
    break;
65
388
  case 9:
66
388
    invoke_inner<std::deca>(format_str, rep);
67
388
    break;
68
410
  case 10:
69
410
    invoke_inner<std::kilo>(format_str, rep);
70
410
    break;
71
389
  case 11:
72
389
    invoke_inner<std::mega>(format_str, rep);
73
389
    break;
74
397
  case 12:
75
397
    invoke_inner<std::giga>(format_str, rep);
76
397
    break;
77
393
  case 13:
78
393
    invoke_inner<std::tera>(format_str, rep);
79
393
    break;
80
324
  case 14:
81
324
    invoke_inner<std::peta>(format_str, rep);
82
324
    break;
83
359
  case 15:
84
359
    invoke_inner<std::exa>(format_str, rep);
85
359
    break;
86
5.83k
  }
87
5.83k
}
void invoke_outer<unsigned long>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
4.83k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
4.83k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
4.83k
  if (size <= fixed_size + 1) return;
30
31
4.83k
  const Rep rep = assign_from_buf<Rep>(data);
32
4.83k
  data += fixed_size;
33
4.83k
  size -= fixed_size;
34
35
  // data is already allocated separately in libFuzzer so reading past the end
36
  // will most likely be detected anyway.
37
4.83k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
4.83k
  switch (period) {
41
333
  case 1:
42
333
    invoke_inner<std::atto>(format_str, rep);
43
333
    break;
44
298
  case 2:
45
298
    invoke_inner<std::femto>(format_str, rep);
46
298
    break;
47
311
  case 3:
48
311
    invoke_inner<std::pico>(format_str, rep);
49
311
    break;
50
329
  case 4:
51
329
    invoke_inner<std::nano>(format_str, rep);
52
329
    break;
53
324
  case 5:
54
324
    invoke_inner<std::micro>(format_str, rep);
55
324
    break;
56
322
  case 6:
57
322
    invoke_inner<std::milli>(format_str, rep);
58
322
    break;
59
311
  case 7:
60
311
    invoke_inner<std::centi>(format_str, rep);
61
311
    break;
62
292
  case 8:
63
292
    invoke_inner<std::deci>(format_str, rep);
64
292
    break;
65
342
  case 9:
66
342
    invoke_inner<std::deca>(format_str, rep);
67
342
    break;
68
363
  case 10:
69
363
    invoke_inner<std::kilo>(format_str, rep);
70
363
    break;
71
334
  case 11:
72
334
    invoke_inner<std::mega>(format_str, rep);
73
334
    break;
74
332
  case 12:
75
332
    invoke_inner<std::giga>(format_str, rep);
76
332
    break;
77
317
  case 13:
78
317
    invoke_inner<std::tera>(format_str, rep);
79
317
    break;
80
314
  case 14:
81
314
    invoke_inner<std::peta>(format_str, rep);
82
314
    break;
83
313
  case 15:
84
313
    invoke_inner<std::exa>(format_str, rep);
85
313
    break;
86
4.83k
  }
87
4.83k
}
void invoke_outer<float>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
6.49k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
6.49k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
6.49k
  if (size <= fixed_size + 1) return;
30
31
6.48k
  const Rep rep = assign_from_buf<Rep>(data);
32
6.48k
  data += fixed_size;
33
6.48k
  size -= fixed_size;
34
35
  // data is already allocated separately in libFuzzer so reading past the end
36
  // will most likely be detected anyway.
37
6.48k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
6.48k
  switch (period) {
41
455
  case 1:
42
455
    invoke_inner<std::atto>(format_str, rep);
43
455
    break;
44
416
  case 2:
45
416
    invoke_inner<std::femto>(format_str, rep);
46
416
    break;
47
402
  case 3:
48
402
    invoke_inner<std::pico>(format_str, rep);
49
402
    break;
50
417
  case 4:
51
417
    invoke_inner<std::nano>(format_str, rep);
52
417
    break;
53
430
  case 5:
54
430
    invoke_inner<std::micro>(format_str, rep);
55
430
    break;
56
428
  case 6:
57
428
    invoke_inner<std::milli>(format_str, rep);
58
428
    break;
59
422
  case 7:
60
422
    invoke_inner<std::centi>(format_str, rep);
61
422
    break;
62
418
  case 8:
63
418
    invoke_inner<std::deci>(format_str, rep);
64
418
    break;
65
451
  case 9:
66
451
    invoke_inner<std::deca>(format_str, rep);
67
451
    break;
68
451
  case 10:
69
451
    invoke_inner<std::kilo>(format_str, rep);
70
451
    break;
71
444
  case 11:
72
444
    invoke_inner<std::mega>(format_str, rep);
73
444
    break;
74
425
  case 12:
75
425
    invoke_inner<std::giga>(format_str, rep);
76
425
    break;
77
458
  case 13:
78
458
    invoke_inner<std::tera>(format_str, rep);
79
458
    break;
80
438
  case 14:
81
438
    invoke_inner<std::peta>(format_str, rep);
82
438
    break;
83
433
  case 15:
84
433
    invoke_inner<std::exa>(format_str, rep);
85
433
    break;
86
6.48k
  }
87
6.48k
}
void invoke_outer<double>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
6.48k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
6.48k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
6.48k
  if (size <= fixed_size + 1) return;
30
31
6.47k
  const Rep rep = assign_from_buf<Rep>(data);
32
6.47k
  data += fixed_size;
33
6.47k
  size -= fixed_size;
34
35
  // data is already allocated separately in libFuzzer so reading past the end
36
  // will most likely be detected anyway.
37
6.47k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
6.47k
  switch (period) {
41
466
  case 1:
42
466
    invoke_inner<std::atto>(format_str, rep);
43
466
    break;
44
430
  case 2:
45
430
    invoke_inner<std::femto>(format_str, rep);
46
430
    break;
47
410
  case 3:
48
410
    invoke_inner<std::pico>(format_str, rep);
49
410
    break;
50
407
  case 4:
51
407
    invoke_inner<std::nano>(format_str, rep);
52
407
    break;
53
445
  case 5:
54
445
    invoke_inner<std::micro>(format_str, rep);
55
445
    break;
56
419
  case 6:
57
419
    invoke_inner<std::milli>(format_str, rep);
58
419
    break;
59
427
  case 7:
60
427
    invoke_inner<std::centi>(format_str, rep);
61
427
    break;
62
433
  case 8:
63
433
    invoke_inner<std::deci>(format_str, rep);
64
433
    break;
65
438
  case 9:
66
438
    invoke_inner<std::deca>(format_str, rep);
67
438
    break;
68
404
  case 10:
69
404
    invoke_inner<std::kilo>(format_str, rep);
70
404
    break;
71
437
  case 11:
72
437
    invoke_inner<std::mega>(format_str, rep);
73
437
    break;
74
451
  case 12:
75
451
    invoke_inner<std::giga>(format_str, rep);
76
451
    break;
77
439
  case 13:
78
439
    invoke_inner<std::tera>(format_str, rep);
79
439
    break;
80
445
  case 14:
81
445
    invoke_inner<std::peta>(format_str, rep);
82
445
    break;
83
422
  case 15:
84
422
    invoke_inner<std::exa>(format_str, rep);
85
422
    break;
86
6.47k
  }
87
6.47k
}
void invoke_outer<long double>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
6.58k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
6.58k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
6.58k
  if (size <= fixed_size + 1) return;
30
31
6.57k
  const Rep rep = assign_from_buf<Rep>(data);
32
6.57k
  data += fixed_size;
33
6.57k
  size -= fixed_size;
34
35
  // data is already allocated separately in libFuzzer so reading past the end
36
  // will most likely be detected anyway.
37
6.57k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
6.57k
  switch (period) {
41
461
  case 1:
42
461
    invoke_inner<std::atto>(format_str, rep);
43
461
    break;
44
427
  case 2:
45
427
    invoke_inner<std::femto>(format_str, rep);
46
427
    break;
47
453
  case 3:
48
453
    invoke_inner<std::pico>(format_str, rep);
49
453
    break;
50
434
  case 4:
51
434
    invoke_inner<std::nano>(format_str, rep);
52
434
    break;
53
443
  case 5:
54
443
    invoke_inner<std::micro>(format_str, rep);
55
443
    break;
56
432
  case 6:
57
432
    invoke_inner<std::milli>(format_str, rep);
58
432
    break;
59
444
  case 7:
60
444
    invoke_inner<std::centi>(format_str, rep);
61
444
    break;
62
430
  case 8:
63
430
    invoke_inner<std::deci>(format_str, rep);
64
430
    break;
65
427
  case 9:
66
427
    invoke_inner<std::deca>(format_str, rep);
67
427
    break;
68
456
  case 10:
69
456
    invoke_inner<std::kilo>(format_str, rep);
70
456
    break;
71
434
  case 11:
72
434
    invoke_inner<std::mega>(format_str, rep);
73
434
    break;
74
441
  case 12:
75
441
    invoke_inner<std::giga>(format_str, rep);
76
441
    break;
77
442
  case 13:
78
442
    invoke_inner<std::tera>(format_str, rep);
79
442
    break;
80
432
  case 14:
81
432
    invoke_inner<std::peta>(format_str, rep);
82
432
    break;
83
422
  case 15:
84
422
    invoke_inner<std::exa>(format_str, rep);
85
422
    break;
86
6.57k
  }
87
6.57k
}
88
89
58.7k
extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
90
58.7k
  if (size <= 4) return 0;
91
92
58.7k
  const auto representation = data[0];
93
58.7k
  const auto period = data[1];
94
58.7k
  data += 2;
95
58.7k
  size -= 2;
96
97
58.7k
  switch (representation) {
98
3.99k
  case 1:
99
3.99k
    invoke_outer<char>(data, size, period);
100
3.99k
    break;
101
4.14k
  case 2:
102
4.14k
    invoke_outer<signed char>(data, size, period);
103
4.14k
    break;
104
3.76k
  case 3:
105
3.76k
    invoke_outer<unsigned char>(data, size, period);
106
3.76k
    break;
107
4.20k
  case 4:
108
4.20k
    invoke_outer<short>(data, size, period);
109
4.20k
    break;
110
3.83k
  case 5:
111
3.83k
    invoke_outer<unsigned short>(data, size, period);
112
3.83k
    break;
113
4.52k
  case 6:
114
4.52k
    invoke_outer<int>(data, size, period);
115
4.52k
    break;
116
4.02k
  case 7:
117
4.02k
    invoke_outer<unsigned int>(data, size, period);
118
4.02k
    break;
119
5.83k
  case 8:
120
5.83k
    invoke_outer<long>(data, size, period);
121
5.83k
    break;
122
4.83k
  case 9:
123
4.83k
    invoke_outer<unsigned long>(data, size, period);
124
4.83k
    break;
125
6.49k
  case 10:
126
6.49k
    invoke_outer<float>(data, size, period);
127
6.49k
    break;
128
6.48k
  case 11:
129
6.48k
    invoke_outer<double>(data, size, period);
130
6.48k
    break;
131
6.58k
  case 12:
132
6.58k
    invoke_outer<long double>(data, size, period);
133
6.58k
    break;
134
58.7k
  }
135
58.7k
  return 0;
136
58.7k
}