Coverage Report

Created: 2026-07-16 06:34

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
76.0k
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
76.0k
  auto value = std::chrono::duration<Rep, Period>(rep);
13
76.0k
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
76.0k
    auto buf = fmt::memory_buffer();
18
76.0k
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
76.0k
#endif
20
76.0k
  } catch (std::exception&) {
21
67.8k
  }
22
76.0k
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
340
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
340
  auto value = std::chrono::duration<Rep, Period>(rep);
13
340
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
340
    auto buf = fmt::memory_buffer();
18
340
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
340
#endif
20
340
  } catch (std::exception&) {
21
306
  }
22
340
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
331
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
331
  auto value = std::chrono::duration<Rep, Period>(rep);
13
331
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
331
    auto buf = fmt::memory_buffer();
18
331
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
331
#endif
20
331
  } catch (std::exception&) {
21
286
  }
22
331
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, char>(fmt::v12::basic_string_view<char>, 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
273
  }
22
304
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, char>(fmt::v12::basic_string_view<char>, char)
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
278
  }
22
329
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, char>(fmt::v12::basic_string_view<char>, char)
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
281
  }
22
329
}
void invoke_inner<std::__1::ratio<1l, 1000l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
320
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
320
  auto value = std::chrono::duration<Rep, Period>(rep);
13
320
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
320
    auto buf = fmt::memory_buffer();
18
320
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
320
#endif
20
320
  } catch (std::exception&) {
21
273
  }
22
320
}
void invoke_inner<std::__1::ratio<1l, 100l>, char>(fmt::v12::basic_string_view<char>, 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
296
  }
22
328
}
void invoke_inner<std::__1::ratio<1l, 10l>, char>(fmt::v12::basic_string_view<char>, char)
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
276
  }
22
311
}
void invoke_inner<std::__1::ratio<10l, 1l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
381
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
381
  auto value = std::chrono::duration<Rep, Period>(rep);
13
381
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
381
    auto buf = fmt::memory_buffer();
18
381
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
381
#endif
20
381
  } catch (std::exception&) {
21
333
  }
22
381
}
void invoke_inner<std::__1::ratio<1000l, 1l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
377
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
377
  auto value = std::chrono::duration<Rep, Period>(rep);
13
377
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
377
    auto buf = fmt::memory_buffer();
18
377
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
377
#endif
20
377
  } catch (std::exception&) {
21
339
  }
22
377
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, char>(fmt::v12::basic_string_view<char>, char)
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
347
  }
22
397
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
391
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
391
  auto value = std::chrono::duration<Rep, Period>(rep);
13
391
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
391
    auto buf = fmt::memory_buffer();
18
391
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
391
#endif
20
391
  } catch (std::exception&) {
21
338
  }
22
391
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, char>(fmt::v12::basic_string_view<char>, char)
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
278
  }
22
322
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
345
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
345
  auto value = std::chrono::duration<Rep, Period>(rep);
13
345
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
345
    auto buf = fmt::memory_buffer();
18
345
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
345
#endif
20
345
  } catch (std::exception&) {
21
297
  }
22
345
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, char>(fmt::v12::basic_string_view<char>, char)
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
310
  }
22
336
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
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
287
  }
22
334
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
340
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
340
  auto value = std::chrono::duration<Rep, Period>(rep);
13
340
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
340
    auto buf = fmt::memory_buffer();
18
340
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
340
#endif
20
340
  } catch (std::exception&) {
21
303
  }
22
340
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, 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
301
  }
22
328
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
347
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
347
  auto value = std::chrono::duration<Rep, Period>(rep);
13
347
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
347
    auto buf = fmt::memory_buffer();
18
347
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
347
#endif
20
347
  } catch (std::exception&) {
21
307
  }
22
347
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
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
269
  }
22
314
}
void invoke_inner<std::__1::ratio<1l, 1000l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
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
280
  }
22
324
}
void invoke_inner<std::__1::ratio<1l, 100l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
339
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
339
  auto value = std::chrono::duration<Rep, Period>(rep);
13
339
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
339
    auto buf = fmt::memory_buffer();
18
339
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
339
#endif
20
339
  } catch (std::exception&) {
21
299
  }
22
339
}
void invoke_inner<std::__1::ratio<1l, 10l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
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
278
  }
22
317
}
void invoke_inner<std::__1::ratio<10l, 1l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
392
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
392
  auto value = std::chrono::duration<Rep, Period>(rep);
13
392
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
392
    auto buf = fmt::memory_buffer();
18
392
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
392
#endif
20
392
  } catch (std::exception&) {
21
362
  }
22
392
}
void invoke_inner<std::__1::ratio<1000l, 1l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
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
355
  }
22
404
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
421
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
421
  auto value = std::chrono::duration<Rep, Period>(rep);
13
421
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
421
    auto buf = fmt::memory_buffer();
18
421
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
421
#endif
20
421
  } catch (std::exception&) {
21
376
  }
22
421
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
420
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
420
  auto value = std::chrono::duration<Rep, Period>(rep);
13
420
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
420
    auto buf = fmt::memory_buffer();
18
420
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
420
#endif
20
420
  } catch (std::exception&) {
21
373
  }
22
420
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
346
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
346
  auto value = std::chrono::duration<Rep, Period>(rep);
13
346
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
346
    auto buf = fmt::memory_buffer();
18
346
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
346
#endif
20
346
  } catch (std::exception&) {
21
313
  }
22
346
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, signed char>(fmt::v12::basic_string_view<char>, signed 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
279
  }
22
310
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
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
286
  }
22
322
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
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
277
  }
22
314
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned 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
288
  }
22
330
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
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
278
  }
22
317
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned 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
280
  }
22
316
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned 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
270
  }
22
316
}
void invoke_inner<std::__1::ratio<1l, 1000l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
309
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
309
  auto value = std::chrono::duration<Rep, Period>(rep);
13
309
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
309
    auto buf = fmt::memory_buffer();
18
309
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
309
#endif
20
309
  } catch (std::exception&) {
21
275
  }
22
309
}
void invoke_inner<std::__1::ratio<1l, 100l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
320
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
320
  auto value = std::chrono::duration<Rep, Period>(rep);
13
320
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
320
    auto buf = fmt::memory_buffer();
18
320
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
320
#endif
20
320
  } catch (std::exception&) {
21
285
  }
22
320
}
void invoke_inner<std::__1::ratio<1l, 10l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned 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
278
  }
22
316
}
void invoke_inner<std::__1::ratio<10l, 1l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
372
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
372
  auto value = std::chrono::duration<Rep, Period>(rep);
13
372
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
372
    auto buf = fmt::memory_buffer();
18
372
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
372
#endif
20
372
  } catch (std::exception&) {
21
320
  }
22
372
}
void invoke_inner<std::__1::ratio<1000l, 1l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
380
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
380
  auto value = std::chrono::duration<Rep, Period>(rep);
13
380
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
380
    auto buf = fmt::memory_buffer();
18
380
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
380
#endif
20
380
  } catch (std::exception&) {
21
347
  }
22
380
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
395
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
395
  auto value = std::chrono::duration<Rep, Period>(rep);
13
395
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
395
    auto buf = fmt::memory_buffer();
18
395
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
395
#endif
20
395
  } catch (std::exception&) {
21
352
  }
22
395
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
385
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
385
  auto value = std::chrono::duration<Rep, Period>(rep);
13
385
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
385
    auto buf = fmt::memory_buffer();
18
385
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
385
#endif
20
385
  } catch (std::exception&) {
21
352
  }
22
385
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
340
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
340
  auto value = std::chrono::duration<Rep, Period>(rep);
13
340
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
340
    auto buf = fmt::memory_buffer();
18
340
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
340
#endif
20
340
  } catch (std::exception&) {
21
298
  }
22
340
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
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
287
  }
22
318
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned 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
301
  }
22
330
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
348
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
348
  auto value = std::chrono::duration<Rep, Period>(rep);
13
348
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
348
    auto buf = fmt::memory_buffer();
18
348
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
348
#endif
20
348
  } catch (std::exception&) {
21
315
  }
22
348
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
351
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
351
  auto value = std::chrono::duration<Rep, Period>(rep);
13
351
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
351
    auto buf = fmt::memory_buffer();
18
351
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
351
#endif
20
351
  } catch (std::exception&) {
21
316
  }
22
351
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
351
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
351
  auto value = std::chrono::duration<Rep, Period>(rep);
13
351
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
351
    auto buf = fmt::memory_buffer();
18
351
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
351
#endif
20
351
  } catch (std::exception&) {
21
313
  }
22
351
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
346
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
346
  auto value = std::chrono::duration<Rep, Period>(rep);
13
346
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
346
    auto buf = fmt::memory_buffer();
18
346
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
346
#endif
20
346
  } catch (std::exception&) {
21
311
  }
22
346
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
351
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
351
  auto value = std::chrono::duration<Rep, Period>(rep);
13
351
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
351
    auto buf = fmt::memory_buffer();
18
351
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
351
#endif
20
351
  } catch (std::exception&) {
21
309
  }
22
351
}
void invoke_inner<std::__1::ratio<1l, 1000l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
351
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
351
  auto value = std::chrono::duration<Rep, Period>(rep);
13
351
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
351
    auto buf = fmt::memory_buffer();
18
351
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
351
#endif
20
351
  } catch (std::exception&) {
21
314
  }
22
351
}
void invoke_inner<std::__1::ratio<1l, 100l>, short>(fmt::v12::basic_string_view<char>, short)
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
305
  }
22
353
}
void invoke_inner<std::__1::ratio<1l, 10l>, short>(fmt::v12::basic_string_view<char>, short)
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
303
  }
22
343
}
void invoke_inner<std::__1::ratio<10l, 1l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
401
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
401
  auto value = std::chrono::duration<Rep, Period>(rep);
13
401
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
401
    auto buf = fmt::memory_buffer();
18
401
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
401
#endif
20
401
  } catch (std::exception&) {
21
359
  }
22
401
}
void invoke_inner<std::__1::ratio<1000l, 1l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
423
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
423
  auto value = std::chrono::duration<Rep, Period>(rep);
13
423
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
423
    auto buf = fmt::memory_buffer();
18
423
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
423
#endif
20
423
  } catch (std::exception&) {
21
387
  }
22
423
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, short>(fmt::v12::basic_string_view<char>, short)
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
384
  }
22
430
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, short>(fmt::v12::basic_string_view<char>, short)
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
395
  }
22
433
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, short>(fmt::v12::basic_string_view<char>, short)
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
295
  }
22
328
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
349
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
349
  auto value = std::chrono::duration<Rep, Period>(rep);
13
349
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
349
    auto buf = fmt::memory_buffer();
18
349
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
349
#endif
20
349
  } catch (std::exception&) {
21
313
  }
22
349
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
315
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
315
  auto value = std::chrono::duration<Rep, Period>(rep);
13
315
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
315
    auto buf = fmt::memory_buffer();
18
315
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
315
#endif
20
315
  } catch (std::exception&) {
21
279
  }
22
315
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
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
294
  }
22
333
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
288
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
288
  auto value = std::chrono::duration<Rep, Period>(rep);
13
288
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
288
    auto buf = fmt::memory_buffer();
18
288
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
288
#endif
20
288
  } catch (std::exception&) {
21
253
  }
22
288
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
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
294
  }
22
322
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
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
254
  }
22
304
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
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
273
  }
22
314
}
void invoke_inner<std::__1::ratio<1l, 1000l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
315
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
315
  auto value = std::chrono::duration<Rep, Period>(rep);
13
315
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
315
    auto buf = fmt::memory_buffer();
18
315
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
315
#endif
20
315
  } catch (std::exception&) {
21
286
  }
22
315
}
void invoke_inner<std::__1::ratio<1l, 100l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
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
275
  }
22
311
}
void invoke_inner<std::__1::ratio<1l, 10l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
325
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
325
  auto value = std::chrono::duration<Rep, Period>(rep);
13
325
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
325
    auto buf = fmt::memory_buffer();
18
325
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
325
#endif
20
325
  } catch (std::exception&) {
21
291
  }
22
325
}
void invoke_inner<std::__1::ratio<10l, 1l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
377
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
377
  auto value = std::chrono::duration<Rep, Period>(rep);
13
377
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
377
    auto buf = fmt::memory_buffer();
18
377
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
377
#endif
20
377
  } catch (std::exception&) {
21
343
  }
22
377
}
void invoke_inner<std::__1::ratio<1000l, 1l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
401
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
401
  auto value = std::chrono::duration<Rep, Period>(rep);
13
401
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
401
    auto buf = fmt::memory_buffer();
18
401
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
401
#endif
20
401
  } catch (std::exception&) {
21
360
  }
22
401
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
371
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
371
  auto value = std::chrono::duration<Rep, Period>(rep);
13
371
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
371
    auto buf = fmt::memory_buffer();
18
371
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
371
#endif
20
371
  } catch (std::exception&) {
21
334
  }
22
371
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
340
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
340
  auto value = std::chrono::duration<Rep, Period>(rep);
13
340
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
340
    auto buf = fmt::memory_buffer();
18
340
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
340
#endif
20
340
  } catch (std::exception&) {
21
309
  }
22
340
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
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
277
  }
22
322
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
340
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
340
  auto value = std::chrono::duration<Rep, Period>(rep);
13
340
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
340
    auto buf = fmt::memory_buffer();
18
340
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
340
#endif
20
340
  } catch (std::exception&) {
21
291
  }
22
340
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
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
307
  }
22
329
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
401
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
401
  auto value = std::chrono::duration<Rep, Period>(rep);
13
401
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
401
    auto buf = fmt::memory_buffer();
18
401
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
401
#endif
20
401
  } catch (std::exception&) {
21
361
  }
22
401
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
378
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
378
  auto value = std::chrono::duration<Rep, Period>(rep);
13
378
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
378
    auto buf = fmt::memory_buffer();
18
378
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
378
#endif
20
378
  } catch (std::exception&) {
21
336
  }
22
378
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
413
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
413
  auto value = std::chrono::duration<Rep, Period>(rep);
13
413
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
413
    auto buf = fmt::memory_buffer();
18
413
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
413
#endif
20
413
  } catch (std::exception&) {
21
370
  }
22
413
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
354
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
354
  auto value = std::chrono::duration<Rep, Period>(rep);
13
354
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
354
    auto buf = fmt::memory_buffer();
18
354
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
354
#endif
20
354
  } catch (std::exception&) {
21
312
  }
22
354
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
375
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
375
  auto value = std::chrono::duration<Rep, Period>(rep);
13
375
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
375
    auto buf = fmt::memory_buffer();
18
375
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
375
#endif
20
375
  } catch (std::exception&) {
21
332
  }
22
375
}
void invoke_inner<std::__1::ratio<1l, 1000l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
378
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
378
  auto value = std::chrono::duration<Rep, Period>(rep);
13
378
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
378
    auto buf = fmt::memory_buffer();
18
378
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
378
#endif
20
378
  } catch (std::exception&) {
21
330
  }
22
378
}
void invoke_inner<std::__1::ratio<1l, 100l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
373
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
373
  auto value = std::chrono::duration<Rep, Period>(rep);
13
373
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
373
    auto buf = fmt::memory_buffer();
18
373
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
373
#endif
20
373
  } catch (std::exception&) {
21
345
  }
22
373
}
void invoke_inner<std::__1::ratio<1l, 10l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
380
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
380
  auto value = std::chrono::duration<Rep, Period>(rep);
13
380
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
380
    auto buf = fmt::memory_buffer();
18
380
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
380
#endif
20
380
  } catch (std::exception&) {
21
337
  }
22
380
}
void invoke_inner<std::__1::ratio<10l, 1l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
454
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
454
  auto value = std::chrono::duration<Rep, Period>(rep);
13
454
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
454
    auto buf = fmt::memory_buffer();
18
454
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
454
#endif
20
454
  } catch (std::exception&) {
21
406
  }
22
454
}
void invoke_inner<std::__1::ratio<1000l, 1l>, int>(fmt::v12::basic_string_view<char>, int)
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
396
  }
22
442
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
447
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
447
  auto value = std::chrono::duration<Rep, Period>(rep);
13
447
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
447
    auto buf = fmt::memory_buffer();
18
447
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
447
#endif
20
447
  } catch (std::exception&) {
21
392
  }
22
447
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, int>(fmt::v12::basic_string_view<char>, int)
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
395
  }
22
442
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
386
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
386
  auto value = std::chrono::duration<Rep, Period>(rep);
13
386
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
386
    auto buf = fmt::memory_buffer();
18
386
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
386
#endif
20
386
  } catch (std::exception&) {
21
345
  }
22
386
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
352
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
352
  auto value = std::chrono::duration<Rep, Period>(rep);
13
352
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
352
    auto buf = fmt::memory_buffer();
18
352
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
352
#endif
20
352
  } catch (std::exception&) {
21
313
  }
22
352
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
361
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
361
  auto value = std::chrono::duration<Rep, Period>(rep);
13
361
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
361
    auto buf = fmt::memory_buffer();
18
361
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
361
#endif
20
361
  } catch (std::exception&) {
21
311
  }
22
361
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
364
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
364
  auto value = std::chrono::duration<Rep, Period>(rep);
13
364
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
364
    auto buf = fmt::memory_buffer();
18
364
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
364
#endif
20
364
  } catch (std::exception&) {
21
315
  }
22
364
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
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
300
  }
22
332
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
345
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
345
  auto value = std::chrono::duration<Rep, Period>(rep);
13
345
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
345
    auto buf = fmt::memory_buffer();
18
345
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
345
#endif
20
345
  } catch (std::exception&) {
21
311
  }
22
345
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
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
287
  }
22
319
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, 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
284
  }
22
317
}
void invoke_inner<std::__1::ratio<1l, 1000l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
325
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
325
  auto value = std::chrono::duration<Rep, Period>(rep);
13
325
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
325
    auto buf = fmt::memory_buffer();
18
325
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
325
#endif
20
325
  } catch (std::exception&) {
21
288
  }
22
325
}
void invoke_inner<std::__1::ratio<1l, 100l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned 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
300
  }
22
336
}
void invoke_inner<std::__1::ratio<1l, 10l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
308
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
308
  auto value = std::chrono::duration<Rep, Period>(rep);
13
308
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
308
    auto buf = fmt::memory_buffer();
18
308
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
308
#endif
20
308
  } catch (std::exception&) {
21
274
  }
22
308
}
void invoke_inner<std::__1::ratio<10l, 1l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
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
350
  }
22
393
}
void invoke_inner<std::__1::ratio<1000l, 1l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
406
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
406
  auto value = std::chrono::duration<Rep, Period>(rep);
13
406
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
406
    auto buf = fmt::memory_buffer();
18
406
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
406
#endif
20
406
  } catch (std::exception&) {
21
377
  }
22
406
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
394
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
394
  auto value = std::chrono::duration<Rep, Period>(rep);
13
394
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
394
    auto buf = fmt::memory_buffer();
18
394
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
394
#endif
20
394
  } catch (std::exception&) {
21
346
  }
22
394
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
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
371
  }
22
410
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned 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
308
  }
22
343
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
340
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
340
  auto value = std::chrono::duration<Rep, Period>(rep);
13
340
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
340
    auto buf = fmt::memory_buffer();
18
340
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
340
#endif
20
340
  } catch (std::exception&) {
21
313
  }
22
340
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned 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
291
  }
22
328
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
597
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
597
  auto value = std::chrono::duration<Rep, Period>(rep);
13
597
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
597
    auto buf = fmt::memory_buffer();
18
597
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
597
#endif
20
597
  } catch (std::exception&) {
21
547
  }
22
597
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
537
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
537
  auto value = std::chrono::duration<Rep, Period>(rep);
13
537
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
537
    auto buf = fmt::memory_buffer();
18
537
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
537
#endif
20
537
  } catch (std::exception&) {
21
494
  }
22
537
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
521
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
521
  auto value = std::chrono::duration<Rep, Period>(rep);
13
521
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
521
    auto buf = fmt::memory_buffer();
18
521
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
521
#endif
20
521
  } catch (std::exception&) {
21
471
  }
22
521
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
515
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
515
  auto value = std::chrono::duration<Rep, Period>(rep);
13
515
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
515
    auto buf = fmt::memory_buffer();
18
515
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
515
#endif
20
515
  } catch (std::exception&) {
21
469
  }
22
515
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
487
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
487
  auto value = std::chrono::duration<Rep, Period>(rep);
13
487
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
487
    auto buf = fmt::memory_buffer();
18
487
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
487
#endif
20
487
  } catch (std::exception&) {
21
438
  }
22
487
}
void invoke_inner<std::__1::ratio<1l, 1000l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
509
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
509
  auto value = std::chrono::duration<Rep, Period>(rep);
13
509
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
509
    auto buf = fmt::memory_buffer();
18
509
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
509
#endif
20
509
  } catch (std::exception&) {
21
460
  }
22
509
}
void invoke_inner<std::__1::ratio<1l, 100l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
431
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
431
  auto value = std::chrono::duration<Rep, Period>(rep);
13
431
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
431
    auto buf = fmt::memory_buffer();
18
431
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
431
#endif
20
431
  } catch (std::exception&) {
21
389
  }
22
431
}
void invoke_inner<std::__1::ratio<1l, 10l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
412
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
412
  auto value = std::chrono::duration<Rep, Period>(rep);
13
412
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
412
    auto buf = fmt::memory_buffer();
18
412
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
412
#endif
20
412
  } catch (std::exception&) {
21
379
  }
22
412
}
void invoke_inner<std::__1::ratio<10l, 1l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
529
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
529
  auto value = std::chrono::duration<Rep, Period>(rep);
13
529
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
529
    auto buf = fmt::memory_buffer();
18
529
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
529
#endif
20
529
  } catch (std::exception&) {
21
500
  }
22
529
}
void invoke_inner<std::__1::ratio<1000l, 1l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
549
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
549
  auto value = std::chrono::duration<Rep, Period>(rep);
13
549
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
549
    auto buf = fmt::memory_buffer();
18
549
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
549
#endif
20
549
  } catch (std::exception&) {
21
505
  }
22
549
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
503
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
503
  auto value = std::chrono::duration<Rep, Period>(rep);
13
503
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
503
    auto buf = fmt::memory_buffer();
18
503
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
503
#endif
20
503
  } catch (std::exception&) {
21
469
  }
22
503
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
505
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
505
  auto value = std::chrono::duration<Rep, Period>(rep);
13
505
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
505
    auto buf = fmt::memory_buffer();
18
505
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
505
#endif
20
505
  } catch (std::exception&) {
21
462
  }
22
505
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
511
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
511
  auto value = std::chrono::duration<Rep, Period>(rep);
13
511
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
511
    auto buf = fmt::memory_buffer();
18
511
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
511
#endif
20
511
  } catch (std::exception&) {
21
476
  }
22
511
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, long>(fmt::v12::basic_string_view<char>, long)
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
415
  }
22
453
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
457
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
457
  auto value = std::chrono::duration<Rep, Period>(rep);
13
457
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
457
    auto buf = fmt::memory_buffer();
18
457
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
457
#endif
20
457
  } catch (std::exception&) {
21
430
  }
22
457
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
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
377
  }
22
433
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
Line
Count
Source
11
408
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
408
  auto value = std::chrono::duration<Rep, Period>(rep);
13
408
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
408
    auto buf = fmt::memory_buffer();
18
408
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
408
#endif
20
408
  } catch (std::exception&) {
21
358
  }
22
408
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
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
376
  }
22
418
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
Line
Count
Source
11
387
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
387
  auto value = std::chrono::duration<Rep, Period>(rep);
13
387
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
387
    auto buf = fmt::memory_buffer();
18
387
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
387
#endif
20
387
  } catch (std::exception&) {
21
344
  }
22
387
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned 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
373
  }
22
414
}
void invoke_inner<std::__1::ratio<1l, 1000l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
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
370
  }
22
404
}
void invoke_inner<std::__1::ratio<1l, 100l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned 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
345
  }
22
389
}
void invoke_inner<std::__1::ratio<1l, 10l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
Line
Count
Source
11
379
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
379
  auto value = std::chrono::duration<Rep, Period>(rep);
13
379
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
379
    auto buf = fmt::memory_buffer();
18
379
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
379
#endif
20
379
  } catch (std::exception&) {
21
344
  }
22
379
}
void invoke_inner<std::__1::ratio<10l, 1l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
Line
Count
Source
11
429
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
429
  auto value = std::chrono::duration<Rep, Period>(rep);
13
429
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
429
    auto buf = fmt::memory_buffer();
18
429
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
429
#endif
20
429
  } catch (std::exception&) {
21
381
  }
22
429
}
void invoke_inner<std::__1::ratio<1000l, 1l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
Line
Count
Source
11
450
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
450
  auto value = std::chrono::duration<Rep, Period>(rep);
13
450
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
450
    auto buf = fmt::memory_buffer();
18
450
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
450
#endif
20
450
  } catch (std::exception&) {
21
410
  }
22
450
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
Line
Count
Source
11
406
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
406
  auto value = std::chrono::duration<Rep, Period>(rep);
13
406
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
406
    auto buf = fmt::memory_buffer();
18
406
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
406
#endif
20
406
  } catch (std::exception&) {
21
362
  }
22
406
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
Line
Count
Source
11
386
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
386
  auto value = std::chrono::duration<Rep, Period>(rep);
13
386
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
386
    auto buf = fmt::memory_buffer();
18
386
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
386
#endif
20
386
  } catch (std::exception&) {
21
348
  }
22
386
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
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
390
  }
22
422
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
Line
Count
Source
11
409
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
409
  auto value = std::chrono::duration<Rep, Period>(rep);
13
409
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
409
    auto buf = fmt::memory_buffer();
18
409
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
409
#endif
20
409
  } catch (std::exception&) {
21
361
  }
22
409
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
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
381
  }
22
427
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
596
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
596
  auto value = std::chrono::duration<Rep, Period>(rep);
13
596
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
596
    auto buf = fmt::memory_buffer();
18
596
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
596
#endif
20
596
  } catch (std::exception&) {
21
535
  }
22
596
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
558
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
558
  auto value = std::chrono::duration<Rep, Period>(rep);
13
558
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
558
    auto buf = fmt::memory_buffer();
18
558
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
558
#endif
20
558
  } catch (std::exception&) {
21
495
  }
22
558
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
559
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
559
  auto value = std::chrono::duration<Rep, Period>(rep);
13
559
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
559
    auto buf = fmt::memory_buffer();
18
559
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
559
#endif
20
559
  } catch (std::exception&) {
21
495
  }
22
559
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
548
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
548
  auto value = std::chrono::duration<Rep, Period>(rep);
13
548
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
548
    auto buf = fmt::memory_buffer();
18
548
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
548
#endif
20
548
  } catch (std::exception&) {
21
496
  }
22
548
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
552
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
552
  auto value = std::chrono::duration<Rep, Period>(rep);
13
552
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
552
    auto buf = fmt::memory_buffer();
18
552
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
552
#endif
20
552
  } catch (std::exception&) {
21
488
  }
22
552
}
void invoke_inner<std::__1::ratio<1l, 1000l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
528
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
528
  auto value = std::chrono::duration<Rep, Period>(rep);
13
528
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
528
    auto buf = fmt::memory_buffer();
18
528
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
528
#endif
20
528
  } catch (std::exception&) {
21
465
  }
22
528
}
void invoke_inner<std::__1::ratio<1l, 100l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
524
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
524
  auto value = std::chrono::duration<Rep, Period>(rep);
13
524
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
524
    auto buf = fmt::memory_buffer();
18
524
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
524
#endif
20
524
  } catch (std::exception&) {
21
460
  }
22
524
}
void invoke_inner<std::__1::ratio<1l, 10l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
534
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
534
  auto value = std::chrono::duration<Rep, Period>(rep);
13
534
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
534
    auto buf = fmt::memory_buffer();
18
534
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
534
#endif
20
534
  } catch (std::exception&) {
21
477
  }
22
534
}
void invoke_inner<std::__1::ratio<10l, 1l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
537
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
537
  auto value = std::chrono::duration<Rep, Period>(rep);
13
537
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
537
    auto buf = fmt::memory_buffer();
18
537
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
537
#endif
20
537
  } catch (std::exception&) {
21
498
  }
22
537
}
void invoke_inner<std::__1::ratio<1000l, 1l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
555
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
555
  auto value = std::chrono::duration<Rep, Period>(rep);
13
555
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
555
    auto buf = fmt::memory_buffer();
18
555
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
555
#endif
20
555
  } catch (std::exception&) {
21
492
  }
22
555
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
569
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
569
  auto value = std::chrono::duration<Rep, Period>(rep);
13
569
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
569
    auto buf = fmt::memory_buffer();
18
569
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
569
#endif
20
569
  } catch (std::exception&) {
21
510
  }
22
569
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
556
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
556
  auto value = std::chrono::duration<Rep, Period>(rep);
13
556
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
556
    auto buf = fmt::memory_buffer();
18
556
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
556
#endif
20
556
  } catch (std::exception&) {
21
497
  }
22
556
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
546
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
546
  auto value = std::chrono::duration<Rep, Period>(rep);
13
546
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
546
    auto buf = fmt::memory_buffer();
18
546
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
546
#endif
20
546
  } catch (std::exception&) {
21
499
  }
22
546
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
536
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
536
  auto value = std::chrono::duration<Rep, Period>(rep);
13
536
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
536
    auto buf = fmt::memory_buffer();
18
536
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
536
#endif
20
536
  } catch (std::exception&) {
21
483
  }
22
536
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
544
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
544
  auto value = std::chrono::duration<Rep, Period>(rep);
13
544
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
544
    auto buf = fmt::memory_buffer();
18
544
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
544
#endif
20
544
  } catch (std::exception&) {
21
482
  }
22
544
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
588
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
588
  auto value = std::chrono::duration<Rep, Period>(rep);
13
588
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
588
    auto buf = fmt::memory_buffer();
18
588
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
588
#endif
20
588
  } catch (std::exception&) {
21
527
  }
22
588
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
585
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
585
  auto value = std::chrono::duration<Rep, Period>(rep);
13
585
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
585
    auto buf = fmt::memory_buffer();
18
585
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
585
#endif
20
585
  } catch (std::exception&) {
21
523
  }
22
585
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
560
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
560
  auto value = std::chrono::duration<Rep, Period>(rep);
13
560
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
560
    auto buf = fmt::memory_buffer();
18
560
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
560
#endif
20
560
  } catch (std::exception&) {
21
498
  }
22
560
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
568
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
568
  auto value = std::chrono::duration<Rep, Period>(rep);
13
568
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
568
    auto buf = fmt::memory_buffer();
18
568
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
568
#endif
20
568
  } catch (std::exception&) {
21
513
  }
22
568
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
573
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
573
  auto value = std::chrono::duration<Rep, Period>(rep);
13
573
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
573
    auto buf = fmt::memory_buffer();
18
573
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
573
#endif
20
573
  } catch (std::exception&) {
21
509
  }
22
573
}
void invoke_inner<std::__1::ratio<1l, 1000l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
627
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
627
  auto value = std::chrono::duration<Rep, Period>(rep);
13
627
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
627
    auto buf = fmt::memory_buffer();
18
627
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
627
#endif
20
627
  } catch (std::exception&) {
21
564
  }
22
627
}
void invoke_inner<std::__1::ratio<1l, 100l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
589
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
589
  auto value = std::chrono::duration<Rep, Period>(rep);
13
589
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
589
    auto buf = fmt::memory_buffer();
18
589
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
589
#endif
20
589
  } catch (std::exception&) {
21
525
  }
22
589
}
void invoke_inner<std::__1::ratio<1l, 10l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
567
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
567
  auto value = std::chrono::duration<Rep, Period>(rep);
13
567
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
567
    auto buf = fmt::memory_buffer();
18
567
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
567
#endif
20
567
  } catch (std::exception&) {
21
494
  }
22
567
}
void invoke_inner<std::__1::ratio<10l, 1l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
559
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
559
  auto value = std::chrono::duration<Rep, Period>(rep);
13
559
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
559
    auto buf = fmt::memory_buffer();
18
559
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
559
#endif
20
559
  } catch (std::exception&) {
21
504
  }
22
559
}
void invoke_inner<std::__1::ratio<1000l, 1l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
580
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
580
  auto value = std::chrono::duration<Rep, Period>(rep);
13
580
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
580
    auto buf = fmt::memory_buffer();
18
580
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
580
#endif
20
580
  } catch (std::exception&) {
21
506
  }
22
580
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
569
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
569
  auto value = std::chrono::duration<Rep, Period>(rep);
13
569
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
569
    auto buf = fmt::memory_buffer();
18
569
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
569
#endif
20
569
  } catch (std::exception&) {
21
498
  }
22
569
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
566
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
566
  auto value = std::chrono::duration<Rep, Period>(rep);
13
566
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
566
    auto buf = fmt::memory_buffer();
18
566
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
566
#endif
20
566
  } catch (std::exception&) {
21
512
  }
22
566
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
541
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
541
  auto value = std::chrono::duration<Rep, Period>(rep);
13
541
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
541
    auto buf = fmt::memory_buffer();
18
541
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
541
#endif
20
541
  } catch (std::exception&) {
21
497
  }
22
541
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
546
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
546
  auto value = std::chrono::duration<Rep, Period>(rep);
13
546
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
546
    auto buf = fmt::memory_buffer();
18
546
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
546
#endif
20
546
  } catch (std::exception&) {
21
475
  }
22
546
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
561
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
561
  auto value = std::chrono::duration<Rep, Period>(rep);
13
561
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
561
    auto buf = fmt::memory_buffer();
18
561
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
561
#endif
20
561
  } catch (std::exception&) {
21
484
  }
22
561
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
559
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
559
  auto value = std::chrono::duration<Rep, Period>(rep);
13
559
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
559
    auto buf = fmt::memory_buffer();
18
559
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
559
#endif
20
559
  } catch (std::exception&) {
21
489
  }
22
559
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
541
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
541
  auto value = std::chrono::duration<Rep, Period>(rep);
13
541
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
541
    auto buf = fmt::memory_buffer();
18
541
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
541
#endif
20
541
  } catch (std::exception&) {
21
472
  }
22
541
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
553
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
553
  auto value = std::chrono::duration<Rep, Period>(rep);
13
553
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
553
    auto buf = fmt::memory_buffer();
18
553
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
553
#endif
20
553
  } catch (std::exception&) {
21
499
  }
22
553
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
541
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
541
  auto value = std::chrono::duration<Rep, Period>(rep);
13
541
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
541
    auto buf = fmt::memory_buffer();
18
541
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
541
#endif
20
541
  } catch (std::exception&) {
21
487
  }
22
541
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
554
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
554
  auto value = std::chrono::duration<Rep, Period>(rep);
13
554
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
554
    auto buf = fmt::memory_buffer();
18
554
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
554
#endif
20
554
  } catch (std::exception&) {
21
466
  }
22
554
}
void invoke_inner<std::__1::ratio<1l, 1000l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
587
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
587
  auto value = std::chrono::duration<Rep, Period>(rep);
13
587
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
587
    auto buf = fmt::memory_buffer();
18
587
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
587
#endif
20
587
  } catch (std::exception&) {
21
524
  }
22
587
}
void invoke_inner<std::__1::ratio<1l, 100l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
586
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
586
  auto value = std::chrono::duration<Rep, Period>(rep);
13
586
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
586
    auto buf = fmt::memory_buffer();
18
586
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
586
#endif
20
586
  } catch (std::exception&) {
21
518
  }
22
586
}
void invoke_inner<std::__1::ratio<1l, 10l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
543
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
543
  auto value = std::chrono::duration<Rep, Period>(rep);
13
543
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
543
    auto buf = fmt::memory_buffer();
18
543
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
543
#endif
20
543
  } catch (std::exception&) {
21
478
  }
22
543
}
void invoke_inner<std::__1::ratio<10l, 1l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
563
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
563
  auto value = std::chrono::duration<Rep, Period>(rep);
13
563
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
563
    auto buf = fmt::memory_buffer();
18
563
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
563
#endif
20
563
  } catch (std::exception&) {
21
480
  }
22
563
}
void invoke_inner<std::__1::ratio<1000l, 1l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
550
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
550
  auto value = std::chrono::duration<Rep, Period>(rep);
13
550
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
550
    auto buf = fmt::memory_buffer();
18
550
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
550
#endif
20
550
  } catch (std::exception&) {
21
486
  }
22
550
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
553
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
553
  auto value = std::chrono::duration<Rep, Period>(rep);
13
553
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
553
    auto buf = fmt::memory_buffer();
18
553
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
553
#endif
20
553
  } catch (std::exception&) {
21
476
  }
22
553
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
559
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
559
  auto value = std::chrono::duration<Rep, Period>(rep);
13
559
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
559
    auto buf = fmt::memory_buffer();
18
559
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
559
#endif
20
559
  } catch (std::exception&) {
21
500
  }
22
559
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
609
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
609
  auto value = std::chrono::duration<Rep, Period>(rep);
13
609
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
609
    auto buf = fmt::memory_buffer();
18
609
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
609
#endif
20
609
  } catch (std::exception&) {
21
544
  }
22
609
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
561
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
561
  auto value = std::chrono::duration<Rep, Period>(rep);
13
561
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
561
    auto buf = fmt::memory_buffer();
18
561
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
561
#endif
20
561
  } catch (std::exception&) {
21
506
  }
22
561
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
546
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
546
  auto value = std::chrono::duration<Rep, Period>(rep);
13
546
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
546
    auto buf = fmt::memory_buffer();
18
546
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
546
#endif
20
546
  } catch (std::exception&) {
21
474
  }
22
546
}
23
24
// Rep is a duration's representation type.
25
template <typename Rep>
26
76.1k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
76.1k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
76.1k
  if (size <= fixed_size + 1) return;
30
31
76.0k
  const Rep rep = assign_from_buf<Rep>(data);
32
76.0k
  data += fixed_size;
33
76.0k
  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
76.0k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
76.0k
  switch (period) {
41
5.20k
  case 1:
42
5.20k
    invoke_inner<std::atto>(format_str, rep);
43
5.20k
    break;
44
4.97k
  case 2:
45
4.97k
    invoke_inner<std::femto>(format_str, rep);
46
4.97k
    break;
47
4.99k
  case 3:
48
4.99k
    invoke_inner<std::pico>(format_str, rep);
49
4.99k
    break;
50
4.87k
  case 4:
51
4.87k
    invoke_inner<std::nano>(format_str, rep);
52
4.87k
    break;
53
4.89k
  case 5:
54
4.89k
    invoke_inner<std::micro>(format_str, rep);
55
4.89k
    break;
56
4.97k
  case 6:
57
4.97k
    invoke_inner<std::milli>(format_str, rep);
58
4.97k
    break;
59
4.87k
  case 7:
60
4.87k
    invoke_inner<std::centi>(format_str, rep);
61
4.87k
    break;
62
4.73k
  case 8:
63
4.73k
    invoke_inner<std::deci>(format_str, rep);
64
4.73k
    break;
65
5.38k
  case 9:
66
5.38k
    invoke_inner<std::deca>(format_str, rep);
67
5.38k
    break;
68
5.51k
  case 10:
69
5.51k
    invoke_inner<std::kilo>(format_str, rep);
70
5.51k
    break;
71
5.45k
  case 11:
72
5.45k
    invoke_inner<std::mega>(format_str, rep);
73
5.45k
    break;
74
5.39k
  case 12:
75
5.39k
    invoke_inner<std::giga>(format_str, rep);
76
5.39k
    break;
77
5.01k
  case 13:
78
5.01k
    invoke_inner<std::tera>(format_str, rep);
79
5.01k
    break;
80
4.85k
  case 14:
81
4.85k
    invoke_inner<std::peta>(format_str, rep);
82
4.85k
    break;
83
4.85k
  case 15:
84
4.85k
    invoke_inner<std::exa>(format_str, rep);
85
4.85k
    break;
86
76.0k
  }
87
76.0k
}
void invoke_outer<char>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
5.14k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
5.14k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
5.14k
  if (size <= fixed_size + 1) return;
30
31
5.14k
  const Rep rep = assign_from_buf<Rep>(data);
32
5.14k
  data += fixed_size;
33
5.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
5.14k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
5.14k
  switch (period) {
41
340
  case 1:
42
340
    invoke_inner<std::atto>(format_str, rep);
43
340
    break;
44
331
  case 2:
45
331
    invoke_inner<std::femto>(format_str, rep);
46
331
    break;
47
304
  case 3:
48
304
    invoke_inner<std::pico>(format_str, rep);
49
304
    break;
50
329
  case 4:
51
329
    invoke_inner<std::nano>(format_str, rep);
52
329
    break;
53
329
  case 5:
54
329
    invoke_inner<std::micro>(format_str, rep);
55
329
    break;
56
320
  case 6:
57
320
    invoke_inner<std::milli>(format_str, rep);
58
320
    break;
59
328
  case 7:
60
328
    invoke_inner<std::centi>(format_str, rep);
61
328
    break;
62
311
  case 8:
63
311
    invoke_inner<std::deci>(format_str, rep);
64
311
    break;
65
381
  case 9:
66
381
    invoke_inner<std::deca>(format_str, rep);
67
381
    break;
68
377
  case 10:
69
377
    invoke_inner<std::kilo>(format_str, rep);
70
377
    break;
71
397
  case 11:
72
397
    invoke_inner<std::mega>(format_str, rep);
73
397
    break;
74
391
  case 12:
75
391
    invoke_inner<std::giga>(format_str, rep);
76
391
    break;
77
322
  case 13:
78
322
    invoke_inner<std::tera>(format_str, rep);
79
322
    break;
80
345
  case 14:
81
345
    invoke_inner<std::peta>(format_str, rep);
82
345
    break;
83
336
  case 15:
84
336
    invoke_inner<std::exa>(format_str, rep);
85
336
    break;
86
5.14k
  }
87
5.14k
}
void invoke_outer<signed char>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
5.26k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
5.26k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
5.26k
  if (size <= fixed_size + 1) return;
30
31
5.25k
  const Rep rep = assign_from_buf<Rep>(data);
32
5.25k
  data += fixed_size;
33
5.25k
  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.25k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
5.25k
  switch (period) {
41
334
  case 1:
42
334
    invoke_inner<std::atto>(format_str, rep);
43
334
    break;
44
340
  case 2:
45
340
    invoke_inner<std::femto>(format_str, rep);
46
340
    break;
47
328
  case 3:
48
328
    invoke_inner<std::pico>(format_str, rep);
49
328
    break;
50
347
  case 4:
51
347
    invoke_inner<std::nano>(format_str, rep);
52
347
    break;
53
314
  case 5:
54
314
    invoke_inner<std::micro>(format_str, rep);
55
314
    break;
56
324
  case 6:
57
324
    invoke_inner<std::milli>(format_str, rep);
58
324
    break;
59
339
  case 7:
60
339
    invoke_inner<std::centi>(format_str, rep);
61
339
    break;
62
317
  case 8:
63
317
    invoke_inner<std::deci>(format_str, rep);
64
317
    break;
65
392
  case 9:
66
392
    invoke_inner<std::deca>(format_str, rep);
67
392
    break;
68
404
  case 10:
69
404
    invoke_inner<std::kilo>(format_str, rep);
70
404
    break;
71
421
  case 11:
72
421
    invoke_inner<std::mega>(format_str, rep);
73
421
    break;
74
420
  case 12:
75
420
    invoke_inner<std::giga>(format_str, rep);
76
420
    break;
77
346
  case 13:
78
346
    invoke_inner<std::tera>(format_str, rep);
79
346
    break;
80
310
  case 14:
81
310
    invoke_inner<std::peta>(format_str, rep);
82
310
    break;
83
322
  case 15:
84
322
    invoke_inner<std::exa>(format_str, rep);
85
322
    break;
86
5.25k
  }
87
5.25k
}
void invoke_outer<unsigned char>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
5.06k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
5.06k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
5.06k
  if (size <= fixed_size + 1) return;
30
31
5.05k
  const Rep rep = assign_from_buf<Rep>(data);
32
5.05k
  data += fixed_size;
33
5.05k
  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.05k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
5.05k
  switch (period) {
41
314
  case 1:
42
314
    invoke_inner<std::atto>(format_str, rep);
43
314
    break;
44
330
  case 2:
45
330
    invoke_inner<std::femto>(format_str, rep);
46
330
    break;
47
317
  case 3:
48
317
    invoke_inner<std::pico>(format_str, rep);
49
317
    break;
50
316
  case 4:
51
316
    invoke_inner<std::nano>(format_str, rep);
52
316
    break;
53
316
  case 5:
54
316
    invoke_inner<std::micro>(format_str, rep);
55
316
    break;
56
309
  case 6:
57
309
    invoke_inner<std::milli>(format_str, rep);
58
309
    break;
59
320
  case 7:
60
320
    invoke_inner<std::centi>(format_str, rep);
61
320
    break;
62
316
  case 8:
63
316
    invoke_inner<std::deci>(format_str, rep);
64
316
    break;
65
372
  case 9:
66
372
    invoke_inner<std::deca>(format_str, rep);
67
372
    break;
68
380
  case 10:
69
380
    invoke_inner<std::kilo>(format_str, rep);
70
380
    break;
71
395
  case 11:
72
395
    invoke_inner<std::mega>(format_str, rep);
73
395
    break;
74
385
  case 12:
75
385
    invoke_inner<std::giga>(format_str, rep);
76
385
    break;
77
340
  case 13:
78
340
    invoke_inner<std::tera>(format_str, rep);
79
340
    break;
80
318
  case 14:
81
318
    invoke_inner<std::peta>(format_str, rep);
82
318
    break;
83
330
  case 15:
84
330
    invoke_inner<std::exa>(format_str, rep);
85
330
    break;
86
5.05k
  }
87
5.05k
}
void invoke_outer<short>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
5.48k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
5.48k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
5.48k
  if (size <= fixed_size + 1) return;
30
31
5.47k
  const Rep rep = assign_from_buf<Rep>(data);
32
5.47k
  data += fixed_size;
33
5.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
5.47k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
5.47k
  switch (period) {
41
348
  case 1:
42
348
    invoke_inner<std::atto>(format_str, rep);
43
348
    break;
44
351
  case 2:
45
351
    invoke_inner<std::femto>(format_str, rep);
46
351
    break;
47
351
  case 3:
48
351
    invoke_inner<std::pico>(format_str, rep);
49
351
    break;
50
346
  case 4:
51
346
    invoke_inner<std::nano>(format_str, rep);
52
346
    break;
53
351
  case 5:
54
351
    invoke_inner<std::micro>(format_str, rep);
55
351
    break;
56
351
  case 6:
57
351
    invoke_inner<std::milli>(format_str, rep);
58
351
    break;
59
353
  case 7:
60
353
    invoke_inner<std::centi>(format_str, rep);
61
353
    break;
62
343
  case 8:
63
343
    invoke_inner<std::deci>(format_str, rep);
64
343
    break;
65
401
  case 9:
66
401
    invoke_inner<std::deca>(format_str, rep);
67
401
    break;
68
423
  case 10:
69
423
    invoke_inner<std::kilo>(format_str, rep);
70
423
    break;
71
430
  case 11:
72
430
    invoke_inner<std::mega>(format_str, rep);
73
430
    break;
74
433
  case 12:
75
433
    invoke_inner<std::giga>(format_str, rep);
76
433
    break;
77
328
  case 13:
78
328
    invoke_inner<std::tera>(format_str, rep);
79
328
    break;
80
349
  case 14:
81
349
    invoke_inner<std::peta>(format_str, rep);
82
349
    break;
83
315
  case 15:
84
315
    invoke_inner<std::exa>(format_str, rep);
85
315
    break;
86
5.47k
  }
87
5.47k
}
void invoke_outer<unsigned short>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
5.00k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
5.00k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
5.00k
  if (size <= fixed_size + 1) return;
30
31
4.99k
  const Rep rep = assign_from_buf<Rep>(data);
32
4.99k
  data += fixed_size;
33
4.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
4.99k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
4.99k
  switch (period) {
41
333
  case 1:
42
333
    invoke_inner<std::atto>(format_str, rep);
43
333
    break;
44
288
  case 2:
45
288
    invoke_inner<std::femto>(format_str, rep);
46
288
    break;
47
322
  case 3:
48
322
    invoke_inner<std::pico>(format_str, rep);
49
322
    break;
50
304
  case 4:
51
304
    invoke_inner<std::nano>(format_str, rep);
52
304
    break;
53
314
  case 5:
54
314
    invoke_inner<std::micro>(format_str, rep);
55
314
    break;
56
315
  case 6:
57
315
    invoke_inner<std::milli>(format_str, rep);
58
315
    break;
59
311
  case 7:
60
311
    invoke_inner<std::centi>(format_str, rep);
61
311
    break;
62
325
  case 8:
63
325
    invoke_inner<std::deci>(format_str, rep);
64
325
    break;
65
377
  case 9:
66
377
    invoke_inner<std::deca>(format_str, rep);
67
377
    break;
68
401
  case 10:
69
401
    invoke_inner<std::kilo>(format_str, rep);
70
401
    break;
71
371
  case 11:
72
371
    invoke_inner<std::mega>(format_str, rep);
73
371
    break;
74
340
  case 12:
75
340
    invoke_inner<std::giga>(format_str, rep);
76
340
    break;
77
322
  case 13:
78
322
    invoke_inner<std::tera>(format_str, rep);
79
322
    break;
80
340
  case 14:
81
340
    invoke_inner<std::peta>(format_str, rep);
82
340
    break;
83
329
  case 15:
84
329
    invoke_inner<std::exa>(format_str, rep);
85
329
    break;
86
4.99k
  }
87
4.99k
}
void invoke_outer<int>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
5.94k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
5.94k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
5.94k
  if (size <= fixed_size + 1) return;
30
31
5.93k
  const Rep rep = assign_from_buf<Rep>(data);
32
5.93k
  data += fixed_size;
33
5.93k
  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.93k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
5.93k
  switch (period) {
41
401
  case 1:
42
401
    invoke_inner<std::atto>(format_str, rep);
43
401
    break;
44
378
  case 2:
45
378
    invoke_inner<std::femto>(format_str, rep);
46
378
    break;
47
413
  case 3:
48
413
    invoke_inner<std::pico>(format_str, rep);
49
413
    break;
50
354
  case 4:
51
354
    invoke_inner<std::nano>(format_str, rep);
52
354
    break;
53
375
  case 5:
54
375
    invoke_inner<std::micro>(format_str, rep);
55
375
    break;
56
378
  case 6:
57
378
    invoke_inner<std::milli>(format_str, rep);
58
378
    break;
59
373
  case 7:
60
373
    invoke_inner<std::centi>(format_str, rep);
61
373
    break;
62
380
  case 8:
63
380
    invoke_inner<std::deci>(format_str, rep);
64
380
    break;
65
454
  case 9:
66
454
    invoke_inner<std::deca>(format_str, rep);
67
454
    break;
68
442
  case 10:
69
442
    invoke_inner<std::kilo>(format_str, rep);
70
442
    break;
71
447
  case 11:
72
447
    invoke_inner<std::mega>(format_str, rep);
73
447
    break;
74
442
  case 12:
75
442
    invoke_inner<std::giga>(format_str, rep);
76
442
    break;
77
386
  case 13:
78
386
    invoke_inner<std::tera>(format_str, rep);
79
386
    break;
80
352
  case 14:
81
352
    invoke_inner<std::peta>(format_str, rep);
82
352
    break;
83
361
  case 15:
84
361
    invoke_inner<std::exa>(format_str, rep);
85
361
    break;
86
5.93k
  }
87
5.93k
}
void invoke_outer<unsigned int>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
5.26k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
5.26k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
5.26k
  if (size <= fixed_size + 1) return;
30
31
5.26k
  const Rep rep = assign_from_buf<Rep>(data);
32
5.26k
  data += fixed_size;
33
5.26k
  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.26k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
5.26k
  switch (period) {
41
364
  case 1:
42
364
    invoke_inner<std::atto>(format_str, rep);
43
364
    break;
44
332
  case 2:
45
332
    invoke_inner<std::femto>(format_str, rep);
46
332
    break;
47
345
  case 3:
48
345
    invoke_inner<std::pico>(format_str, rep);
49
345
    break;
50
319
  case 4:
51
319
    invoke_inner<std::nano>(format_str, rep);
52
319
    break;
53
317
  case 5:
54
317
    invoke_inner<std::micro>(format_str, rep);
55
317
    break;
56
325
  case 6:
57
325
    invoke_inner<std::milli>(format_str, rep);
58
325
    break;
59
336
  case 7:
60
336
    invoke_inner<std::centi>(format_str, rep);
61
336
    break;
62
308
  case 8:
63
308
    invoke_inner<std::deci>(format_str, rep);
64
308
    break;
65
393
  case 9:
66
393
    invoke_inner<std::deca>(format_str, rep);
67
393
    break;
68
406
  case 10:
69
406
    invoke_inner<std::kilo>(format_str, rep);
70
406
    break;
71
394
  case 11:
72
394
    invoke_inner<std::mega>(format_str, rep);
73
394
    break;
74
410
  case 12:
75
410
    invoke_inner<std::giga>(format_str, rep);
76
410
    break;
77
343
  case 13:
78
343
    invoke_inner<std::tera>(format_str, rep);
79
343
    break;
80
340
  case 14:
81
340
    invoke_inner<std::peta>(format_str, rep);
82
340
    break;
83
328
  case 15:
84
328
    invoke_inner<std::exa>(format_str, rep);
85
328
    break;
86
5.26k
  }
87
5.26k
}
void invoke_outer<long>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
7.52k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
7.52k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
7.52k
  if (size <= fixed_size + 1) return;
30
31
7.51k
  const Rep rep = assign_from_buf<Rep>(data);
32
7.51k
  data += fixed_size;
33
7.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
7.51k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
7.51k
  switch (period) {
41
597
  case 1:
42
597
    invoke_inner<std::atto>(format_str, rep);
43
597
    break;
44
537
  case 2:
45
537
    invoke_inner<std::femto>(format_str, rep);
46
537
    break;
47
521
  case 3:
48
521
    invoke_inner<std::pico>(format_str, rep);
49
521
    break;
50
515
  case 4:
51
515
    invoke_inner<std::nano>(format_str, rep);
52
515
    break;
53
487
  case 5:
54
487
    invoke_inner<std::micro>(format_str, rep);
55
487
    break;
56
509
  case 6:
57
509
    invoke_inner<std::milli>(format_str, rep);
58
509
    break;
59
431
  case 7:
60
431
    invoke_inner<std::centi>(format_str, rep);
61
431
    break;
62
412
  case 8:
63
412
    invoke_inner<std::deci>(format_str, rep);
64
412
    break;
65
529
  case 9:
66
529
    invoke_inner<std::deca>(format_str, rep);
67
529
    break;
68
549
  case 10:
69
549
    invoke_inner<std::kilo>(format_str, rep);
70
549
    break;
71
503
  case 11:
72
503
    invoke_inner<std::mega>(format_str, rep);
73
503
    break;
74
505
  case 12:
75
505
    invoke_inner<std::giga>(format_str, rep);
76
505
    break;
77
511
  case 13:
78
511
    invoke_inner<std::tera>(format_str, rep);
79
511
    break;
80
453
  case 14:
81
453
    invoke_inner<std::peta>(format_str, rep);
82
453
    break;
83
457
  case 15:
84
457
    invoke_inner<std::exa>(format_str, rep);
85
457
    break;
86
7.51k
  }
87
7.51k
}
void invoke_outer<unsigned long>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
6.17k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
6.17k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
6.17k
  if (size <= fixed_size + 1) return;
30
31
6.16k
  const Rep rep = assign_from_buf<Rep>(data);
32
6.16k
  data += fixed_size;
33
6.16k
  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.16k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
6.16k
  switch (period) {
41
433
  case 1:
42
433
    invoke_inner<std::atto>(format_str, rep);
43
433
    break;
44
408
  case 2:
45
408
    invoke_inner<std::femto>(format_str, rep);
46
408
    break;
47
418
  case 3:
48
418
    invoke_inner<std::pico>(format_str, rep);
49
418
    break;
50
387
  case 4:
51
387
    invoke_inner<std::nano>(format_str, rep);
52
387
    break;
53
414
  case 5:
54
414
    invoke_inner<std::micro>(format_str, rep);
55
414
    break;
56
404
  case 6:
57
404
    invoke_inner<std::milli>(format_str, rep);
58
404
    break;
59
389
  case 7:
60
389
    invoke_inner<std::centi>(format_str, rep);
61
389
    break;
62
379
  case 8:
63
379
    invoke_inner<std::deci>(format_str, rep);
64
379
    break;
65
429
  case 9:
66
429
    invoke_inner<std::deca>(format_str, rep);
67
429
    break;
68
450
  case 10:
69
450
    invoke_inner<std::kilo>(format_str, rep);
70
450
    break;
71
406
  case 11:
72
406
    invoke_inner<std::mega>(format_str, rep);
73
406
    break;
74
386
  case 12:
75
386
    invoke_inner<std::giga>(format_str, rep);
76
386
    break;
77
422
  case 13:
78
422
    invoke_inner<std::tera>(format_str, rep);
79
422
    break;
80
409
  case 14:
81
409
    invoke_inner<std::peta>(format_str, rep);
82
409
    break;
83
427
  case 15:
84
427
    invoke_inner<std::exa>(format_str, rep);
85
427
    break;
86
6.16k
  }
87
6.16k
}
void invoke_outer<float>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
8.25k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
8.25k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
8.25k
  if (size <= fixed_size + 1) return;
30
31
8.24k
  const Rep rep = assign_from_buf<Rep>(data);
32
8.24k
  data += fixed_size;
33
8.24k
  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
8.24k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
8.24k
  switch (period) {
41
596
  case 1:
42
596
    invoke_inner<std::atto>(format_str, rep);
43
596
    break;
44
558
  case 2:
45
558
    invoke_inner<std::femto>(format_str, rep);
46
558
    break;
47
559
  case 3:
48
559
    invoke_inner<std::pico>(format_str, rep);
49
559
    break;
50
548
  case 4:
51
548
    invoke_inner<std::nano>(format_str, rep);
52
548
    break;
53
552
  case 5:
54
552
    invoke_inner<std::micro>(format_str, rep);
55
552
    break;
56
528
  case 6:
57
528
    invoke_inner<std::milli>(format_str, rep);
58
528
    break;
59
524
  case 7:
60
524
    invoke_inner<std::centi>(format_str, rep);
61
524
    break;
62
534
  case 8:
63
534
    invoke_inner<std::deci>(format_str, rep);
64
534
    break;
65
537
  case 9:
66
537
    invoke_inner<std::deca>(format_str, rep);
67
537
    break;
68
555
  case 10:
69
555
    invoke_inner<std::kilo>(format_str, rep);
70
555
    break;
71
569
  case 11:
72
569
    invoke_inner<std::mega>(format_str, rep);
73
569
    break;
74
556
  case 12:
75
556
    invoke_inner<std::giga>(format_str, rep);
76
556
    break;
77
546
  case 13:
78
546
    invoke_inner<std::tera>(format_str, rep);
79
546
    break;
80
536
  case 14:
81
536
    invoke_inner<std::peta>(format_str, rep);
82
536
    break;
83
544
  case 15:
84
544
    invoke_inner<std::exa>(format_str, rep);
85
544
    break;
86
8.24k
  }
87
8.24k
}
void invoke_outer<double>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
8.58k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
8.58k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
8.58k
  if (size <= fixed_size + 1) return;
30
31
8.58k
  const Rep rep = assign_from_buf<Rep>(data);
32
8.58k
  data += fixed_size;
33
8.58k
  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
8.58k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
8.58k
  switch (period) {
41
588
  case 1:
42
588
    invoke_inner<std::atto>(format_str, rep);
43
588
    break;
44
585
  case 2:
45
585
    invoke_inner<std::femto>(format_str, rep);
46
585
    break;
47
560
  case 3:
48
560
    invoke_inner<std::pico>(format_str, rep);
49
560
    break;
50
568
  case 4:
51
568
    invoke_inner<std::nano>(format_str, rep);
52
568
    break;
53
573
  case 5:
54
573
    invoke_inner<std::micro>(format_str, rep);
55
573
    break;
56
627
  case 6:
57
627
    invoke_inner<std::milli>(format_str, rep);
58
627
    break;
59
589
  case 7:
60
589
    invoke_inner<std::centi>(format_str, rep);
61
589
    break;
62
567
  case 8:
63
567
    invoke_inner<std::deci>(format_str, rep);
64
567
    break;
65
559
  case 9:
66
559
    invoke_inner<std::deca>(format_str, rep);
67
559
    break;
68
580
  case 10:
69
580
    invoke_inner<std::kilo>(format_str, rep);
70
580
    break;
71
569
  case 11:
72
569
    invoke_inner<std::mega>(format_str, rep);
73
569
    break;
74
566
  case 12:
75
566
    invoke_inner<std::giga>(format_str, rep);
76
566
    break;
77
541
  case 13:
78
541
    invoke_inner<std::tera>(format_str, rep);
79
541
    break;
80
546
  case 14:
81
546
    invoke_inner<std::peta>(format_str, rep);
82
546
    break;
83
561
  case 15:
84
561
    invoke_inner<std::exa>(format_str, rep);
85
561
    break;
86
8.58k
  }
87
8.58k
}
void invoke_outer<long double>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
8.41k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
8.41k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
8.41k
  if (size <= fixed_size + 1) return;
30
31
8.40k
  const Rep rep = assign_from_buf<Rep>(data);
32
8.40k
  data += fixed_size;
33
8.40k
  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
8.40k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
8.40k
  switch (period) {
41
559
  case 1:
42
559
    invoke_inner<std::atto>(format_str, rep);
43
559
    break;
44
541
  case 2:
45
541
    invoke_inner<std::femto>(format_str, rep);
46
541
    break;
47
553
  case 3:
48
553
    invoke_inner<std::pico>(format_str, rep);
49
553
    break;
50
541
  case 4:
51
541
    invoke_inner<std::nano>(format_str, rep);
52
541
    break;
53
554
  case 5:
54
554
    invoke_inner<std::micro>(format_str, rep);
55
554
    break;
56
587
  case 6:
57
587
    invoke_inner<std::milli>(format_str, rep);
58
587
    break;
59
586
  case 7:
60
586
    invoke_inner<std::centi>(format_str, rep);
61
586
    break;
62
543
  case 8:
63
543
    invoke_inner<std::deci>(format_str, rep);
64
543
    break;
65
563
  case 9:
66
563
    invoke_inner<std::deca>(format_str, rep);
67
563
    break;
68
550
  case 10:
69
550
    invoke_inner<std::kilo>(format_str, rep);
70
550
    break;
71
553
  case 11:
72
553
    invoke_inner<std::mega>(format_str, rep);
73
553
    break;
74
559
  case 12:
75
559
    invoke_inner<std::giga>(format_str, rep);
76
559
    break;
77
609
  case 13:
78
609
    invoke_inner<std::tera>(format_str, rep);
79
609
    break;
80
561
  case 14:
81
561
    invoke_inner<std::peta>(format_str, rep);
82
561
    break;
83
546
  case 15:
84
546
    invoke_inner<std::exa>(format_str, rep);
85
546
    break;
86
8.40k
  }
87
8.40k
}
88
89
76.1k
extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
90
76.1k
  if (size <= 4) return 0;
91
92
76.1k
  const auto representation = data[0];
93
76.1k
  const auto period = data[1];
94
76.1k
  data += 2;
95
76.1k
  size -= 2;
96
97
76.1k
  switch (representation) {
98
5.14k
  case 1:
99
5.14k
    invoke_outer<char>(data, size, period);
100
5.14k
    break;
101
5.26k
  case 2:
102
5.26k
    invoke_outer<signed char>(data, size, period);
103
5.26k
    break;
104
5.06k
  case 3:
105
5.06k
    invoke_outer<unsigned char>(data, size, period);
106
5.06k
    break;
107
5.48k
  case 4:
108
5.48k
    invoke_outer<short>(data, size, period);
109
5.48k
    break;
110
5.00k
  case 5:
111
5.00k
    invoke_outer<unsigned short>(data, size, period);
112
5.00k
    break;
113
5.94k
  case 6:
114
5.94k
    invoke_outer<int>(data, size, period);
115
5.94k
    break;
116
5.26k
  case 7:
117
5.26k
    invoke_outer<unsigned int>(data, size, period);
118
5.26k
    break;
119
7.52k
  case 8:
120
7.52k
    invoke_outer<long>(data, size, period);
121
7.52k
    break;
122
6.17k
  case 9:
123
6.17k
    invoke_outer<unsigned long>(data, size, period);
124
6.17k
    break;
125
8.25k
  case 10:
126
8.25k
    invoke_outer<float>(data, size, period);
127
8.25k
    break;
128
8.58k
  case 11:
129
8.58k
    invoke_outer<double>(data, size, period);
130
8.58k
    break;
131
8.41k
  case 12:
132
8.41k
    invoke_outer<long double>(data, size, period);
133
8.41k
    break;
134
76.1k
  }
135
76.1k
  return 0;
136
76.1k
}