Coverage Report

Created: 2025-11-18 06:38

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
50.6k
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
50.6k
  auto value = std::chrono::duration<Rep, Period>(rep);
13
50.6k
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
50.6k
    auto buf = fmt::memory_buffer();
18
50.6k
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
50.6k
#endif
20
50.6k
  } catch (std::exception&) {
21
46.1k
  }
22
50.6k
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
231
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
231
  auto value = std::chrono::duration<Rep, Period>(rep);
13
231
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
231
    auto buf = fmt::memory_buffer();
18
231
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
231
#endif
20
231
  } catch (std::exception&) {
21
208
  }
22
231
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
223
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
223
  auto value = std::chrono::duration<Rep, Period>(rep);
13
223
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
223
    auto buf = fmt::memory_buffer();
18
223
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
223
#endif
20
223
  } catch (std::exception&) {
21
204
  }
22
223
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
212
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
212
  auto value = std::chrono::duration<Rep, Period>(rep);
13
212
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
212
    auto buf = fmt::memory_buffer();
18
212
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
212
#endif
20
212
  } catch (std::exception&) {
21
192
  }
22
212
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
216
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
216
  auto value = std::chrono::duration<Rep, Period>(rep);
13
216
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
216
    auto buf = fmt::memory_buffer();
18
216
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
216
#endif
20
216
  } catch (std::exception&) {
21
189
  }
22
216
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
235
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
235
  auto value = std::chrono::duration<Rep, Period>(rep);
13
235
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
235
    auto buf = fmt::memory_buffer();
18
235
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
235
#endif
20
235
  } catch (std::exception&) {
21
206
  }
22
235
}
void invoke_inner<std::__1::ratio<1l, 1000l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
213
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
213
  auto value = std::chrono::duration<Rep, Period>(rep);
13
213
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
213
    auto buf = fmt::memory_buffer();
18
213
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
213
#endif
20
213
  } catch (std::exception&) {
21
192
  }
22
213
}
void invoke_inner<std::__1::ratio<1l, 100l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
231
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
231
  auto value = std::chrono::duration<Rep, Period>(rep);
13
231
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
231
    auto buf = fmt::memory_buffer();
18
231
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
231
#endif
20
231
  } catch (std::exception&) {
21
205
  }
22
231
}
void invoke_inner<std::__1::ratio<1l, 10l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
221
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
221
  auto value = std::chrono::duration<Rep, Period>(rep);
13
221
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
221
    auto buf = fmt::memory_buffer();
18
221
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
221
#endif
20
221
  } catch (std::exception&) {
21
199
  }
22
221
}
void invoke_inner<std::__1::ratio<10l, 1l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
251
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
251
  auto value = std::chrono::duration<Rep, Period>(rep);
13
251
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
251
    auto buf = fmt::memory_buffer();
18
251
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
251
#endif
20
251
  } catch (std::exception&) {
21
231
  }
22
251
}
void invoke_inner<std::__1::ratio<1000l, 1l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
259
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
259
  auto value = std::chrono::duration<Rep, Period>(rep);
13
259
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
259
    auto buf = fmt::memory_buffer();
18
259
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
259
#endif
20
259
  } catch (std::exception&) {
21
242
  }
22
259
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
267
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
267
  auto value = std::chrono::duration<Rep, Period>(rep);
13
267
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
267
    auto buf = fmt::memory_buffer();
18
267
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
267
#endif
20
267
  } catch (std::exception&) {
21
246
  }
22
267
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
278
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
278
  auto value = std::chrono::duration<Rep, Period>(rep);
13
278
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
278
    auto buf = fmt::memory_buffer();
18
278
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
278
#endif
20
278
  } catch (std::exception&) {
21
258
  }
22
278
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
223
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
223
  auto value = std::chrono::duration<Rep, Period>(rep);
13
223
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
223
    auto buf = fmt::memory_buffer();
18
223
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
223
#endif
20
223
  } catch (std::exception&) {
21
204
  }
22
223
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
214
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
214
  auto value = std::chrono::duration<Rep, Period>(rep);
13
214
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
214
    auto buf = fmt::memory_buffer();
18
214
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
214
#endif
20
214
  } catch (std::exception&) {
21
191
  }
22
214
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
208
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
208
  auto value = std::chrono::duration<Rep, Period>(rep);
13
208
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
208
    auto buf = fmt::memory_buffer();
18
208
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
208
#endif
20
208
  } catch (std::exception&) {
21
194
  }
22
208
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
236
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
236
  auto value = std::chrono::duration<Rep, Period>(rep);
13
236
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
236
    auto buf = fmt::memory_buffer();
18
236
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
236
#endif
20
236
  } catch (std::exception&) {
21
228
  }
22
236
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
239
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
239
  auto value = std::chrono::duration<Rep, Period>(rep);
13
239
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
239
    auto buf = fmt::memory_buffer();
18
239
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
239
#endif
20
239
  } catch (std::exception&) {
21
230
  }
22
239
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
205
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
205
  auto value = std::chrono::duration<Rep, Period>(rep);
13
205
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
205
    auto buf = fmt::memory_buffer();
18
205
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
205
#endif
20
205
  } catch (std::exception&) {
21
187
  }
22
205
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
230
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
230
  auto value = std::chrono::duration<Rep, Period>(rep);
13
230
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
230
    auto buf = fmt::memory_buffer();
18
230
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
230
#endif
20
230
  } catch (std::exception&) {
21
219
  }
22
230
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
241
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
241
  auto value = std::chrono::duration<Rep, Period>(rep);
13
241
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
241
    auto buf = fmt::memory_buffer();
18
241
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
241
#endif
20
241
  } catch (std::exception&) {
21
219
  }
22
241
}
void invoke_inner<std::__1::ratio<1l, 1000l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
220
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
220
  auto value = std::chrono::duration<Rep, Period>(rep);
13
220
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
220
    auto buf = fmt::memory_buffer();
18
220
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
220
#endif
20
220
  } catch (std::exception&) {
21
194
  }
22
220
}
void invoke_inner<std::__1::ratio<1l, 100l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
224
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
224
  auto value = std::chrono::duration<Rep, Period>(rep);
13
224
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
224
    auto buf = fmt::memory_buffer();
18
224
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
224
#endif
20
224
  } catch (std::exception&) {
21
199
  }
22
224
}
void invoke_inner<std::__1::ratio<1l, 10l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
234
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
234
  auto value = std::chrono::duration<Rep, Period>(rep);
13
234
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
234
    auto buf = fmt::memory_buffer();
18
234
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
234
#endif
20
234
  } catch (std::exception&) {
21
211
  }
22
234
}
void invoke_inner<std::__1::ratio<10l, 1l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
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
261
  }
22
288
}
void invoke_inner<std::__1::ratio<1000l, 1l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
259
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
259
  auto value = std::chrono::duration<Rep, Period>(rep);
13
259
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
259
    auto buf = fmt::memory_buffer();
18
259
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
259
#endif
20
259
  } catch (std::exception&) {
21
236
  }
22
259
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
277
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
277
  auto value = std::chrono::duration<Rep, Period>(rep);
13
277
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
277
    auto buf = fmt::memory_buffer();
18
277
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
277
#endif
20
277
  } catch (std::exception&) {
21
256
  }
22
277
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
266
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
266
  auto value = std::chrono::duration<Rep, Period>(rep);
13
266
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
266
    auto buf = fmt::memory_buffer();
18
266
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
266
#endif
20
266
  } catch (std::exception&) {
21
247
  }
22
266
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
221
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
221
  auto value = std::chrono::duration<Rep, Period>(rep);
13
221
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
221
    auto buf = fmt::memory_buffer();
18
221
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
221
#endif
20
221
  } catch (std::exception&) {
21
196
  }
22
221
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
217
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
217
  auto value = std::chrono::duration<Rep, Period>(rep);
13
217
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
217
    auto buf = fmt::memory_buffer();
18
217
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
217
#endif
20
217
  } catch (std::exception&) {
21
200
  }
22
217
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
218
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
218
  auto value = std::chrono::duration<Rep, Period>(rep);
13
218
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
218
    auto buf = fmt::memory_buffer();
18
218
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
218
#endif
20
218
  } catch (std::exception&) {
21
195
  }
22
218
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
210
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
210
  auto value = std::chrono::duration<Rep, Period>(rep);
13
210
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
210
    auto buf = fmt::memory_buffer();
18
210
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
210
#endif
20
210
  } catch (std::exception&) {
21
190
  }
22
210
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
207
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
207
  auto value = std::chrono::duration<Rep, Period>(rep);
13
207
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
207
    auto buf = fmt::memory_buffer();
18
207
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
207
#endif
20
207
  } catch (std::exception&) {
21
188
  }
22
207
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
213
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
213
  auto value = std::chrono::duration<Rep, Period>(rep);
13
213
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
213
    auto buf = fmt::memory_buffer();
18
213
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
213
#endif
20
213
  } catch (std::exception&) {
21
192
  }
22
213
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
208
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
208
  auto value = std::chrono::duration<Rep, Period>(rep);
13
208
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
208
    auto buf = fmt::memory_buffer();
18
208
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
208
#endif
20
208
  } catch (std::exception&) {
21
184
  }
22
208
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
216
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
216
  auto value = std::chrono::duration<Rep, Period>(rep);
13
216
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
216
    auto buf = fmt::memory_buffer();
18
216
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
216
#endif
20
216
  } catch (std::exception&) {
21
192
  }
22
216
}
void invoke_inner<std::__1::ratio<1l, 1000l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
210
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
210
  auto value = std::chrono::duration<Rep, Period>(rep);
13
210
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
210
    auto buf = fmt::memory_buffer();
18
210
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
210
#endif
20
210
  } catch (std::exception&) {
21
191
  }
22
210
}
void invoke_inner<std::__1::ratio<1l, 100l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
189
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
189
  auto value = std::chrono::duration<Rep, Period>(rep);
13
189
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
189
    auto buf = fmt::memory_buffer();
18
189
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
189
#endif
20
189
  } catch (std::exception&) {
21
175
  }
22
189
}
void invoke_inner<std::__1::ratio<1l, 10l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
207
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
207
  auto value = std::chrono::duration<Rep, Period>(rep);
13
207
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
207
    auto buf = fmt::memory_buffer();
18
207
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
207
#endif
20
207
  } catch (std::exception&) {
21
191
  }
22
207
}
void invoke_inner<std::__1::ratio<10l, 1l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
244
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
244
  auto value = std::chrono::duration<Rep, Period>(rep);
13
244
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
244
    auto buf = fmt::memory_buffer();
18
244
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
244
#endif
20
244
  } catch (std::exception&) {
21
224
  }
22
244
}
void invoke_inner<std::__1::ratio<1000l, 1l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
263
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
263
  auto value = std::chrono::duration<Rep, Period>(rep);
13
263
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
263
    auto buf = fmt::memory_buffer();
18
263
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
263
#endif
20
263
  } catch (std::exception&) {
21
234
  }
22
263
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
246
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
246
  auto value = std::chrono::duration<Rep, Period>(rep);
13
246
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
246
    auto buf = fmt::memory_buffer();
18
246
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
246
#endif
20
246
  } catch (std::exception&) {
21
223
  }
22
246
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
237
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
237
  auto value = std::chrono::duration<Rep, Period>(rep);
13
237
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
237
    auto buf = fmt::memory_buffer();
18
237
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
237
#endif
20
237
  } catch (std::exception&) {
21
215
  }
22
237
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
218
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
218
  auto value = std::chrono::duration<Rep, Period>(rep);
13
218
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
218
    auto buf = fmt::memory_buffer();
18
218
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
218
#endif
20
218
  } catch (std::exception&) {
21
197
  }
22
218
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
207
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
207
  auto value = std::chrono::duration<Rep, Period>(rep);
13
207
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
207
    auto buf = fmt::memory_buffer();
18
207
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
207
#endif
20
207
  } catch (std::exception&) {
21
185
  }
22
207
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
211
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
211
  auto value = std::chrono::duration<Rep, Period>(rep);
13
211
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
211
    auto buf = fmt::memory_buffer();
18
211
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
211
#endif
20
211
  } catch (std::exception&) {
21
191
  }
22
211
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
250
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
250
  auto value = std::chrono::duration<Rep, Period>(rep);
13
250
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
250
    auto buf = fmt::memory_buffer();
18
250
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
250
#endif
20
250
  } catch (std::exception&) {
21
231
  }
22
250
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
229
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
229
  auto value = std::chrono::duration<Rep, Period>(rep);
13
229
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
229
    auto buf = fmt::memory_buffer();
18
229
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
229
#endif
20
229
  } catch (std::exception&) {
21
210
  }
22
229
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
222
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
222
  auto value = std::chrono::duration<Rep, Period>(rep);
13
222
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
222
    auto buf = fmt::memory_buffer();
18
222
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
222
#endif
20
222
  } catch (std::exception&) {
21
203
  }
22
222
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
241
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
241
  auto value = std::chrono::duration<Rep, Period>(rep);
13
241
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
241
    auto buf = fmt::memory_buffer();
18
241
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
241
#endif
20
241
  } catch (std::exception&) {
21
223
  }
22
241
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
229
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
229
  auto value = std::chrono::duration<Rep, Period>(rep);
13
229
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
229
    auto buf = fmt::memory_buffer();
18
229
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
229
#endif
20
229
  } catch (std::exception&) {
21
208
  }
22
229
}
void invoke_inner<std::__1::ratio<1l, 1000l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
234
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
234
  auto value = std::chrono::duration<Rep, Period>(rep);
13
234
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
234
    auto buf = fmt::memory_buffer();
18
234
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
234
#endif
20
234
  } catch (std::exception&) {
21
213
  }
22
234
}
void invoke_inner<std::__1::ratio<1l, 100l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
228
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
228
  auto value = std::chrono::duration<Rep, Period>(rep);
13
228
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
228
    auto buf = fmt::memory_buffer();
18
228
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
228
#endif
20
228
  } catch (std::exception&) {
21
199
  }
22
228
}
void invoke_inner<std::__1::ratio<1l, 10l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
225
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
225
  auto value = std::chrono::duration<Rep, Period>(rep);
13
225
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
225
    auto buf = fmt::memory_buffer();
18
225
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
225
#endif
20
225
  } catch (std::exception&) {
21
217
  }
22
225
}
void invoke_inner<std::__1::ratio<10l, 1l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
282
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
282
  auto value = std::chrono::duration<Rep, Period>(rep);
13
282
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
282
    auto buf = fmt::memory_buffer();
18
282
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
282
#endif
20
282
  } catch (std::exception&) {
21
252
  }
22
282
}
void invoke_inner<std::__1::ratio<1000l, 1l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
275
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
275
  auto value = std::chrono::duration<Rep, Period>(rep);
13
275
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
275
    auto buf = fmt::memory_buffer();
18
275
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
275
#endif
20
275
  } catch (std::exception&) {
21
246
  }
22
275
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
280
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
280
  auto value = std::chrono::duration<Rep, Period>(rep);
13
280
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
280
    auto buf = fmt::memory_buffer();
18
280
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
280
#endif
20
280
  } catch (std::exception&) {
21
258
  }
22
280
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
289
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
289
  auto value = std::chrono::duration<Rep, Period>(rep);
13
289
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
289
    auto buf = fmt::memory_buffer();
18
289
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
289
#endif
20
289
  } catch (std::exception&) {
21
263
  }
22
289
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
239
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
239
  auto value = std::chrono::duration<Rep, Period>(rep);
13
239
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
239
    auto buf = fmt::memory_buffer();
18
239
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
239
#endif
20
239
  } catch (std::exception&) {
21
220
  }
22
239
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
241
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
241
  auto value = std::chrono::duration<Rep, Period>(rep);
13
241
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
241
    auto buf = fmt::memory_buffer();
18
241
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
241
#endif
20
241
  } catch (std::exception&) {
21
218
  }
22
241
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
213
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
213
  auto value = std::chrono::duration<Rep, Period>(rep);
13
213
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
213
    auto buf = fmt::memory_buffer();
18
213
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
213
#endif
20
213
  } catch (std::exception&) {
21
200
  }
22
213
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
208
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
208
  auto value = std::chrono::duration<Rep, Period>(rep);
13
208
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
208
    auto buf = fmt::memory_buffer();
18
208
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
208
#endif
20
208
  } catch (std::exception&) {
21
195
  }
22
208
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
205
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
205
  auto value = std::chrono::duration<Rep, Period>(rep);
13
205
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
205
    auto buf = fmt::memory_buffer();
18
205
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
205
#endif
20
205
  } catch (std::exception&) {
21
186
  }
22
205
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
208
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
208
  auto value = std::chrono::duration<Rep, Period>(rep);
13
208
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
208
    auto buf = fmt::memory_buffer();
18
208
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
208
#endif
20
208
  } catch (std::exception&) {
21
189
  }
22
208
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
201
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
201
  auto value = std::chrono::duration<Rep, Period>(rep);
13
201
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
201
    auto buf = fmt::memory_buffer();
18
201
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
201
#endif
20
201
  } catch (std::exception&) {
21
179
  }
22
201
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
216
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
216
  auto value = std::chrono::duration<Rep, Period>(rep);
13
216
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
216
    auto buf = fmt::memory_buffer();
18
216
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
216
#endif
20
216
  } catch (std::exception&) {
21
200
  }
22
216
}
void invoke_inner<std::__1::ratio<1l, 1000l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
212
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
212
  auto value = std::chrono::duration<Rep, Period>(rep);
13
212
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
212
    auto buf = fmt::memory_buffer();
18
212
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
212
#endif
20
212
  } catch (std::exception&) {
21
180
  }
22
212
}
void invoke_inner<std::__1::ratio<1l, 100l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
202
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
202
  auto value = std::chrono::duration<Rep, Period>(rep);
13
202
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
202
    auto buf = fmt::memory_buffer();
18
202
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
202
#endif
20
202
  } catch (std::exception&) {
21
186
  }
22
202
}
void invoke_inner<std::__1::ratio<1l, 10l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
208
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
208
  auto value = std::chrono::duration<Rep, Period>(rep);
13
208
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
208
    auto buf = fmt::memory_buffer();
18
208
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
208
#endif
20
208
  } catch (std::exception&) {
21
187
  }
22
208
}
void invoke_inner<std::__1::ratio<10l, 1l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
257
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
257
  auto value = std::chrono::duration<Rep, Period>(rep);
13
257
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
257
    auto buf = fmt::memory_buffer();
18
257
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
257
#endif
20
257
  } catch (std::exception&) {
21
231
  }
22
257
}
void invoke_inner<std::__1::ratio<1000l, 1l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
273
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
273
  auto value = std::chrono::duration<Rep, Period>(rep);
13
273
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
273
    auto buf = fmt::memory_buffer();
18
273
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
273
#endif
20
273
  } catch (std::exception&) {
21
251
  }
22
273
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
264
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
264
  auto value = std::chrono::duration<Rep, Period>(rep);
13
264
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
264
    auto buf = fmt::memory_buffer();
18
264
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
264
#endif
20
264
  } catch (std::exception&) {
21
240
  }
22
264
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
237
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
237
  auto value = std::chrono::duration<Rep, Period>(rep);
13
237
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
237
    auto buf = fmt::memory_buffer();
18
237
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
237
#endif
20
237
  } catch (std::exception&) {
21
225
  }
22
237
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
225
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
225
  auto value = std::chrono::duration<Rep, Period>(rep);
13
225
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
225
    auto buf = fmt::memory_buffer();
18
225
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
225
#endif
20
225
  } catch (std::exception&) {
21
201
  }
22
225
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
217
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
217
  auto value = std::chrono::duration<Rep, Period>(rep);
13
217
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
217
    auto buf = fmt::memory_buffer();
18
217
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
217
#endif
20
217
  } catch (std::exception&) {
21
192
  }
22
217
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
216
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
216
  auto value = std::chrono::duration<Rep, Period>(rep);
13
216
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
216
    auto buf = fmt::memory_buffer();
18
216
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
216
#endif
20
216
  } catch (std::exception&) {
21
198
  }
22
216
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
250
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
250
  auto value = std::chrono::duration<Rep, Period>(rep);
13
250
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
250
    auto buf = fmt::memory_buffer();
18
250
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
250
#endif
20
250
  } catch (std::exception&) {
21
223
  }
22
250
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
245
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
245
  auto value = std::chrono::duration<Rep, Period>(rep);
13
245
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
245
    auto buf = fmt::memory_buffer();
18
245
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
245
#endif
20
245
  } catch (std::exception&) {
21
221
  }
22
245
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
257
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
257
  auto value = std::chrono::duration<Rep, Period>(rep);
13
257
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
257
    auto buf = fmt::memory_buffer();
18
257
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
257
#endif
20
257
  } catch (std::exception&) {
21
238
  }
22
257
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
244
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
244
  auto value = std::chrono::duration<Rep, Period>(rep);
13
244
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
244
    auto buf = fmt::memory_buffer();
18
244
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
244
#endif
20
244
  } catch (std::exception&) {
21
219
  }
22
244
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
247
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
247
  auto value = std::chrono::duration<Rep, Period>(rep);
13
247
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
247
    auto buf = fmt::memory_buffer();
18
247
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
247
#endif
20
247
  } catch (std::exception&) {
21
231
  }
22
247
}
void invoke_inner<std::__1::ratio<1l, 1000l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
242
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
242
  auto value = std::chrono::duration<Rep, Period>(rep);
13
242
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
242
    auto buf = fmt::memory_buffer();
18
242
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
242
#endif
20
242
  } catch (std::exception&) {
21
220
  }
22
242
}
void invoke_inner<std::__1::ratio<1l, 100l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
257
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
257
  auto value = std::chrono::duration<Rep, Period>(rep);
13
257
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
257
    auto buf = fmt::memory_buffer();
18
257
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
257
#endif
20
257
  } catch (std::exception&) {
21
248
  }
22
257
}
void invoke_inner<std::__1::ratio<1l, 10l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
258
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
258
  auto value = std::chrono::duration<Rep, Period>(rep);
13
258
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
258
    auto buf = fmt::memory_buffer();
18
258
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
258
#endif
20
258
  } catch (std::exception&) {
21
234
  }
22
258
}
void invoke_inner<std::__1::ratio<10l, 1l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
283
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
283
  auto value = std::chrono::duration<Rep, Period>(rep);
13
283
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
283
    auto buf = fmt::memory_buffer();
18
283
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
283
#endif
20
283
  } catch (std::exception&) {
21
254
  }
22
283
}
void invoke_inner<std::__1::ratio<1000l, 1l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
289
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
289
  auto value = std::chrono::duration<Rep, Period>(rep);
13
289
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
289
    auto buf = fmt::memory_buffer();
18
289
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
289
#endif
20
289
  } catch (std::exception&) {
21
275
  }
22
289
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
299
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
299
  auto value = std::chrono::duration<Rep, Period>(rep);
13
299
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
299
    auto buf = fmt::memory_buffer();
18
299
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
299
#endif
20
299
  } catch (std::exception&) {
21
278
  }
22
299
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
286
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
286
  auto value = std::chrono::duration<Rep, Period>(rep);
13
286
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
286
    auto buf = fmt::memory_buffer();
18
286
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
286
#endif
20
286
  } catch (std::exception&) {
21
252
  }
22
286
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
238
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
238
  auto value = std::chrono::duration<Rep, Period>(rep);
13
238
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
238
    auto buf = fmt::memory_buffer();
18
238
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
238
#endif
20
238
  } catch (std::exception&) {
21
215
  }
22
238
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
234
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
234
  auto value = std::chrono::duration<Rep, Period>(rep);
13
234
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
234
    auto buf = fmt::memory_buffer();
18
234
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
234
#endif
20
234
  } catch (std::exception&) {
21
216
  }
22
234
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
240
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
240
  auto value = std::chrono::duration<Rep, Period>(rep);
13
240
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
240
    auto buf = fmt::memory_buffer();
18
240
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
240
#endif
20
240
  } catch (std::exception&) {
21
225
  }
22
240
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
247
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
247
  auto value = std::chrono::duration<Rep, Period>(rep);
13
247
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
247
    auto buf = fmt::memory_buffer();
18
247
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
247
#endif
20
247
  } catch (std::exception&) {
21
217
  }
22
247
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
219
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
219
  auto value = std::chrono::duration<Rep, Period>(rep);
13
219
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
219
    auto buf = fmt::memory_buffer();
18
219
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
219
#endif
20
219
  } catch (std::exception&) {
21
202
  }
22
219
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
225
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
225
  auto value = std::chrono::duration<Rep, Period>(rep);
13
225
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
225
    auto buf = fmt::memory_buffer();
18
225
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
225
#endif
20
225
  } catch (std::exception&) {
21
199
  }
22
225
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
227
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
227
  auto value = std::chrono::duration<Rep, Period>(rep);
13
227
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
227
    auto buf = fmt::memory_buffer();
18
227
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
227
#endif
20
227
  } catch (std::exception&) {
21
202
  }
22
227
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
213
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
213
  auto value = std::chrono::duration<Rep, Period>(rep);
13
213
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
213
    auto buf = fmt::memory_buffer();
18
213
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
213
#endif
20
213
  } catch (std::exception&) {
21
191
  }
22
213
}
void invoke_inner<std::__1::ratio<1l, 1000l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
219
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
219
  auto value = std::chrono::duration<Rep, Period>(rep);
13
219
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
219
    auto buf = fmt::memory_buffer();
18
219
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
219
#endif
20
219
  } catch (std::exception&) {
21
210
  }
22
219
}
void invoke_inner<std::__1::ratio<1l, 100l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
199
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
199
  auto value = std::chrono::duration<Rep, Period>(rep);
13
199
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
199
    auto buf = fmt::memory_buffer();
18
199
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
199
#endif
20
199
  } catch (std::exception&) {
21
181
  }
22
199
}
void invoke_inner<std::__1::ratio<1l, 10l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
209
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
209
  auto value = std::chrono::duration<Rep, Period>(rep);
13
209
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
209
    auto buf = fmt::memory_buffer();
18
209
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
209
#endif
20
209
  } catch (std::exception&) {
21
185
  }
22
209
}
void invoke_inner<std::__1::ratio<10l, 1l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
254
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
254
  auto value = std::chrono::duration<Rep, Period>(rep);
13
254
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
254
    auto buf = fmt::memory_buffer();
18
254
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
254
#endif
20
254
  } catch (std::exception&) {
21
234
  }
22
254
}
void invoke_inner<std::__1::ratio<1000l, 1l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
245
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
245
  auto value = std::chrono::duration<Rep, Period>(rep);
13
245
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
245
    auto buf = fmt::memory_buffer();
18
245
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
245
#endif
20
245
  } catch (std::exception&) {
21
223
  }
22
245
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
240
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
240
  auto value = std::chrono::duration<Rep, Period>(rep);
13
240
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
240
    auto buf = fmt::memory_buffer();
18
240
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
240
#endif
20
240
  } catch (std::exception&) {
21
222
  }
22
240
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
255
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
255
  auto value = std::chrono::duration<Rep, Period>(rep);
13
255
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
255
    auto buf = fmt::memory_buffer();
18
255
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
255
#endif
20
255
  } catch (std::exception&) {
21
236
  }
22
255
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
212
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
212
  auto value = std::chrono::duration<Rep, Period>(rep);
13
212
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
212
    auto buf = fmt::memory_buffer();
18
212
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
212
#endif
20
212
  } catch (std::exception&) {
21
199
  }
22
212
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
226
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
226
  auto value = std::chrono::duration<Rep, Period>(rep);
13
226
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
226
    auto buf = fmt::memory_buffer();
18
226
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
226
#endif
20
226
  } catch (std::exception&) {
21
207
  }
22
226
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
226
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
226
  auto value = std::chrono::duration<Rep, Period>(rep);
13
226
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
226
    auto buf = fmt::memory_buffer();
18
226
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
226
#endif
20
226
  } catch (std::exception&) {
21
199
  }
22
226
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
374
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
374
  auto value = std::chrono::duration<Rep, Period>(rep);
13
374
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
374
    auto buf = fmt::memory_buffer();
18
374
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
374
#endif
20
374
  } catch (std::exception&) {
21
347
  }
22
374
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, long>(fmt::v12::basic_string_view<char>, long)
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
338
  }
22
372
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
337
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
337
  auto value = std::chrono::duration<Rep, Period>(rep);
13
337
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
337
    auto buf = fmt::memory_buffer();
18
337
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
337
#endif
20
337
  } catch (std::exception&) {
21
309
  }
22
337
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
342
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
342
  auto value = std::chrono::duration<Rep, Period>(rep);
13
342
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
342
    auto buf = fmt::memory_buffer();
18
342
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
342
#endif
20
342
  } catch (std::exception&) {
21
321
  }
22
342
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
313
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
313
  auto value = std::chrono::duration<Rep, Period>(rep);
13
313
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
313
    auto buf = fmt::memory_buffer();
18
313
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
313
#endif
20
313
  } catch (std::exception&) {
21
295
  }
22
313
}
void invoke_inner<std::__1::ratio<1l, 1000l>, long>(fmt::v12::basic_string_view<char>, long)
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
325
  }
22
348
}
void invoke_inner<std::__1::ratio<1l, 100l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
321
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
321
  auto value = std::chrono::duration<Rep, Period>(rep);
13
321
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
321
    auto buf = fmt::memory_buffer();
18
321
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
321
#endif
20
321
  } catch (std::exception&) {
21
293
  }
22
321
}
void invoke_inner<std::__1::ratio<1l, 10l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
297
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
297
  auto value = std::chrono::duration<Rep, Period>(rep);
13
297
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
297
    auto buf = fmt::memory_buffer();
18
297
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
297
#endif
20
297
  } catch (std::exception&) {
21
274
  }
22
297
}
void invoke_inner<std::__1::ratio<10l, 1l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
322
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
322
  auto value = std::chrono::duration<Rep, Period>(rep);
13
322
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
322
    auto buf = fmt::memory_buffer();
18
322
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
322
#endif
20
322
  } catch (std::exception&) {
21
300
  }
22
322
}
void invoke_inner<std::__1::ratio<1000l, 1l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
337
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
337
  auto value = std::chrono::duration<Rep, Period>(rep);
13
337
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
337
    auto buf = fmt::memory_buffer();
18
337
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
337
#endif
20
337
  } catch (std::exception&) {
21
305
  }
22
337
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, long>(fmt::v12::basic_string_view<char>, long)
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
290
  }
22
310
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
334
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
334
  auto value = std::chrono::duration<Rep, Period>(rep);
13
334
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
334
    auto buf = fmt::memory_buffer();
18
334
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
334
#endif
20
334
  } catch (std::exception&) {
21
304
  }
22
334
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
332
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
332
  auto value = std::chrono::duration<Rep, Period>(rep);
13
332
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
332
    auto buf = fmt::memory_buffer();
18
332
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
332
#endif
20
332
  } catch (std::exception&) {
21
312
  }
22
332
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
276
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
276
  auto value = std::chrono::duration<Rep, Period>(rep);
13
276
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
276
    auto buf = fmt::memory_buffer();
18
276
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
276
#endif
20
276
  } catch (std::exception&) {
21
252
  }
22
276
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
294
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
294
  auto value = std::chrono::duration<Rep, Period>(rep);
13
294
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
294
    auto buf = fmt::memory_buffer();
18
294
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
294
#endif
20
294
  } catch (std::exception&) {
21
271
  }
22
294
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
Line
Count
Source
11
278
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
278
  auto value = std::chrono::duration<Rep, Period>(rep);
13
278
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
278
    auto buf = fmt::memory_buffer();
18
278
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
278
#endif
20
278
  } catch (std::exception&) {
21
251
  }
22
278
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
Line
Count
Source
11
265
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
265
  auto value = std::chrono::duration<Rep, Period>(rep);
13
265
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
265
    auto buf = fmt::memory_buffer();
18
265
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
265
#endif
20
265
  } catch (std::exception&) {
21
236
  }
22
265
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
Line
Count
Source
11
284
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
284
  auto value = std::chrono::duration<Rep, Period>(rep);
13
284
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
284
    auto buf = fmt::memory_buffer();
18
284
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
284
#endif
20
284
  } catch (std::exception&) {
21
267
  }
22
284
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
Line
Count
Source
11
272
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
272
  auto value = std::chrono::duration<Rep, Period>(rep);
13
272
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
272
    auto buf = fmt::memory_buffer();
18
272
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
272
#endif
20
272
  } catch (std::exception&) {
21
245
  }
22
272
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
Line
Count
Source
11
259
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
259
  auto value = std::chrono::duration<Rep, Period>(rep);
13
259
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
259
    auto buf = fmt::memory_buffer();
18
259
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
259
#endif
20
259
  } catch (std::exception&) {
21
229
  }
22
259
}
void invoke_inner<std::__1::ratio<1l, 1000l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
Line
Count
Source
11
260
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
260
  auto value = std::chrono::duration<Rep, Period>(rep);
13
260
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
260
    auto buf = fmt::memory_buffer();
18
260
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
260
#endif
20
260
  } catch (std::exception&) {
21
227
  }
22
260
}
void invoke_inner<std::__1::ratio<1l, 100l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
Line
Count
Source
11
272
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
272
  auto value = std::chrono::duration<Rep, Period>(rep);
13
272
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
272
    auto buf = fmt::memory_buffer();
18
272
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
272
#endif
20
272
  } catch (std::exception&) {
21
257
  }
22
272
}
void invoke_inner<std::__1::ratio<1l, 10l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
Line
Count
Source
11
251
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
251
  auto value = std::chrono::duration<Rep, Period>(rep);
13
251
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
251
    auto buf = fmt::memory_buffer();
18
251
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
251
#endif
20
251
  } catch (std::exception&) {
21
232
  }
22
251
}
void invoke_inner<std::__1::ratio<10l, 1l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
Line
Count
Source
11
278
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
278
  auto value = std::chrono::duration<Rep, Period>(rep);
13
278
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
278
    auto buf = fmt::memory_buffer();
18
278
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
278
#endif
20
278
  } catch (std::exception&) {
21
255
  }
22
278
}
void invoke_inner<std::__1::ratio<1000l, 1l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
Line
Count
Source
11
312
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
312
  auto value = std::chrono::duration<Rep, Period>(rep);
13
312
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
312
    auto buf = fmt::memory_buffer();
18
312
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
312
#endif
20
312
  } catch (std::exception&) {
21
281
  }
22
312
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
Line
Count
Source
11
280
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
280
  auto value = std::chrono::duration<Rep, Period>(rep);
13
280
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
280
    auto buf = fmt::memory_buffer();
18
280
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
280
#endif
20
280
  } catch (std::exception&) {
21
255
  }
22
280
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
Line
Count
Source
11
289
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
289
  auto value = std::chrono::duration<Rep, Period>(rep);
13
289
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
289
    auto buf = fmt::memory_buffer();
18
289
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
289
#endif
20
289
  } catch (std::exception&) {
21
259
  }
22
289
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
Line
Count
Source
11
274
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
274
  auto value = std::chrono::duration<Rep, Period>(rep);
13
274
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
274
    auto buf = fmt::memory_buffer();
18
274
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
274
#endif
20
274
  } catch (std::exception&) {
21
252
  }
22
274
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
Line
Count
Source
11
266
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
266
  auto value = std::chrono::duration<Rep, Period>(rep);
13
266
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
266
    auto buf = fmt::memory_buffer();
18
266
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
266
#endif
20
266
  } catch (std::exception&) {
21
236
  }
22
266
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
Line
Count
Source
11
265
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
265
  auto value = std::chrono::duration<Rep, Period>(rep);
13
265
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
265
    auto buf = fmt::memory_buffer();
18
265
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
265
#endif
20
265
  } catch (std::exception&) {
21
248
  }
22
265
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, float>(fmt::v12::basic_string_view<char>, float)
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
360
  }
22
386
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
358
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
358
  auto value = std::chrono::duration<Rep, Period>(rep);
13
358
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
358
    auto buf = fmt::memory_buffer();
18
358
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
358
#endif
20
358
  } catch (std::exception&) {
21
323
  }
22
358
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
382
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
382
  auto value = std::chrono::duration<Rep, Period>(rep);
13
382
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
382
    auto buf = fmt::memory_buffer();
18
382
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
382
#endif
20
382
  } catch (std::exception&) {
21
351
  }
22
382
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, float>(fmt::v12::basic_string_view<char>, float)
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
343
  }
22
375
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
369
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
369
  auto value = std::chrono::duration<Rep, Period>(rep);
13
369
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
369
    auto buf = fmt::memory_buffer();
18
369
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
369
#endif
20
369
  } catch (std::exception&) {
21
334
  }
22
369
}
void invoke_inner<std::__1::ratio<1l, 1000l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
382
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
382
  auto value = std::chrono::duration<Rep, Period>(rep);
13
382
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
382
    auto buf = fmt::memory_buffer();
18
382
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
382
#endif
20
382
  } catch (std::exception&) {
21
358
  }
22
382
}
void invoke_inner<std::__1::ratio<1l, 100l>, float>(fmt::v12::basic_string_view<char>, float)
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
327
  }
22
361
}
void invoke_inner<std::__1::ratio<1l, 10l>, float>(fmt::v12::basic_string_view<char>, float)
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
347
  }
22
371
}
void invoke_inner<std::__1::ratio<10l, 1l>, float>(fmt::v12::basic_string_view<char>, float)
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
359
  }
22
389
}
void invoke_inner<std::__1::ratio<1000l, 1l>, float>(fmt::v12::basic_string_view<char>, float)
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
366
  }
22
391
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, float>(fmt::v12::basic_string_view<char>, float)
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
338
  }
22
372
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, float>(fmt::v12::basic_string_view<char>, float)
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
340
  }
22
372
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
402
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
402
  auto value = std::chrono::duration<Rep, Period>(rep);
13
402
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
402
    auto buf = fmt::memory_buffer();
18
402
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
402
#endif
20
402
  } catch (std::exception&) {
21
375
  }
22
402
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
362
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
362
  auto value = std::chrono::duration<Rep, Period>(rep);
13
362
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
362
    auto buf = fmt::memory_buffer();
18
362
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
362
#endif
20
362
  } catch (std::exception&) {
21
337
  }
22
362
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
360
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
360
  auto value = std::chrono::duration<Rep, Period>(rep);
13
360
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
360
    auto buf = fmt::memory_buffer();
18
360
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
360
#endif
20
360
  } catch (std::exception&) {
21
318
  }
22
360
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
407
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
407
  auto value = std::chrono::duration<Rep, Period>(rep);
13
407
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
407
    auto buf = fmt::memory_buffer();
18
407
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
407
#endif
20
407
  } catch (std::exception&) {
21
372
  }
22
407
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, double>(fmt::v12::basic_string_view<char>, double)
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
352
  }
22
389
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
363
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
363
  auto value = std::chrono::duration<Rep, Period>(rep);
13
363
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
363
    auto buf = fmt::memory_buffer();
18
363
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
363
#endif
20
363
  } catch (std::exception&) {
21
324
  }
22
363
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
365
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
365
  auto value = std::chrono::duration<Rep, Period>(rep);
13
365
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
365
    auto buf = fmt::memory_buffer();
18
365
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
365
#endif
20
365
  } catch (std::exception&) {
21
327
  }
22
365
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, double>(fmt::v12::basic_string_view<char>, double)
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
344
  }
22
386
}
void invoke_inner<std::__1::ratio<1l, 1000l>, double>(fmt::v12::basic_string_view<char>, double)
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
345
  }
22
377
}
void invoke_inner<std::__1::ratio<1l, 100l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
383
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
383
  auto value = std::chrono::duration<Rep, Period>(rep);
13
383
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
383
    auto buf = fmt::memory_buffer();
18
383
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
383
#endif
20
383
  } catch (std::exception&) {
21
351
  }
22
383
}
void invoke_inner<std::__1::ratio<1l, 10l>, double>(fmt::v12::basic_string_view<char>, double)
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
355
  }
22
389
}
void invoke_inner<std::__1::ratio<10l, 1l>, double>(fmt::v12::basic_string_view<char>, double)
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
352
  }
22
379
}
void invoke_inner<std::__1::ratio<1000l, 1l>, double>(fmt::v12::basic_string_view<char>, double)
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
336
  }
22
377
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, double>(fmt::v12::basic_string_view<char>, double)
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
342
  }
22
389
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
390
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
390
  auto value = std::chrono::duration<Rep, Period>(rep);
13
390
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
390
    auto buf = fmt::memory_buffer();
18
390
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
390
#endif
20
390
  } catch (std::exception&) {
21
352
  }
22
390
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, double>(fmt::v12::basic_string_view<char>, double)
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<1000000000000000l, 1l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
363
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
363
  auto value = std::chrono::duration<Rep, Period>(rep);
13
363
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
363
    auto buf = fmt::memory_buffer();
18
363
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
363
#endif
20
363
  } catch (std::exception&) {
21
325
  }
22
363
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
358
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
358
  auto value = std::chrono::duration<Rep, Period>(rep);
13
358
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
358
    auto buf = fmt::memory_buffer();
18
358
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
358
#endif
20
358
  } catch (std::exception&) {
21
311
  }
22
358
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, long double>(fmt::v12::basic_string_view<char>, long double)
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
356
  }
22
391
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
390
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
390
  auto value = std::chrono::duration<Rep, Period>(rep);
13
390
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
390
    auto buf = fmt::memory_buffer();
18
390
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
390
#endif
20
390
  } catch (std::exception&) {
21
354
  }
22
390
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
366
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
366
  auto value = std::chrono::duration<Rep, Period>(rep);
13
366
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
366
    auto buf = fmt::memory_buffer();
18
366
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
366
#endif
20
366
  } catch (std::exception&) {
21
338
  }
22
366
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, long double>(fmt::v12::basic_string_view<char>, long double)
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
334
  }
22
364
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, long double>(fmt::v12::basic_string_view<char>, long double)
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<1l, 1000l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
383
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
383
  auto value = std::chrono::duration<Rep, Period>(rep);
13
383
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
383
    auto buf = fmt::memory_buffer();
18
383
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
383
#endif
20
383
  } catch (std::exception&) {
21
349
  }
22
383
}
void invoke_inner<std::__1::ratio<1l, 100l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
367
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
367
  auto value = std::chrono::duration<Rep, Period>(rep);
13
367
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
367
    auto buf = fmt::memory_buffer();
18
367
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
367
#endif
20
367
  } catch (std::exception&) {
21
340
  }
22
367
}
void invoke_inner<std::__1::ratio<1l, 10l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
368
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
368
  auto value = std::chrono::duration<Rep, Period>(rep);
13
368
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
368
    auto buf = fmt::memory_buffer();
18
368
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
368
#endif
20
368
  } catch (std::exception&) {
21
332
  }
22
368
}
void invoke_inner<std::__1::ratio<10l, 1l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
365
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
365
  auto value = std::chrono::duration<Rep, Period>(rep);
13
365
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
365
    auto buf = fmt::memory_buffer();
18
365
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
365
#endif
20
365
  } catch (std::exception&) {
21
341
  }
22
365
}
void invoke_inner<std::__1::ratio<1000l, 1l>, long double>(fmt::v12::basic_string_view<char>, long double)
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
352
  }
22
378
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, long double>(fmt::v12::basic_string_view<char>, long double)
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
342
  }
22
372
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
382
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
382
  auto value = std::chrono::duration<Rep, Period>(rep);
13
382
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
382
    auto buf = fmt::memory_buffer();
18
382
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
382
#endif
20
382
  } catch (std::exception&) {
21
344
  }
22
382
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, long double>(fmt::v12::basic_string_view<char>, long double)
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
329
  }
22
377
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
368
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
368
  auto value = std::chrono::duration<Rep, Period>(rep);
13
368
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
368
    auto buf = fmt::memory_buffer();
18
368
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
368
#endif
20
368
  } catch (std::exception&) {
21
337
  }
22
368
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
368
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
368
  auto value = std::chrono::duration<Rep, Period>(rep);
13
368
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
368
    auto buf = fmt::memory_buffer();
18
368
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
368
#endif
20
368
  } catch (std::exception&) {
21
306
  }
22
368
}
23
24
// Rep is a duration's representation type.
25
template <typename Rep>
26
50.6k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
50.6k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
50.6k
  if (size <= fixed_size + 1) return;
30
31
50.6k
  const Rep rep = assign_from_buf<Rep>(data);
32
50.6k
  data += fixed_size;
33
50.6k
  size -= fixed_size;
34
35
  // data is already allocated separately in libFuzzer so reading past the end
36
  // will most likely be detected anyway.
37
50.6k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
50.6k
  switch (period) {
41
3.46k
  case 1:
42
3.46k
    invoke_inner<std::atto>(format_str, rep);
43
3.46k
    break;
44
3.34k
  case 2:
45
3.34k
    invoke_inner<std::femto>(format_str, rep);
46
3.34k
    break;
47
3.27k
  case 3:
48
3.27k
    invoke_inner<std::pico>(format_str, rep);
49
3.27k
    break;
50
3.28k
  case 4:
51
3.28k
    invoke_inner<std::nano>(format_str, rep);
52
3.28k
    break;
53
3.30k
  case 5:
54
3.30k
    invoke_inner<std::micro>(format_str, rep);
55
3.30k
    break;
56
3.30k
  case 6:
57
3.30k
    invoke_inner<std::milli>(format_str, rep);
58
3.30k
    break;
59
3.23k
  case 7:
60
3.23k
    invoke_inner<std::centi>(format_str, rep);
61
3.23k
    break;
62
3.23k
  case 8:
63
3.23k
    invoke_inner<std::deci>(format_str, rep);
64
3.23k
    break;
65
3.59k
  case 9:
66
3.59k
    invoke_inner<std::deca>(format_str, rep);
67
3.59k
    break;
68
3.65k
  case 10:
69
3.65k
    invoke_inner<std::kilo>(format_str, rep);
70
3.65k
    break;
71
3.59k
  case 11:
72
3.59k
    invoke_inner<std::mega>(format_str, rep);
73
3.59k
    break;
74
3.61k
  case 12:
75
3.61k
    invoke_inner<std::giga>(format_str, rep);
76
3.61k
    break;
77
3.34k
  case 13:
78
3.34k
    invoke_inner<std::tera>(format_str, rep);
79
3.34k
    break;
80
3.19k
  case 14:
81
3.19k
    invoke_inner<std::peta>(format_str, rep);
82
3.19k
    break;
83
3.17k
  case 15:
84
3.17k
    invoke_inner<std::exa>(format_str, rep);
85
3.17k
    break;
86
50.6k
  }
87
50.6k
}
void invoke_outer<char>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
3.48k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
3.48k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
3.48k
  if (size <= fixed_size + 1) return;
30
31
3.48k
  const Rep rep = assign_from_buf<Rep>(data);
32
3.48k
  data += fixed_size;
33
3.48k
  size -= fixed_size;
34
35
  // data is already allocated separately in libFuzzer so reading past the end
36
  // will most likely be detected anyway.
37
3.48k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
3.48k
  switch (period) {
41
231
  case 1:
42
231
    invoke_inner<std::atto>(format_str, rep);
43
231
    break;
44
223
  case 2:
45
223
    invoke_inner<std::femto>(format_str, rep);
46
223
    break;
47
212
  case 3:
48
212
    invoke_inner<std::pico>(format_str, rep);
49
212
    break;
50
216
  case 4:
51
216
    invoke_inner<std::nano>(format_str, rep);
52
216
    break;
53
235
  case 5:
54
235
    invoke_inner<std::micro>(format_str, rep);
55
235
    break;
56
213
  case 6:
57
213
    invoke_inner<std::milli>(format_str, rep);
58
213
    break;
59
231
  case 7:
60
231
    invoke_inner<std::centi>(format_str, rep);
61
231
    break;
62
221
  case 8:
63
221
    invoke_inner<std::deci>(format_str, rep);
64
221
    break;
65
251
  case 9:
66
251
    invoke_inner<std::deca>(format_str, rep);
67
251
    break;
68
259
  case 10:
69
259
    invoke_inner<std::kilo>(format_str, rep);
70
259
    break;
71
267
  case 11:
72
267
    invoke_inner<std::mega>(format_str, rep);
73
267
    break;
74
278
  case 12:
75
278
    invoke_inner<std::giga>(format_str, rep);
76
278
    break;
77
223
  case 13:
78
223
    invoke_inner<std::tera>(format_str, rep);
79
223
    break;
80
214
  case 14:
81
214
    invoke_inner<std::peta>(format_str, rep);
82
214
    break;
83
208
  case 15:
84
208
    invoke_inner<std::exa>(format_str, rep);
85
208
    break;
86
3.48k
  }
87
3.48k
}
void invoke_outer<signed char>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
3.58k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
3.58k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
3.58k
  if (size <= fixed_size + 1) return;
30
31
3.57k
  const Rep rep = assign_from_buf<Rep>(data);
32
3.57k
  data += fixed_size;
33
3.57k
  size -= fixed_size;
34
35
  // data is already allocated separately in libFuzzer so reading past the end
36
  // will most likely be detected anyway.
37
3.57k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
3.57k
  switch (period) {
41
236
  case 1:
42
236
    invoke_inner<std::atto>(format_str, rep);
43
236
    break;
44
239
  case 2:
45
239
    invoke_inner<std::femto>(format_str, rep);
46
239
    break;
47
205
  case 3:
48
205
    invoke_inner<std::pico>(format_str, rep);
49
205
    break;
50
230
  case 4:
51
230
    invoke_inner<std::nano>(format_str, rep);
52
230
    break;
53
241
  case 5:
54
241
    invoke_inner<std::micro>(format_str, rep);
55
241
    break;
56
220
  case 6:
57
220
    invoke_inner<std::milli>(format_str, rep);
58
220
    break;
59
224
  case 7:
60
224
    invoke_inner<std::centi>(format_str, rep);
61
224
    break;
62
234
  case 8:
63
234
    invoke_inner<std::deci>(format_str, rep);
64
234
    break;
65
288
  case 9:
66
288
    invoke_inner<std::deca>(format_str, rep);
67
288
    break;
68
259
  case 10:
69
259
    invoke_inner<std::kilo>(format_str, rep);
70
259
    break;
71
277
  case 11:
72
277
    invoke_inner<std::mega>(format_str, rep);
73
277
    break;
74
266
  case 12:
75
266
    invoke_inner<std::giga>(format_str, rep);
76
266
    break;
77
221
  case 13:
78
221
    invoke_inner<std::tera>(format_str, rep);
79
221
    break;
80
217
  case 14:
81
217
    invoke_inner<std::peta>(format_str, rep);
82
217
    break;
83
218
  case 15:
84
218
    invoke_inner<std::exa>(format_str, rep);
85
218
    break;
86
3.57k
  }
87
3.57k
}
void invoke_outer<unsigned char>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
3.29k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
3.29k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
3.29k
  if (size <= fixed_size + 1) return;
30
31
3.28k
  const Rep rep = assign_from_buf<Rep>(data);
32
3.28k
  data += fixed_size;
33
3.28k
  size -= fixed_size;
34
35
  // data is already allocated separately in libFuzzer so reading past the end
36
  // will most likely be detected anyway.
37
3.28k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
3.28k
  switch (period) {
41
210
  case 1:
42
210
    invoke_inner<std::atto>(format_str, rep);
43
210
    break;
44
207
  case 2:
45
207
    invoke_inner<std::femto>(format_str, rep);
46
207
    break;
47
213
  case 3:
48
213
    invoke_inner<std::pico>(format_str, rep);
49
213
    break;
50
208
  case 4:
51
208
    invoke_inner<std::nano>(format_str, rep);
52
208
    break;
53
216
  case 5:
54
216
    invoke_inner<std::micro>(format_str, rep);
55
216
    break;
56
210
  case 6:
57
210
    invoke_inner<std::milli>(format_str, rep);
58
210
    break;
59
189
  case 7:
60
189
    invoke_inner<std::centi>(format_str, rep);
61
189
    break;
62
207
  case 8:
63
207
    invoke_inner<std::deci>(format_str, rep);
64
207
    break;
65
244
  case 9:
66
244
    invoke_inner<std::deca>(format_str, rep);
67
244
    break;
68
263
  case 10:
69
263
    invoke_inner<std::kilo>(format_str, rep);
70
263
    break;
71
246
  case 11:
72
246
    invoke_inner<std::mega>(format_str, rep);
73
246
    break;
74
237
  case 12:
75
237
    invoke_inner<std::giga>(format_str, rep);
76
237
    break;
77
218
  case 13:
78
218
    invoke_inner<std::tera>(format_str, rep);
79
218
    break;
80
207
  case 14:
81
207
    invoke_inner<std::peta>(format_str, rep);
82
207
    break;
83
211
  case 15:
84
211
    invoke_inner<std::exa>(format_str, rep);
85
211
    break;
86
3.28k
  }
87
3.28k
}
void invoke_outer<short>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
3.68k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
3.68k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
3.68k
  if (size <= fixed_size + 1) return;
30
31
3.67k
  const Rep rep = assign_from_buf<Rep>(data);
32
3.67k
  data += fixed_size;
33
3.67k
  size -= fixed_size;
34
35
  // data is already allocated separately in libFuzzer so reading past the end
36
  // will most likely be detected anyway.
37
3.67k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
3.67k
  switch (period) {
41
250
  case 1:
42
250
    invoke_inner<std::atto>(format_str, rep);
43
250
    break;
44
229
  case 2:
45
229
    invoke_inner<std::femto>(format_str, rep);
46
229
    break;
47
222
  case 3:
48
222
    invoke_inner<std::pico>(format_str, rep);
49
222
    break;
50
241
  case 4:
51
241
    invoke_inner<std::nano>(format_str, rep);
52
241
    break;
53
229
  case 5:
54
229
    invoke_inner<std::micro>(format_str, rep);
55
229
    break;
56
234
  case 6:
57
234
    invoke_inner<std::milli>(format_str, rep);
58
234
    break;
59
228
  case 7:
60
228
    invoke_inner<std::centi>(format_str, rep);
61
228
    break;
62
225
  case 8:
63
225
    invoke_inner<std::deci>(format_str, rep);
64
225
    break;
65
282
  case 9:
66
282
    invoke_inner<std::deca>(format_str, rep);
67
282
    break;
68
275
  case 10:
69
275
    invoke_inner<std::kilo>(format_str, rep);
70
275
    break;
71
280
  case 11:
72
280
    invoke_inner<std::mega>(format_str, rep);
73
280
    break;
74
289
  case 12:
75
289
    invoke_inner<std::giga>(format_str, rep);
76
289
    break;
77
239
  case 13:
78
239
    invoke_inner<std::tera>(format_str, rep);
79
239
    break;
80
241
  case 14:
81
241
    invoke_inner<std::peta>(format_str, rep);
82
241
    break;
83
213
  case 15:
84
213
    invoke_inner<std::exa>(format_str, rep);
85
213
    break;
86
3.67k
  }
87
3.67k
}
void invoke_outer<unsigned short>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
3.35k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
3.35k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
3.35k
  if (size <= fixed_size + 1) return;
30
31
3.35k
  const Rep rep = assign_from_buf<Rep>(data);
32
3.35k
  data += fixed_size;
33
3.35k
  size -= fixed_size;
34
35
  // data is already allocated separately in libFuzzer so reading past the end
36
  // will most likely be detected anyway.
37
3.35k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
3.35k
  switch (period) {
41
208
  case 1:
42
208
    invoke_inner<std::atto>(format_str, rep);
43
208
    break;
44
205
  case 2:
45
205
    invoke_inner<std::femto>(format_str, rep);
46
205
    break;
47
208
  case 3:
48
208
    invoke_inner<std::pico>(format_str, rep);
49
208
    break;
50
201
  case 4:
51
201
    invoke_inner<std::nano>(format_str, rep);
52
201
    break;
53
216
  case 5:
54
216
    invoke_inner<std::micro>(format_str, rep);
55
216
    break;
56
212
  case 6:
57
212
    invoke_inner<std::milli>(format_str, rep);
58
212
    break;
59
202
  case 7:
60
202
    invoke_inner<std::centi>(format_str, rep);
61
202
    break;
62
208
  case 8:
63
208
    invoke_inner<std::deci>(format_str, rep);
64
208
    break;
65
257
  case 9:
66
257
    invoke_inner<std::deca>(format_str, rep);
67
257
    break;
68
273
  case 10:
69
273
    invoke_inner<std::kilo>(format_str, rep);
70
273
    break;
71
264
  case 11:
72
264
    invoke_inner<std::mega>(format_str, rep);
73
264
    break;
74
237
  case 12:
75
237
    invoke_inner<std::giga>(format_str, rep);
76
237
    break;
77
225
  case 13:
78
225
    invoke_inner<std::tera>(format_str, rep);
79
225
    break;
80
217
  case 14:
81
217
    invoke_inner<std::peta>(format_str, rep);
82
217
    break;
83
216
  case 15:
84
216
    invoke_inner<std::exa>(format_str, rep);
85
216
    break;
86
3.35k
  }
87
3.35k
}
void invoke_outer<int>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
3.87k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
3.87k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
3.87k
  if (size <= fixed_size + 1) return;
30
31
3.87k
  const Rep rep = assign_from_buf<Rep>(data);
32
3.87k
  data += fixed_size;
33
3.87k
  size -= fixed_size;
34
35
  // data is already allocated separately in libFuzzer so reading past the end
36
  // will most likely be detected anyway.
37
3.87k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
3.87k
  switch (period) {
41
250
  case 1:
42
250
    invoke_inner<std::atto>(format_str, rep);
43
250
    break;
44
245
  case 2:
45
245
    invoke_inner<std::femto>(format_str, rep);
46
245
    break;
47
257
  case 3:
48
257
    invoke_inner<std::pico>(format_str, rep);
49
257
    break;
50
244
  case 4:
51
244
    invoke_inner<std::nano>(format_str, rep);
52
244
    break;
53
247
  case 5:
54
247
    invoke_inner<std::micro>(format_str, rep);
55
247
    break;
56
242
  case 6:
57
242
    invoke_inner<std::milli>(format_str, rep);
58
242
    break;
59
257
  case 7:
60
257
    invoke_inner<std::centi>(format_str, rep);
61
257
    break;
62
258
  case 8:
63
258
    invoke_inner<std::deci>(format_str, rep);
64
258
    break;
65
283
  case 9:
66
283
    invoke_inner<std::deca>(format_str, rep);
67
283
    break;
68
289
  case 10:
69
289
    invoke_inner<std::kilo>(format_str, rep);
70
289
    break;
71
299
  case 11:
72
299
    invoke_inner<std::mega>(format_str, rep);
73
299
    break;
74
286
  case 12:
75
286
    invoke_inner<std::giga>(format_str, rep);
76
286
    break;
77
238
  case 13:
78
238
    invoke_inner<std::tera>(format_str, rep);
79
238
    break;
80
234
  case 14:
81
234
    invoke_inner<std::peta>(format_str, rep);
82
234
    break;
83
240
  case 15:
84
240
    invoke_inner<std::exa>(format_str, rep);
85
240
    break;
86
3.87k
  }
87
3.87k
}
void invoke_outer<unsigned int>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
3.41k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
3.41k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
3.41k
  if (size <= fixed_size + 1) return;
30
31
3.41k
  const Rep rep = assign_from_buf<Rep>(data);
32
3.41k
  data += fixed_size;
33
3.41k
  size -= fixed_size;
34
35
  // data is already allocated separately in libFuzzer so reading past the end
36
  // will most likely be detected anyway.
37
3.41k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
3.41k
  switch (period) {
41
247
  case 1:
42
247
    invoke_inner<std::atto>(format_str, rep);
43
247
    break;
44
219
  case 2:
45
219
    invoke_inner<std::femto>(format_str, rep);
46
219
    break;
47
225
  case 3:
48
225
    invoke_inner<std::pico>(format_str, rep);
49
225
    break;
50
227
  case 4:
51
227
    invoke_inner<std::nano>(format_str, rep);
52
227
    break;
53
213
  case 5:
54
213
    invoke_inner<std::micro>(format_str, rep);
55
213
    break;
56
219
  case 6:
57
219
    invoke_inner<std::milli>(format_str, rep);
58
219
    break;
59
199
  case 7:
60
199
    invoke_inner<std::centi>(format_str, rep);
61
199
    break;
62
209
  case 8:
63
209
    invoke_inner<std::deci>(format_str, rep);
64
209
    break;
65
254
  case 9:
66
254
    invoke_inner<std::deca>(format_str, rep);
67
254
    break;
68
245
  case 10:
69
245
    invoke_inner<std::kilo>(format_str, rep);
70
245
    break;
71
240
  case 11:
72
240
    invoke_inner<std::mega>(format_str, rep);
73
240
    break;
74
255
  case 12:
75
255
    invoke_inner<std::giga>(format_str, rep);
76
255
    break;
77
212
  case 13:
78
212
    invoke_inner<std::tera>(format_str, rep);
79
212
    break;
80
226
  case 14:
81
226
    invoke_inner<std::peta>(format_str, rep);
82
226
    break;
83
226
  case 15:
84
226
    invoke_inner<std::exa>(format_str, rep);
85
226
    break;
86
3.41k
  }
87
3.41k
}
void invoke_outer<long>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
4.91k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
4.91k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
4.91k
  if (size <= fixed_size + 1) return;
30
31
4.91k
  const Rep rep = assign_from_buf<Rep>(data);
32
4.91k
  data += fixed_size;
33
4.91k
  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.91k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
4.91k
  switch (period) {
41
374
  case 1:
42
374
    invoke_inner<std::atto>(format_str, rep);
43
374
    break;
44
372
  case 2:
45
372
    invoke_inner<std::femto>(format_str, rep);
46
372
    break;
47
337
  case 3:
48
337
    invoke_inner<std::pico>(format_str, rep);
49
337
    break;
50
342
  case 4:
51
342
    invoke_inner<std::nano>(format_str, rep);
52
342
    break;
53
313
  case 5:
54
313
    invoke_inner<std::micro>(format_str, rep);
55
313
    break;
56
348
  case 6:
57
348
    invoke_inner<std::milli>(format_str, rep);
58
348
    break;
59
321
  case 7:
60
321
    invoke_inner<std::centi>(format_str, rep);
61
321
    break;
62
297
  case 8:
63
297
    invoke_inner<std::deci>(format_str, rep);
64
297
    break;
65
322
  case 9:
66
322
    invoke_inner<std::deca>(format_str, rep);
67
322
    break;
68
337
  case 10:
69
337
    invoke_inner<std::kilo>(format_str, rep);
70
337
    break;
71
310
  case 11:
72
310
    invoke_inner<std::mega>(format_str, rep);
73
310
    break;
74
334
  case 12:
75
334
    invoke_inner<std::giga>(format_str, rep);
76
334
    break;
77
332
  case 13:
78
332
    invoke_inner<std::tera>(format_str, rep);
79
332
    break;
80
276
  case 14:
81
276
    invoke_inner<std::peta>(format_str, rep);
82
276
    break;
83
294
  case 15:
84
294
    invoke_inner<std::exa>(format_str, rep);
85
294
    break;
86
4.91k
  }
87
4.91k
}
void invoke_outer<unsigned long>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
4.10k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
4.10k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
4.10k
  if (size <= fixed_size + 1) return;
30
31
4.10k
  const Rep rep = assign_from_buf<Rep>(data);
32
4.10k
  data += fixed_size;
33
4.10k
  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.10k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
4.10k
  switch (period) {
41
278
  case 1:
42
278
    invoke_inner<std::atto>(format_str, rep);
43
278
    break;
44
265
  case 2:
45
265
    invoke_inner<std::femto>(format_str, rep);
46
265
    break;
47
284
  case 3:
48
284
    invoke_inner<std::pico>(format_str, rep);
49
284
    break;
50
272
  case 4:
51
272
    invoke_inner<std::nano>(format_str, rep);
52
272
    break;
53
259
  case 5:
54
259
    invoke_inner<std::micro>(format_str, rep);
55
259
    break;
56
260
  case 6:
57
260
    invoke_inner<std::milli>(format_str, rep);
58
260
    break;
59
272
  case 7:
60
272
    invoke_inner<std::centi>(format_str, rep);
61
272
    break;
62
251
  case 8:
63
251
    invoke_inner<std::deci>(format_str, rep);
64
251
    break;
65
278
  case 9:
66
278
    invoke_inner<std::deca>(format_str, rep);
67
278
    break;
68
312
  case 10:
69
312
    invoke_inner<std::kilo>(format_str, rep);
70
312
    break;
71
280
  case 11:
72
280
    invoke_inner<std::mega>(format_str, rep);
73
280
    break;
74
289
  case 12:
75
289
    invoke_inner<std::giga>(format_str, rep);
76
289
    break;
77
274
  case 13:
78
274
    invoke_inner<std::tera>(format_str, rep);
79
274
    break;
80
266
  case 14:
81
266
    invoke_inner<std::peta>(format_str, rep);
82
266
    break;
83
265
  case 15:
84
265
    invoke_inner<std::exa>(format_str, rep);
85
265
    break;
86
4.10k
  }
87
4.10k
}
void invoke_outer<float>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
5.63k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
5.63k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
5.63k
  if (size <= fixed_size + 1) return;
30
31
5.63k
  const Rep rep = assign_from_buf<Rep>(data);
32
5.63k
  data += fixed_size;
33
5.63k
  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.63k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
5.63k
  switch (period) {
41
386
  case 1:
42
386
    invoke_inner<std::atto>(format_str, rep);
43
386
    break;
44
358
  case 2:
45
358
    invoke_inner<std::femto>(format_str, rep);
46
358
    break;
47
382
  case 3:
48
382
    invoke_inner<std::pico>(format_str, rep);
49
382
    break;
50
375
  case 4:
51
375
    invoke_inner<std::nano>(format_str, rep);
52
375
    break;
53
369
  case 5:
54
369
    invoke_inner<std::micro>(format_str, rep);
55
369
    break;
56
382
  case 6:
57
382
    invoke_inner<std::milli>(format_str, rep);
58
382
    break;
59
361
  case 7:
60
361
    invoke_inner<std::centi>(format_str, rep);
61
361
    break;
62
371
  case 8:
63
371
    invoke_inner<std::deci>(format_str, rep);
64
371
    break;
65
389
  case 9:
66
389
    invoke_inner<std::deca>(format_str, rep);
67
389
    break;
68
391
  case 10:
69
391
    invoke_inner<std::kilo>(format_str, rep);
70
391
    break;
71
372
  case 11:
72
372
    invoke_inner<std::mega>(format_str, rep);
73
372
    break;
74
372
  case 12:
75
372
    invoke_inner<std::giga>(format_str, rep);
76
372
    break;
77
402
  case 13:
78
402
    invoke_inner<std::tera>(format_str, rep);
79
402
    break;
80
362
  case 14:
81
362
    invoke_inner<std::peta>(format_str, rep);
82
362
    break;
83
360
  case 15:
84
360
    invoke_inner<std::exa>(format_str, rep);
85
360
    break;
86
5.63k
  }
87
5.63k
}
void invoke_outer<double>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
5.69k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
5.69k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
5.69k
  if (size <= fixed_size + 1) return;
30
31
5.69k
  const Rep rep = assign_from_buf<Rep>(data);
32
5.69k
  data += fixed_size;
33
5.69k
  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.69k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
5.69k
  switch (period) {
41
407
  case 1:
42
407
    invoke_inner<std::atto>(format_str, rep);
43
407
    break;
44
389
  case 2:
45
389
    invoke_inner<std::femto>(format_str, rep);
46
389
    break;
47
363
  case 3:
48
363
    invoke_inner<std::pico>(format_str, rep);
49
363
    break;
50
365
  case 4:
51
365
    invoke_inner<std::nano>(format_str, rep);
52
365
    break;
53
386
  case 5:
54
386
    invoke_inner<std::micro>(format_str, rep);
55
386
    break;
56
377
  case 6:
57
377
    invoke_inner<std::milli>(format_str, rep);
58
377
    break;
59
383
  case 7:
60
383
    invoke_inner<std::centi>(format_str, rep);
61
383
    break;
62
389
  case 8:
63
389
    invoke_inner<std::deci>(format_str, rep);
64
389
    break;
65
379
  case 9:
66
379
    invoke_inner<std::deca>(format_str, rep);
67
379
    break;
68
377
  case 10:
69
377
    invoke_inner<std::kilo>(format_str, rep);
70
377
    break;
71
389
  case 11:
72
389
    invoke_inner<std::mega>(format_str, rep);
73
389
    break;
74
390
  case 12:
75
390
    invoke_inner<std::giga>(format_str, rep);
76
390
    break;
77
379
  case 13:
78
379
    invoke_inner<std::tera>(format_str, rep);
79
379
    break;
80
363
  case 14:
81
363
    invoke_inner<std::peta>(format_str, rep);
82
363
    break;
83
358
  case 15:
84
358
    invoke_inner<std::exa>(format_str, rep);
85
358
    break;
86
5.69k
  }
87
5.69k
}
void invoke_outer<long double>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
5.62k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
5.62k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
5.62k
  if (size <= fixed_size + 1) return;
30
31
5.62k
  const Rep rep = assign_from_buf<Rep>(data);
32
5.62k
  data += fixed_size;
33
5.62k
  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.62k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
5.62k
  switch (period) {
41
391
  case 1:
42
391
    invoke_inner<std::atto>(format_str, rep);
43
391
    break;
44
390
  case 2:
45
390
    invoke_inner<std::femto>(format_str, rep);
46
390
    break;
47
366
  case 3:
48
366
    invoke_inner<std::pico>(format_str, rep);
49
366
    break;
50
364
  case 4:
51
364
    invoke_inner<std::nano>(format_str, rep);
52
364
    break;
53
380
  case 5:
54
380
    invoke_inner<std::micro>(format_str, rep);
55
380
    break;
56
383
  case 6:
57
383
    invoke_inner<std::milli>(format_str, rep);
58
383
    break;
59
367
  case 7:
60
367
    invoke_inner<std::centi>(format_str, rep);
61
367
    break;
62
368
  case 8:
63
368
    invoke_inner<std::deci>(format_str, rep);
64
368
    break;
65
365
  case 9:
66
365
    invoke_inner<std::deca>(format_str, rep);
67
365
    break;
68
378
  case 10:
69
378
    invoke_inner<std::kilo>(format_str, rep);
70
378
    break;
71
372
  case 11:
72
372
    invoke_inner<std::mega>(format_str, rep);
73
372
    break;
74
382
  case 12:
75
382
    invoke_inner<std::giga>(format_str, rep);
76
382
    break;
77
377
  case 13:
78
377
    invoke_inner<std::tera>(format_str, rep);
79
377
    break;
80
368
  case 14:
81
368
    invoke_inner<std::peta>(format_str, rep);
82
368
    break;
83
368
  case 15:
84
368
    invoke_inner<std::exa>(format_str, rep);
85
368
    break;
86
5.62k
  }
87
5.62k
}
88
89
50.6k
extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
90
50.6k
  if (size <= 4) return 0;
91
92
50.6k
  const auto representation = data[0];
93
50.6k
  const auto period = data[1];
94
50.6k
  data += 2;
95
50.6k
  size -= 2;
96
97
50.6k
  switch (representation) {
98
3.48k
  case 1:
99
3.48k
    invoke_outer<char>(data, size, period);
100
3.48k
    break;
101
3.58k
  case 2:
102
3.58k
    invoke_outer<signed char>(data, size, period);
103
3.58k
    break;
104
3.29k
  case 3:
105
3.29k
    invoke_outer<unsigned char>(data, size, period);
106
3.29k
    break;
107
3.68k
  case 4:
108
3.68k
    invoke_outer<short>(data, size, period);
109
3.68k
    break;
110
3.35k
  case 5:
111
3.35k
    invoke_outer<unsigned short>(data, size, period);
112
3.35k
    break;
113
3.87k
  case 6:
114
3.87k
    invoke_outer<int>(data, size, period);
115
3.87k
    break;
116
3.41k
  case 7:
117
3.41k
    invoke_outer<unsigned int>(data, size, period);
118
3.41k
    break;
119
4.91k
  case 8:
120
4.91k
    invoke_outer<long>(data, size, period);
121
4.91k
    break;
122
4.10k
  case 9:
123
4.10k
    invoke_outer<unsigned long>(data, size, period);
124
4.10k
    break;
125
5.63k
  case 10:
126
5.63k
    invoke_outer<float>(data, size, period);
127
5.63k
    break;
128
5.69k
  case 11:
129
5.69k
    invoke_outer<double>(data, size, period);
130
5.69k
    break;
131
5.62k
  case 12:
132
5.62k
    invoke_outer<long double>(data, size, period);
133
5.62k
    break;
134
50.6k
  }
135
50.6k
  return 0;
136
50.6k
}