Coverage Report

Created: 2025-11-11 06:06

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
47.1k
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
47.1k
  auto value = std::chrono::duration<Rep, Period>(rep);
13
47.1k
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
47.1k
    auto buf = fmt::memory_buffer();
18
47.1k
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
47.1k
#endif
20
47.1k
  } catch (std::exception&) {
21
42.8k
  }
22
47.1k
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, char>(fmt::v12::basic_string_view<char>, char)
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
198
  }
22
219
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
222
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
222
  auto value = std::chrono::duration<Rep, Period>(rep);
13
222
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
222
    auto buf = fmt::memory_buffer();
18
222
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
222
#endif
20
222
  } catch (std::exception&) {
21
204
  }
22
222
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
203
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
203
  auto value = std::chrono::duration<Rep, Period>(rep);
13
203
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
203
    auto buf = fmt::memory_buffer();
18
203
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
203
#endif
20
203
  } catch (std::exception&) {
21
178
  }
22
203
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
194
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
194
  auto value = std::chrono::duration<Rep, Period>(rep);
13
194
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
194
    auto buf = fmt::memory_buffer();
18
194
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
194
#endif
20
194
  } catch (std::exception&) {
21
171
  }
22
194
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
222
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
222
  auto value = std::chrono::duration<Rep, Period>(rep);
13
222
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
222
    auto buf = fmt::memory_buffer();
18
222
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
222
#endif
20
222
  } catch (std::exception&) {
21
195
  }
22
222
}
void invoke_inner<std::__1::ratio<1l, 1000l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
200
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
200
  auto value = std::chrono::duration<Rep, Period>(rep);
13
200
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
200
    auto buf = fmt::memory_buffer();
18
200
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
200
#endif
20
200
  } catch (std::exception&) {
21
180
  }
22
200
}
void invoke_inner<std::__1::ratio<1l, 100l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
204
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
204
  auto value = std::chrono::duration<Rep, Period>(rep);
13
204
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
204
    auto buf = fmt::memory_buffer();
18
204
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
204
#endif
20
204
  } catch (std::exception&) {
21
180
  }
22
204
}
void invoke_inner<std::__1::ratio<1l, 10l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
194
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
194
  auto value = std::chrono::duration<Rep, Period>(rep);
13
194
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
194
    auto buf = fmt::memory_buffer();
18
194
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
194
#endif
20
194
  } catch (std::exception&) {
21
169
  }
22
194
}
void invoke_inner<std::__1::ratio<10l, 1l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
245
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
245
  auto value = std::chrono::duration<Rep, Period>(rep);
13
245
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
245
    auto buf = fmt::memory_buffer();
18
245
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
245
#endif
20
245
  } catch (std::exception&) {
21
231
  }
22
245
}
void invoke_inner<std::__1::ratio<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
243
  }
22
259
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
245
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
245
  auto value = std::chrono::duration<Rep, Period>(rep);
13
245
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
245
    auto buf = fmt::memory_buffer();
18
245
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
245
#endif
20
245
  } catch (std::exception&) {
21
222
  }
22
245
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, char>(fmt::v12::basic_string_view<char>, 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
222
  }
22
244
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
193
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
193
  auto value = std::chrono::duration<Rep, Period>(rep);
13
193
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
193
    auto buf = fmt::memory_buffer();
18
193
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
193
#endif
20
193
  } catch (std::exception&) {
21
176
  }
22
193
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
204
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
204
  auto value = std::chrono::duration<Rep, Period>(rep);
13
204
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
204
    auto buf = fmt::memory_buffer();
18
204
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
204
#endif
20
204
  } catch (std::exception&) {
21
182
  }
22
204
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, char>(fmt::v12::basic_string_view<char>, 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
196
  }
22
211
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, 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
210
  }
22
221
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
215
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
215
  auto value = std::chrono::duration<Rep, Period>(rep);
13
215
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
215
    auto buf = fmt::memory_buffer();
18
215
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
215
#endif
20
215
  } catch (std::exception&) {
21
200
  }
22
215
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, signed char>(fmt::v12::basic_string_view<char>, signed 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
184
  }
22
207
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
222
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
222
  auto value = std::chrono::duration<Rep, Period>(rep);
13
222
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
222
    auto buf = fmt::memory_buffer();
18
222
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
222
#endif
20
222
  } catch (std::exception&) {
21
208
  }
22
222
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
204
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
204
  auto value = std::chrono::duration<Rep, Period>(rep);
13
204
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
204
    auto buf = fmt::memory_buffer();
18
204
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
204
#endif
20
204
  } catch (std::exception&) {
21
182
  }
22
204
}
void invoke_inner<std::__1::ratio<1l, 1000l>, signed char>(fmt::v12::basic_string_view<char>, signed 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
195
  }
22
213
}
void invoke_inner<std::__1::ratio<1l, 100l>, signed char>(fmt::v12::basic_string_view<char>, signed 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
186
  }
22
210
}
void invoke_inner<std::__1::ratio<1l, 10l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
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
197
  }
22
219
}
void invoke_inner<std::__1::ratio<10l, 1l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
281
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
281
  auto value = std::chrono::duration<Rep, Period>(rep);
13
281
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
281
    auto buf = fmt::memory_buffer();
18
281
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
281
#endif
20
281
  } catch (std::exception&) {
21
254
  }
22
281
}
void invoke_inner<std::__1::ratio<1000l, 1l>, 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
220
  }
22
239
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
253
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
253
  auto value = std::chrono::duration<Rep, Period>(rep);
13
253
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
253
    auto buf = fmt::memory_buffer();
18
253
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
253
#endif
20
253
  } catch (std::exception&) {
21
233
  }
22
253
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, signed char>(fmt::v12::basic_string_view<char>, signed 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
240
  }
22
263
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
200
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
200
  auto value = std::chrono::duration<Rep, Period>(rep);
13
200
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
200
    auto buf = fmt::memory_buffer();
18
200
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
200
#endif
20
200
  } catch (std::exception&) {
21
182
  }
22
200
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
206
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
206
  auto value = std::chrono::duration<Rep, Period>(rep);
13
206
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
206
    auto buf = fmt::memory_buffer();
18
206
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
206
#endif
20
206
  } catch (std::exception&) {
21
189
  }
22
206
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, signed char>(fmt::v12::basic_string_view<char>, signed 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
171
  }
22
189
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
194
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
194
  auto value = std::chrono::duration<Rep, Period>(rep);
13
194
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
194
    auto buf = fmt::memory_buffer();
18
194
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
194
#endif
20
194
  } catch (std::exception&) {
21
175
  }
22
194
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
197
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
197
  auto value = std::chrono::duration<Rep, Period>(rep);
13
197
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
197
    auto buf = fmt::memory_buffer();
18
197
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
197
#endif
20
197
  } catch (std::exception&) {
21
176
  }
22
197
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
196
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
196
  auto value = std::chrono::duration<Rep, Period>(rep);
13
196
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
196
    auto buf = fmt::memory_buffer();
18
196
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
196
#endif
20
196
  } catch (std::exception&) {
21
174
  }
22
196
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
198
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
198
  auto value = std::chrono::duration<Rep, Period>(rep);
13
198
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
198
    auto buf = fmt::memory_buffer();
18
198
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
198
#endif
20
198
  } catch (std::exception&) {
21
174
  }
22
198
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
191
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
191
  auto value = std::chrono::duration<Rep, Period>(rep);
13
191
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
191
    auto buf = fmt::memory_buffer();
18
191
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
191
#endif
20
191
  } catch (std::exception&) {
21
178
  }
22
191
}
void invoke_inner<std::__1::ratio<1l, 1000l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
193
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
193
  auto value = std::chrono::duration<Rep, Period>(rep);
13
193
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
193
    auto buf = fmt::memory_buffer();
18
193
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
193
#endif
20
193
  } catch (std::exception&) {
21
176
  }
22
193
}
void invoke_inner<std::__1::ratio<1l, 100l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
181
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
181
  auto value = std::chrono::duration<Rep, Period>(rep);
13
181
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
181
    auto buf = fmt::memory_buffer();
18
181
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
181
#endif
20
181
  } catch (std::exception&) {
21
165
  }
22
181
}
void invoke_inner<std::__1::ratio<1l, 10l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
191
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
191
  auto value = std::chrono::duration<Rep, Period>(rep);
13
191
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
191
    auto buf = fmt::memory_buffer();
18
191
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
191
#endif
20
191
  } catch (std::exception&) {
21
178
  }
22
191
}
void invoke_inner<std::__1::ratio<10l, 1l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned 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
207
  }
22
234
}
void invoke_inner<std::__1::ratio<1000l, 1l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
253
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
253
  auto value = std::chrono::duration<Rep, Period>(rep);
13
253
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
253
    auto buf = fmt::memory_buffer();
18
253
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
253
#endif
20
253
  } catch (std::exception&) {
21
231
  }
22
253
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned 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
212
  }
22
234
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
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
202
  }
22
225
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
206
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
206
  auto value = std::chrono::duration<Rep, Period>(rep);
13
206
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
206
    auto buf = fmt::memory_buffer();
18
206
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
206
#endif
20
206
  } catch (std::exception&) {
21
193
  }
22
206
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
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
181
  }
22
201
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned 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
181
  }
22
205
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
233
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
233
  auto value = std::chrono::duration<Rep, Period>(rep);
13
233
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
233
    auto buf = fmt::memory_buffer();
18
233
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
233
#endif
20
233
  } catch (std::exception&) {
21
216
  }
22
233
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, short>(fmt::v12::basic_string_view<char>, short)
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
193
  }
22
211
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, short>(fmt::v12::basic_string_view<char>, short)
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
184
  }
22
207
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, short>(fmt::v12::basic_string_view<char>, short)
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
207
  }
22
219
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
204
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
204
  auto value = std::chrono::duration<Rep, Period>(rep);
13
204
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
204
    auto buf = fmt::memory_buffer();
18
204
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
204
#endif
20
204
  } catch (std::exception&) {
21
182
  }
22
204
}
void invoke_inner<std::__1::ratio<1l, 1000l>, 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
203
  }
22
228
}
void invoke_inner<std::__1::ratio<1l, 100l>, short>(fmt::v12::basic_string_view<char>, short)
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
189
  }
22
207
}
void invoke_inner<std::__1::ratio<1l, 10l>, short>(fmt::v12::basic_string_view<char>, short)
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
196
  }
22
210
}
void invoke_inner<std::__1::ratio<10l, 1l>, short>(fmt::v12::basic_string_view<char>, short)
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
222
  }
22
245
}
void invoke_inner<std::__1::ratio<1000l, 1l>, 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
230
  }
22
250
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
249
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
249
  auto value = std::chrono::duration<Rep, Period>(rep);
13
249
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
249
    auto buf = fmt::memory_buffer();
18
249
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
249
#endif
20
249
  } catch (std::exception&) {
21
229
  }
22
249
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
240
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
240
  auto value = std::chrono::duration<Rep, Period>(rep);
13
240
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
240
    auto buf = fmt::memory_buffer();
18
240
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
240
#endif
20
240
  } catch (std::exception&) {
21
221
  }
22
240
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, short>(fmt::v12::basic_string_view<char>, short)
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
206
  }
22
218
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, short>(fmt::v12::basic_string_view<char>, 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
198
  }
22
217
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, short>(fmt::v12::basic_string_view<char>, 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>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
197
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
197
  auto value = std::chrono::duration<Rep, Period>(rep);
13
197
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
197
    auto buf = fmt::memory_buffer();
18
197
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
197
#endif
20
197
  } catch (std::exception&) {
21
182
  }
22
197
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
190
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
190
  auto value = std::chrono::duration<Rep, Period>(rep);
13
190
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
190
    auto buf = fmt::memory_buffer();
18
190
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
190
#endif
20
190
  } catch (std::exception&) {
21
173
  }
22
190
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
197
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
197
  auto value = std::chrono::duration<Rep, Period>(rep);
13
197
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
197
    auto buf = fmt::memory_buffer();
18
197
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
197
#endif
20
197
  } catch (std::exception&) {
21
181
  }
22
197
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
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
173
  }
22
189
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
196
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
196
  auto value = std::chrono::duration<Rep, Period>(rep);
13
196
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
196
    auto buf = fmt::memory_buffer();
18
196
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
196
#endif
20
196
  } catch (std::exception&) {
21
181
  }
22
196
}
void invoke_inner<std::__1::ratio<1l, 1000l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
204
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
204
  auto value = std::chrono::duration<Rep, Period>(rep);
13
204
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
204
    auto buf = fmt::memory_buffer();
18
204
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
204
#endif
20
204
  } catch (std::exception&) {
21
179
  }
22
204
}
void invoke_inner<std::__1::ratio<1l, 100l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
175
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
175
  auto value = std::chrono::duration<Rep, Period>(rep);
13
175
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
175
    auto buf = fmt::memory_buffer();
18
175
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
175
#endif
20
175
  } catch (std::exception&) {
21
160
  }
22
175
}
void invoke_inner<std::__1::ratio<1l, 10l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
191
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
191
  auto value = std::chrono::duration<Rep, Period>(rep);
13
191
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
191
    auto buf = fmt::memory_buffer();
18
191
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
191
#endif
20
191
  } catch (std::exception&) {
21
170
  }
22
191
}
void invoke_inner<std::__1::ratio<10l, 1l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
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
223
  }
22
247
}
void invoke_inner<std::__1::ratio<1000l, 1l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
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
223
  }
22
242
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
230
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
230
  auto value = std::chrono::duration<Rep, Period>(rep);
13
230
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
230
    auto buf = fmt::memory_buffer();
18
230
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
230
#endif
20
230
  } catch (std::exception&) {
21
205
  }
22
230
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
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
208
  }
22
224
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
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
189
  }
22
214
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, 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
186
  }
22
212
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
206
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
206
  auto value = std::chrono::duration<Rep, Period>(rep);
13
206
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
206
    auto buf = fmt::memory_buffer();
18
206
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
206
#endif
20
206
  } catch (std::exception&) {
21
183
  }
22
206
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, int>(fmt::v12::basic_string_view<char>, int)
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
186
  }
22
216
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, int>(fmt::v12::basic_string_view<char>, int)
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
204
  }
22
222
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
243
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
243
  auto value = std::chrono::duration<Rep, Period>(rep);
13
243
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
243
    auto buf = fmt::memory_buffer();
18
243
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
243
#endif
20
243
  } catch (std::exception&) {
21
227
  }
22
243
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, int>(fmt::v12::basic_string_view<char>, int)
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
195
  }
22
220
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, int>(fmt::v12::basic_string_view<char>, int)
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
207
  }
22
224
}
void invoke_inner<std::__1::ratio<1l, 1000l>, int>(fmt::v12::basic_string_view<char>, int)
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
213
  }
22
231
}
void invoke_inner<std::__1::ratio<1l, 100l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
233
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
233
  auto value = std::chrono::duration<Rep, Period>(rep);
13
233
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
233
    auto buf = fmt::memory_buffer();
18
233
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
233
#endif
20
233
  } catch (std::exception&) {
21
220
  }
22
233
}
void invoke_inner<std::__1::ratio<1l, 10l>, int>(fmt::v12::basic_string_view<char>, int)
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
210
  }
22
231
}
void invoke_inner<std::__1::ratio<10l, 1l>, 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
232
  }
22
257
}
void invoke_inner<std::__1::ratio<1000l, 1l>, int>(fmt::v12::basic_string_view<char>, int)
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
264
  }
22
278
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, int>(fmt::v12::basic_string_view<char>, int)
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
261
  }
22
282
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, 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
222
  }
22
244
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, int>(fmt::v12::basic_string_view<char>, int)
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>, int>(fmt::v12::basic_string_view<char>, 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
198
  }
22
213
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, int>(fmt::v12::basic_string_view<char>, int)
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
207
  }
22
221
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
233
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
233
  auto value = std::chrono::duration<Rep, Period>(rep);
13
233
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
233
    auto buf = fmt::memory_buffer();
18
233
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
233
#endif
20
233
  } catch (std::exception&) {
21
211
  }
22
233
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, 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
188
  }
22
209
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
203
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
203
  auto value = std::chrono::duration<Rep, Period>(rep);
13
203
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
203
    auto buf = fmt::memory_buffer();
18
203
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
203
#endif
20
203
  } catch (std::exception&) {
21
180
  }
22
203
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
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, 1000000l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
193
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
193
  auto value = std::chrono::duration<Rep, Period>(rep);
13
193
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
193
    auto buf = fmt::memory_buffer();
18
193
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
193
#endif
20
193
  } catch (std::exception&) {
21
167
  }
22
193
}
void invoke_inner<std::__1::ratio<1l, 1000l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
197
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
197
  auto value = std::chrono::duration<Rep, Period>(rep);
13
197
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
197
    auto buf = fmt::memory_buffer();
18
197
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
197
#endif
20
197
  } catch (std::exception&) {
21
178
  }
22
197
}
void invoke_inner<std::__1::ratio<1l, 100l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
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 int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
194
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
194
  auto value = std::chrono::duration<Rep, Period>(rep);
13
194
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
194
    auto buf = fmt::memory_buffer();
18
194
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
194
#endif
20
194
  } catch (std::exception&) {
21
168
  }
22
194
}
void invoke_inner<std::__1::ratio<10l, 1l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
232
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
232
  auto value = std::chrono::duration<Rep, Period>(rep);
13
232
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
232
    auto buf = fmt::memory_buffer();
18
232
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
232
#endif
20
232
  } catch (std::exception&) {
21
211
  }
22
232
}
void invoke_inner<std::__1::ratio<1000l, 1l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
249
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
249
  auto value = std::chrono::duration<Rep, Period>(rep);
13
249
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
249
    auto buf = fmt::memory_buffer();
18
249
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
249
#endif
20
249
  } catch (std::exception&) {
21
225
  }
22
249
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
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
198
  }
22
223
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
243
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
243
  auto value = std::chrono::duration<Rep, Period>(rep);
13
243
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
243
    auto buf = fmt::memory_buffer();
18
243
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
243
#endif
20
243
  } catch (std::exception&) {
21
220
  }
22
243
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
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<1000000000000000l, 1l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
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
182
  }
22
208
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
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
185
  }
22
211
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
357
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
357
  auto value = std::chrono::duration<Rep, Period>(rep);
13
357
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
357
    auto buf = fmt::memory_buffer();
18
357
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
357
#endif
20
357
  } catch (std::exception&) {
21
328
  }
22
357
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
349
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
349
  auto value = std::chrono::duration<Rep, Period>(rep);
13
349
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
349
    auto buf = fmt::memory_buffer();
18
349
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
349
#endif
20
349
  } catch (std::exception&) {
21
315
  }
22
349
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
330
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
330
  auto value = std::chrono::duration<Rep, Period>(rep);
13
330
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
330
    auto buf = fmt::memory_buffer();
18
330
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
330
#endif
20
330
  } catch (std::exception&) {
21
308
  }
22
330
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
311
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
311
  auto value = std::chrono::duration<Rep, Period>(rep);
13
311
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
311
    auto buf = fmt::memory_buffer();
18
311
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
311
#endif
20
311
  } catch (std::exception&) {
21
290
  }
22
311
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
315
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
315
  auto value = std::chrono::duration<Rep, Period>(rep);
13
315
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
315
    auto buf = fmt::memory_buffer();
18
315
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
315
#endif
20
315
  } catch (std::exception&) {
21
296
  }
22
315
}
void invoke_inner<std::__1::ratio<1l, 1000l>, long>(fmt::v12::basic_string_view<char>, 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
291
  }
22
312
}
void invoke_inner<std::__1::ratio<1l, 100l>, long>(fmt::v12::basic_string_view<char>, long)
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
268
  }
22
299
}
void invoke_inner<std::__1::ratio<1l, 10l>, long>(fmt::v12::basic_string_view<char>, long)
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
258
  }
22
282
}
void invoke_inner<std::__1::ratio<10l, 1l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
317
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
317
  auto value = std::chrono::duration<Rep, Period>(rep);
13
317
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
317
    auto buf = fmt::memory_buffer();
18
317
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
317
#endif
20
317
  } catch (std::exception&) {
21
293
  }
22
317
}
void invoke_inner<std::__1::ratio<1000l, 1l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
325
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
325
  auto value = std::chrono::duration<Rep, Period>(rep);
13
325
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
325
    auto buf = fmt::memory_buffer();
18
325
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
325
#endif
20
325
  } catch (std::exception&) {
21
304
  }
22
325
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, 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
283
  }
22
313
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
311
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
311
  auto value = std::chrono::duration<Rep, Period>(rep);
13
311
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
311
    auto buf = fmt::memory_buffer();
18
311
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
311
#endif
20
311
  } catch (std::exception&) {
21
284
  }
22
311
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
326
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
326
  auto value = std::chrono::duration<Rep, Period>(rep);
13
326
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
326
    auto buf = fmt::memory_buffer();
18
326
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
326
#endif
20
326
  } catch (std::exception&) {
21
306
  }
22
326
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
252
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
252
  auto value = std::chrono::duration<Rep, Period>(rep);
13
252
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
252
    auto buf = fmt::memory_buffer();
18
252
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
252
#endif
20
252
  } catch (std::exception&) {
21
234
  }
22
252
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, long>(fmt::v12::basic_string_view<char>, long)
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<1l, 1000000000000000000l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
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
235
  }
22
255
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
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
216
  }
22
240
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
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
232
  }
22
257
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
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
222
  }
22
247
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
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
221
  }
22
239
}
void invoke_inner<std::__1::ratio<1l, 1000l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
Line
Count
Source
11
248
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
248
  auto value = std::chrono::duration<Rep, Period>(rep);
13
248
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
248
    auto buf = fmt::memory_buffer();
18
248
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
248
#endif
20
248
  } catch (std::exception&) {
21
220
  }
22
248
}
void invoke_inner<std::__1::ratio<1l, 100l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
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
232
  }
22
258
}
void invoke_inner<std::__1::ratio<1l, 10l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
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
212
  }
22
230
}
void invoke_inner<std::__1::ratio<10l, 1l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
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
235
  }
22
258
}
void invoke_inner<std::__1::ratio<1000l, 1l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
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
260
  }
22
286
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
Line
Count
Source
11
256
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
256
  auto value = std::chrono::duration<Rep, Period>(rep);
13
256
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
256
    auto buf = fmt::memory_buffer();
18
256
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
256
#endif
20
256
  } catch (std::exception&) {
21
234
  }
22
256
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
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
253
  }
22
275
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
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
206
  }
22
225
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
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
222
  }
22
244
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
Line
Count
Source
11
243
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
243
  auto value = std::chrono::duration<Rep, Period>(rep);
13
243
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
243
    auto buf = fmt::memory_buffer();
18
243
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
243
#endif
20
243
  } catch (std::exception&) {
21
232
  }
22
243
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, 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, 1000000000000000l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
349
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
349
  auto value = std::chrono::duration<Rep, Period>(rep);
13
349
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
349
    auto buf = fmt::memory_buffer();
18
349
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
349
#endif
20
349
  } catch (std::exception&) {
21
310
  }
22
349
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, 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
334
  }
22
361
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
350
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
350
  auto value = std::chrono::duration<Rep, Period>(rep);
13
350
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
350
    auto buf = fmt::memory_buffer();
18
350
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
350
#endif
20
350
  } catch (std::exception&) {
21
321
  }
22
350
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
336
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
336
  auto value = std::chrono::duration<Rep, Period>(rep);
13
336
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
336
    auto buf = fmt::memory_buffer();
18
336
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
336
#endif
20
336
  } catch (std::exception&) {
21
307
  }
22
336
}
void invoke_inner<std::__1::ratio<1l, 1000l>, 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
329
  }
22
358
}
void invoke_inner<std::__1::ratio<1l, 100l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
347
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
347
  auto value = std::chrono::duration<Rep, Period>(rep);
13
347
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
347
    auto buf = fmt::memory_buffer();
18
347
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
347
#endif
20
347
  } catch (std::exception&) {
21
331
  }
22
347
}
void invoke_inner<std::__1::ratio<1l, 10l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
346
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
346
  auto value = std::chrono::duration<Rep, Period>(rep);
13
346
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
346
    auto buf = fmt::memory_buffer();
18
346
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
346
#endif
20
346
  } catch (std::exception&) {
21
322
  }
22
346
}
void invoke_inner<std::__1::ratio<10l, 1l>, float>(fmt::v12::basic_string_view<char>, float)
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
340
  }
22
363
}
void invoke_inner<std::__1::ratio<1000l, 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
331
  }
22
362
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
327
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
327
  auto value = std::chrono::duration<Rep, Period>(rep);
13
327
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
327
    auto buf = fmt::memory_buffer();
18
327
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
327
#endif
20
327
  } catch (std::exception&) {
21
298
  }
22
327
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
353
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
353
  auto value = std::chrono::duration<Rep, Period>(rep);
13
353
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
353
    auto buf = fmt::memory_buffer();
18
353
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
353
#endif
20
353
  } catch (std::exception&) {
21
324
  }
22
353
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, float>(fmt::v12::basic_string_view<char>, float)
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<1000000000000000l, 1l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
338
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
338
  auto value = std::chrono::duration<Rep, Period>(rep);
13
338
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
338
    auto buf = fmt::memory_buffer();
18
338
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
338
#endif
20
338
  } catch (std::exception&) {
21
319
  }
22
338
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
345
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
345
  auto value = std::chrono::duration<Rep, Period>(rep);
13
345
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
345
    auto buf = fmt::memory_buffer();
18
345
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
345
#endif
20
345
  } catch (std::exception&) {
21
316
  }
22
345
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, double>(fmt::v12::basic_string_view<char>, double)
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
331
  }
22
360
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, double>(fmt::v12::basic_string_view<char>, 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
329
  }
22
364
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
346
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
346
  auto value = std::chrono::duration<Rep, Period>(rep);
13
346
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
346
    auto buf = fmt::memory_buffer();
18
346
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
346
#endif
20
346
  } catch (std::exception&) {
21
318
  }
22
346
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, double>(fmt::v12::basic_string_view<char>, double)
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
313
  }
22
342
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, double>(fmt::v12::basic_string_view<char>, double)
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
298
  }
22
337
}
void invoke_inner<std::__1::ratio<1l, 1000l>, 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
325
  }
22
358
}
void invoke_inner<std::__1::ratio<1l, 100l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
343
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
343
  auto value = std::chrono::duration<Rep, Period>(rep);
13
343
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
343
    auto buf = fmt::memory_buffer();
18
343
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
343
#endif
20
343
  } catch (std::exception&) {
21
307
  }
22
343
}
void invoke_inner<std::__1::ratio<1l, 10l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
341
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
341
  auto value = std::chrono::duration<Rep, Period>(rep);
13
341
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
341
    auto buf = fmt::memory_buffer();
18
341
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
341
#endif
20
341
  } catch (std::exception&) {
21
298
  }
22
341
}
void invoke_inner<std::__1::ratio<10l, 1l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
357
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
357
  auto value = std::chrono::duration<Rep, Period>(rep);
13
357
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
357
    auto buf = fmt::memory_buffer();
18
357
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
357
#endif
20
357
  } catch (std::exception&) {
21
326
  }
22
357
}
void invoke_inner<std::__1::ratio<1000l, 1l>, double>(fmt::v12::basic_string_view<char>, double)
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
322
  }
22
360
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, double>(fmt::v12::basic_string_view<char>, double)
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
298
  }
22
332
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
355
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
355
  auto value = std::chrono::duration<Rep, Period>(rep);
13
355
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
355
    auto buf = fmt::memory_buffer();
18
355
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
355
#endif
20
355
  } catch (std::exception&) {
21
319
  }
22
355
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
344
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
344
  auto value = std::chrono::duration<Rep, Period>(rep);
13
344
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
344
    auto buf = fmt::memory_buffer();
18
344
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
344
#endif
20
344
  } catch (std::exception&) {
21
321
  }
22
344
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
353
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
353
  auto value = std::chrono::duration<Rep, Period>(rep);
13
353
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
353
    auto buf = fmt::memory_buffer();
18
353
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
353
#endif
20
353
  } catch (std::exception&) {
21
321
  }
22
353
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, double>(fmt::v12::basic_string_view<char>, double)
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
283
  }
22
332
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
371
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
371
  auto value = std::chrono::duration<Rep, Period>(rep);
13
371
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
371
    auto buf = fmt::memory_buffer();
18
371
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
371
#endif
20
371
  } catch (std::exception&) {
21
334
  }
22
371
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
359
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
359
  auto value = std::chrono::duration<Rep, Period>(rep);
13
359
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
359
    auto buf = fmt::memory_buffer();
18
359
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
359
#endif
20
359
  } catch (std::exception&) {
21
322
  }
22
359
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
344
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
344
  auto value = std::chrono::duration<Rep, Period>(rep);
13
344
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
344
    auto buf = fmt::memory_buffer();
18
344
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
344
#endif
20
344
  } catch (std::exception&) {
21
304
  }
22
344
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
347
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
347
  auto value = std::chrono::duration<Rep, Period>(rep);
13
347
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
347
    auto buf = fmt::memory_buffer();
18
347
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
347
#endif
20
347
  } catch (std::exception&) {
21
320
  }
22
347
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
346
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
346
  auto value = std::chrono::duration<Rep, Period>(rep);
13
346
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
346
    auto buf = fmt::memory_buffer();
18
346
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
346
#endif
20
346
  } catch (std::exception&) {
21
317
  }
22
346
}
void invoke_inner<std::__1::ratio<1l, 1000l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
346
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
346
  auto value = std::chrono::duration<Rep, Period>(rep);
13
346
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
346
    auto buf = fmt::memory_buffer();
18
346
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
346
#endif
20
346
  } catch (std::exception&) {
21
313
  }
22
346
}
void invoke_inner<std::__1::ratio<1l, 100l>, 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
335
  }
22
364
}
void invoke_inner<std::__1::ratio<1l, 10l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
347
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
347
  auto value = std::chrono::duration<Rep, Period>(rep);
13
347
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
347
    auto buf = fmt::memory_buffer();
18
347
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
347
#endif
20
347
  } catch (std::exception&) {
21
312
  }
22
347
}
void invoke_inner<std::__1::ratio<10l, 1l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
349
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
349
  auto value = std::chrono::duration<Rep, Period>(rep);
13
349
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
349
    auto buf = fmt::memory_buffer();
18
349
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
349
#endif
20
349
  } catch (std::exception&) {
21
327
  }
22
349
}
void invoke_inner<std::__1::ratio<1000l, 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
341
  }
22
368
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
351
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
351
  auto value = std::chrono::duration<Rep, Period>(rep);
13
351
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
351
    auto buf = fmt::memory_buffer();
18
351
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
351
#endif
20
351
  } catch (std::exception&) {
21
322
  }
22
351
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, long double>(fmt::v12::basic_string_view<char>, long 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
330
  }
22
363
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
339
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
339
  auto value = std::chrono::duration<Rep, Period>(rep);
13
339
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
339
    auto buf = fmt::memory_buffer();
18
339
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
339
#endif
20
339
  } catch (std::exception&) {
21
305
  }
22
339
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
354
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
354
  auto value = std::chrono::duration<Rep, Period>(rep);
13
354
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
354
    auto buf = fmt::memory_buffer();
18
354
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
354
#endif
20
354
  } catch (std::exception&) {
21
327
  }
22
354
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, long double>(fmt::v12::basic_string_view<char>, long double)
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
280
  }
22
342
}
23
24
// Rep is a duration's representation type.
25
template <typename Rep>
26
47.1k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
47.1k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
47.1k
  if (size <= fixed_size + 1) return;
30
31
47.1k
  const Rep rep = assign_from_buf<Rep>(data);
32
47.1k
  data += fixed_size;
33
47.1k
  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
47.1k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
47.1k
  switch (period) {
41
3.21k
  case 1:
42
3.21k
    invoke_inner<std::atto>(format_str, rep);
43
3.21k
    break;
44
3.12k
  case 2:
45
3.12k
    invoke_inner<std::femto>(format_str, rep);
46
3.12k
    break;
47
3.09k
  case 3:
48
3.09k
    invoke_inner<std::pico>(format_str, rep);
49
3.09k
    break;
50
3.04k
  case 4:
51
3.04k
    invoke_inner<std::nano>(format_str, rep);
52
3.04k
    break;
53
3.00k
  case 5:
54
3.00k
    invoke_inner<std::micro>(format_str, rep);
55
3.00k
    break;
56
3.08k
  case 6:
57
3.08k
    invoke_inner<std::milli>(format_str, rep);
58
3.08k
    break;
59
3.01k
  case 7:
60
3.01k
    invoke_inner<std::centi>(format_str, rep);
61
3.01k
    break;
62
2.97k
  case 8:
63
2.97k
    invoke_inner<std::deci>(format_str, rep);
64
2.97k
    break;
65
3.38k
  case 9:
66
3.38k
    invoke_inner<std::deca>(format_str, rep);
67
3.38k
    break;
68
3.47k
  case 10:
69
3.47k
    invoke_inner<std::kilo>(format_str, rep);
70
3.47k
    break;
71
3.29k
  case 11:
72
3.29k
    invoke_inner<std::mega>(format_str, rep);
73
3.29k
    break;
74
3.34k
  case 12:
75
3.34k
    invoke_inner<std::giga>(format_str, rep);
76
3.34k
    break;
77
3.05k
  case 13:
78
3.05k
    invoke_inner<std::tera>(format_str, rep);
79
3.05k
    break;
80
3.00k
  case 14:
81
3.00k
    invoke_inner<std::peta>(format_str, rep);
82
3.00k
    break;
83
2.98k
  case 15:
84
2.98k
    invoke_inner<std::exa>(format_str, rep);
85
2.98k
    break;
86
47.1k
  }
87
47.1k
}
void invoke_outer<char>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
3.26k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
3.26k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
3.26k
  if (size <= fixed_size + 1) return;
30
31
3.26k
  const Rep rep = assign_from_buf<Rep>(data);
32
3.26k
  data += fixed_size;
33
3.26k
  size -= fixed_size;
34
35
  // data is already allocated separately in libFuzzer so reading past the end
36
  // will most likely be detected anyway.
37
3.26k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
3.26k
  switch (period) {
41
219
  case 1:
42
219
    invoke_inner<std::atto>(format_str, rep);
43
219
    break;
44
222
  case 2:
45
222
    invoke_inner<std::femto>(format_str, rep);
46
222
    break;
47
203
  case 3:
48
203
    invoke_inner<std::pico>(format_str, rep);
49
203
    break;
50
194
  case 4:
51
194
    invoke_inner<std::nano>(format_str, rep);
52
194
    break;
53
222
  case 5:
54
222
    invoke_inner<std::micro>(format_str, rep);
55
222
    break;
56
200
  case 6:
57
200
    invoke_inner<std::milli>(format_str, rep);
58
200
    break;
59
204
  case 7:
60
204
    invoke_inner<std::centi>(format_str, rep);
61
204
    break;
62
194
  case 8:
63
194
    invoke_inner<std::deci>(format_str, rep);
64
194
    break;
65
245
  case 9:
66
245
    invoke_inner<std::deca>(format_str, rep);
67
245
    break;
68
259
  case 10:
69
259
    invoke_inner<std::kilo>(format_str, rep);
70
259
    break;
71
245
  case 11:
72
245
    invoke_inner<std::mega>(format_str, rep);
73
245
    break;
74
244
  case 12:
75
244
    invoke_inner<std::giga>(format_str, rep);
76
244
    break;
77
193
  case 13:
78
193
    invoke_inner<std::tera>(format_str, rep);
79
193
    break;
80
204
  case 14:
81
204
    invoke_inner<std::peta>(format_str, rep);
82
204
    break;
83
211
  case 15:
84
211
    invoke_inner<std::exa>(format_str, rep);
85
211
    break;
86
3.26k
  }
87
3.26k
}
void invoke_outer<signed char>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
3.34k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
3.34k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
3.34k
  if (size <= fixed_size + 1) return;
30
31
3.34k
  const Rep rep = assign_from_buf<Rep>(data);
32
3.34k
  data += fixed_size;
33
3.34k
  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.34k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
3.34k
  switch (period) {
41
221
  case 1:
42
221
    invoke_inner<std::atto>(format_str, rep);
43
221
    break;
44
215
  case 2:
45
215
    invoke_inner<std::femto>(format_str, rep);
46
215
    break;
47
207
  case 3:
48
207
    invoke_inner<std::pico>(format_str, rep);
49
207
    break;
50
222
  case 4:
51
222
    invoke_inner<std::nano>(format_str, rep);
52
222
    break;
53
204
  case 5:
54
204
    invoke_inner<std::micro>(format_str, rep);
55
204
    break;
56
213
  case 6:
57
213
    invoke_inner<std::milli>(format_str, rep);
58
213
    break;
59
210
  case 7:
60
210
    invoke_inner<std::centi>(format_str, rep);
61
210
    break;
62
219
  case 8:
63
219
    invoke_inner<std::deci>(format_str, rep);
64
219
    break;
65
281
  case 9:
66
281
    invoke_inner<std::deca>(format_str, rep);
67
281
    break;
68
239
  case 10:
69
239
    invoke_inner<std::kilo>(format_str, rep);
70
239
    break;
71
253
  case 11:
72
253
    invoke_inner<std::mega>(format_str, rep);
73
253
    break;
74
263
  case 12:
75
263
    invoke_inner<std::giga>(format_str, rep);
76
263
    break;
77
200
  case 13:
78
200
    invoke_inner<std::tera>(format_str, rep);
79
200
    break;
80
206
  case 14:
81
206
    invoke_inner<std::peta>(format_str, rep);
82
206
    break;
83
189
  case 15:
84
189
    invoke_inner<std::exa>(format_str, rep);
85
189
    break;
86
3.34k
  }
87
3.34k
}
void invoke_outer<unsigned char>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
3.10k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
3.10k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
3.10k
  if (size <= fixed_size + 1) return;
30
31
3.10k
  const Rep rep = assign_from_buf<Rep>(data);
32
3.10k
  data += fixed_size;
33
3.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
3.10k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
3.10k
  switch (period) {
41
194
  case 1:
42
194
    invoke_inner<std::atto>(format_str, rep);
43
194
    break;
44
197
  case 2:
45
197
    invoke_inner<std::femto>(format_str, rep);
46
197
    break;
47
196
  case 3:
48
196
    invoke_inner<std::pico>(format_str, rep);
49
196
    break;
50
198
  case 4:
51
198
    invoke_inner<std::nano>(format_str, rep);
52
198
    break;
53
191
  case 5:
54
191
    invoke_inner<std::micro>(format_str, rep);
55
191
    break;
56
193
  case 6:
57
193
    invoke_inner<std::milli>(format_str, rep);
58
193
    break;
59
181
  case 7:
60
181
    invoke_inner<std::centi>(format_str, rep);
61
181
    break;
62
191
  case 8:
63
191
    invoke_inner<std::deci>(format_str, rep);
64
191
    break;
65
234
  case 9:
66
234
    invoke_inner<std::deca>(format_str, rep);
67
234
    break;
68
253
  case 10:
69
253
    invoke_inner<std::kilo>(format_str, rep);
70
253
    break;
71
234
  case 11:
72
234
    invoke_inner<std::mega>(format_str, rep);
73
234
    break;
74
225
  case 12:
75
225
    invoke_inner<std::giga>(format_str, rep);
76
225
    break;
77
206
  case 13:
78
206
    invoke_inner<std::tera>(format_str, rep);
79
206
    break;
80
201
  case 14:
81
201
    invoke_inner<std::peta>(format_str, rep);
82
201
    break;
83
205
  case 15:
84
205
    invoke_inner<std::exa>(format_str, rep);
85
205
    break;
86
3.10k
  }
87
3.10k
}
void invoke_outer<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
233
  case 1:
42
233
    invoke_inner<std::atto>(format_str, rep);
43
233
    break;
44
211
  case 2:
45
211
    invoke_inner<std::femto>(format_str, rep);
46
211
    break;
47
207
  case 3:
48
207
    invoke_inner<std::pico>(format_str, rep);
49
207
    break;
50
219
  case 4:
51
219
    invoke_inner<std::nano>(format_str, rep);
52
219
    break;
53
204
  case 5:
54
204
    invoke_inner<std::micro>(format_str, rep);
55
204
    break;
56
228
  case 6:
57
228
    invoke_inner<std::milli>(format_str, rep);
58
228
    break;
59
207
  case 7:
60
207
    invoke_inner<std::centi>(format_str, rep);
61
207
    break;
62
210
  case 8:
63
210
    invoke_inner<std::deci>(format_str, rep);
64
210
    break;
65
245
  case 9:
66
245
    invoke_inner<std::deca>(format_str, rep);
67
245
    break;
68
250
  case 10:
69
250
    invoke_inner<std::kilo>(format_str, rep);
70
250
    break;
71
249
  case 11:
72
249
    invoke_inner<std::mega>(format_str, rep);
73
249
    break;
74
240
  case 12:
75
240
    invoke_inner<std::giga>(format_str, rep);
76
240
    break;
77
218
  case 13:
78
218
    invoke_inner<std::tera>(format_str, rep);
79
218
    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<unsigned short>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
3.11k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
3.11k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
3.11k
  if (size <= fixed_size + 1) return;
30
31
3.11k
  const Rep rep = assign_from_buf<Rep>(data);
32
3.11k
  data += fixed_size;
33
3.11k
  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.11k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
3.11k
  switch (period) {
41
197
  case 1:
42
197
    invoke_inner<std::atto>(format_str, rep);
43
197
    break;
44
190
  case 2:
45
190
    invoke_inner<std::femto>(format_str, rep);
46
190
    break;
47
197
  case 3:
48
197
    invoke_inner<std::pico>(format_str, rep);
49
197
    break;
50
189
  case 4:
51
189
    invoke_inner<std::nano>(format_str, rep);
52
189
    break;
53
196
  case 5:
54
196
    invoke_inner<std::micro>(format_str, rep);
55
196
    break;
56
204
  case 6:
57
204
    invoke_inner<std::milli>(format_str, rep);
58
204
    break;
59
175
  case 7:
60
175
    invoke_inner<std::centi>(format_str, rep);
61
175
    break;
62
191
  case 8:
63
191
    invoke_inner<std::deci>(format_str, rep);
64
191
    break;
65
247
  case 9:
66
247
    invoke_inner<std::deca>(format_str, rep);
67
247
    break;
68
242
  case 10:
69
242
    invoke_inner<std::kilo>(format_str, rep);
70
242
    break;
71
230
  case 11:
72
230
    invoke_inner<std::mega>(format_str, rep);
73
230
    break;
74
224
  case 12:
75
224
    invoke_inner<std::giga>(format_str, rep);
76
224
    break;
77
214
  case 13:
78
214
    invoke_inner<std::tera>(format_str, rep);
79
214
    break;
80
212
  case 14:
81
212
    invoke_inner<std::peta>(format_str, rep);
82
212
    break;
83
206
  case 15:
84
206
    invoke_inner<std::exa>(format_str, rep);
85
206
    break;
86
3.11k
  }
87
3.11k
}
void invoke_outer<int>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
3.53k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
3.53k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
3.53k
  if (size <= fixed_size + 1) return;
30
31
3.53k
  const Rep rep = assign_from_buf<Rep>(data);
32
3.53k
  data += fixed_size;
33
3.53k
  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.53k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
3.53k
  switch (period) {
41
216
  case 1:
42
216
    invoke_inner<std::atto>(format_str, rep);
43
216
    break;
44
222
  case 2:
45
222
    invoke_inner<std::femto>(format_str, rep);
46
222
    break;
47
243
  case 3:
48
243
    invoke_inner<std::pico>(format_str, rep);
49
243
    break;
50
220
  case 4:
51
220
    invoke_inner<std::nano>(format_str, rep);
52
220
    break;
53
224
  case 5:
54
224
    invoke_inner<std::micro>(format_str, rep);
55
224
    break;
56
231
  case 6:
57
231
    invoke_inner<std::milli>(format_str, rep);
58
231
    break;
59
233
  case 7:
60
233
    invoke_inner<std::centi>(format_str, rep);
61
233
    break;
62
231
  case 8:
63
231
    invoke_inner<std::deci>(format_str, rep);
64
231
    break;
65
257
  case 9:
66
257
    invoke_inner<std::deca>(format_str, rep);
67
257
    break;
68
278
  case 10:
69
278
    invoke_inner<std::kilo>(format_str, rep);
70
278
    break;
71
282
  case 11:
72
282
    invoke_inner<std::mega>(format_str, rep);
73
282
    break;
74
244
  case 12:
75
244
    invoke_inner<std::giga>(format_str, rep);
76
244
    break;
77
218
  case 13:
78
218
    invoke_inner<std::tera>(format_str, rep);
79
218
    break;
80
213
  case 14:
81
213
    invoke_inner<std::peta>(format_str, rep);
82
213
    break;
83
221
  case 15:
84
221
    invoke_inner<std::exa>(format_str, rep);
85
221
    break;
86
3.53k
  }
87
3.53k
}
void invoke_outer<unsigned int>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
3.20k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
3.20k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
3.20k
  if (size <= fixed_size + 1) return;
30
31
3.20k
  const Rep rep = assign_from_buf<Rep>(data);
32
3.20k
  data += fixed_size;
33
3.20k
  size -= fixed_size;
34
35
  // data is already allocated separately in libFuzzer so reading past the end
36
  // will most likely be detected anyway.
37
3.20k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
3.20k
  switch (period) {
41
233
  case 1:
42
233
    invoke_inner<std::atto>(format_str, rep);
43
233
    break;
44
209
  case 2:
45
209
    invoke_inner<std::femto>(format_str, rep);
46
209
    break;
47
203
  case 3:
48
203
    invoke_inner<std::pico>(format_str, rep);
49
203
    break;
50
210
  case 4:
51
210
    invoke_inner<std::nano>(format_str, rep);
52
210
    break;
53
193
  case 5:
54
193
    invoke_inner<std::micro>(format_str, rep);
55
193
    break;
56
197
  case 6:
57
197
    invoke_inner<std::milli>(format_str, rep);
58
197
    break;
59
189
  case 7:
60
189
    invoke_inner<std::centi>(format_str, rep);
61
189
    break;
62
194
  case 8:
63
194
    invoke_inner<std::deci>(format_str, rep);
64
194
    break;
65
232
  case 9:
66
232
    invoke_inner<std::deca>(format_str, rep);
67
232
    break;
68
249
  case 10:
69
249
    invoke_inner<std::kilo>(format_str, rep);
70
249
    break;
71
223
  case 11:
72
223
    invoke_inner<std::mega>(format_str, rep);
73
223
    break;
74
243
  case 12:
75
243
    invoke_inner<std::giga>(format_str, rep);
76
243
    break;
77
207
  case 13:
78
207
    invoke_inner<std::tera>(format_str, rep);
79
207
    break;
80
208
  case 14:
81
208
    invoke_inner<std::peta>(format_str, rep);
82
208
    break;
83
211
  case 15:
84
211
    invoke_inner<std::exa>(format_str, rep);
85
211
    break;
86
3.20k
  }
87
3.20k
}
void invoke_outer<long>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
4.66k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
4.66k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
4.66k
  if (size <= fixed_size + 1) return;
30
31
4.66k
  const Rep rep = assign_from_buf<Rep>(data);
32
4.66k
  data += fixed_size;
33
4.66k
  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.66k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
4.66k
  switch (period) {
41
357
  case 1:
42
357
    invoke_inner<std::atto>(format_str, rep);
43
357
    break;
44
349
  case 2:
45
349
    invoke_inner<std::femto>(format_str, rep);
46
349
    break;
47
330
  case 3:
48
330
    invoke_inner<std::pico>(format_str, rep);
49
330
    break;
50
311
  case 4:
51
311
    invoke_inner<std::nano>(format_str, rep);
52
311
    break;
53
315
  case 5:
54
315
    invoke_inner<std::micro>(format_str, rep);
55
315
    break;
56
312
  case 6:
57
312
    invoke_inner<std::milli>(format_str, rep);
58
312
    break;
59
299
  case 7:
60
299
    invoke_inner<std::centi>(format_str, rep);
61
299
    break;
62
282
  case 8:
63
282
    invoke_inner<std::deci>(format_str, rep);
64
282
    break;
65
317
  case 9:
66
317
    invoke_inner<std::deca>(format_str, rep);
67
317
    break;
68
325
  case 10:
69
325
    invoke_inner<std::kilo>(format_str, rep);
70
325
    break;
71
313
  case 11:
72
313
    invoke_inner<std::mega>(format_str, rep);
73
313
    break;
74
311
  case 12:
75
311
    invoke_inner<std::giga>(format_str, rep);
76
311
    break;
77
326
  case 13:
78
326
    invoke_inner<std::tera>(format_str, rep);
79
326
    break;
80
252
  case 14:
81
252
    invoke_inner<std::peta>(format_str, rep);
82
252
    break;
83
267
  case 15:
84
267
    invoke_inner<std::exa>(format_str, rep);
85
267
    break;
86
4.66k
  }
87
4.66k
}
void invoke_outer<unsigned long>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
3.76k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
3.76k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
3.76k
  if (size <= fixed_size + 1) return;
30
31
3.76k
  const Rep rep = assign_from_buf<Rep>(data);
32
3.76k
  data += fixed_size;
33
3.76k
  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.76k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
3.76k
  switch (period) {
41
255
  case 1:
42
255
    invoke_inner<std::atto>(format_str, rep);
43
255
    break;
44
240
  case 2:
45
240
    invoke_inner<std::femto>(format_str, rep);
46
240
    break;
47
257
  case 3:
48
257
    invoke_inner<std::pico>(format_str, rep);
49
257
    break;
50
247
  case 4:
51
247
    invoke_inner<std::nano>(format_str, rep);
52
247
    break;
53
239
  case 5:
54
239
    invoke_inner<std::micro>(format_str, rep);
55
239
    break;
56
248
  case 6:
57
248
    invoke_inner<std::milli>(format_str, rep);
58
248
    break;
59
258
  case 7:
60
258
    invoke_inner<std::centi>(format_str, rep);
61
258
    break;
62
230
  case 8:
63
230
    invoke_inner<std::deci>(format_str, rep);
64
230
    break;
65
258
  case 9:
66
258
    invoke_inner<std::deca>(format_str, rep);
67
258
    break;
68
286
  case 10:
69
286
    invoke_inner<std::kilo>(format_str, rep);
70
286
    break;
71
256
  case 11:
72
256
    invoke_inner<std::mega>(format_str, rep);
73
256
    break;
74
275
  case 12:
75
275
    invoke_inner<std::giga>(format_str, rep);
76
275
    break;
77
225
  case 13:
78
225
    invoke_inner<std::tera>(format_str, rep);
79
225
    break;
80
244
  case 14:
81
244
    invoke_inner<std::peta>(format_str, rep);
82
244
    break;
83
243
  case 15:
84
243
    invoke_inner<std::exa>(format_str, rep);
85
243
    break;
86
3.76k
  }
87
3.76k
}
void invoke_outer<float>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
5.26k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
5.26k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
5.26k
  if (size <= fixed_size + 1) return;
30
31
5.26k
  const Rep rep = assign_from_buf<Rep>(data);
32
5.26k
  data += fixed_size;
33
5.26k
  size -= fixed_size;
34
35
  // data is already allocated separately in libFuzzer so reading past the end
36
  // will most likely be detected anyway.
37
5.26k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
5.26k
  switch (period) {
41
358
  case 1:
42
358
    invoke_inner<std::atto>(format_str, rep);
43
358
    break;
44
349
  case 2:
45
349
    invoke_inner<std::femto>(format_str, rep);
46
349
    break;
47
361
  case 3:
48
361
    invoke_inner<std::pico>(format_str, rep);
49
361
    break;
50
350
  case 4:
51
350
    invoke_inner<std::nano>(format_str, rep);
52
350
    break;
53
336
  case 5:
54
336
    invoke_inner<std::micro>(format_str, rep);
55
336
    break;
56
358
  case 6:
57
358
    invoke_inner<std::milli>(format_str, rep);
58
358
    break;
59
347
  case 7:
60
347
    invoke_inner<std::centi>(format_str, rep);
61
347
    break;
62
346
  case 8:
63
346
    invoke_inner<std::deci>(format_str, rep);
64
346
    break;
65
363
  case 9:
66
363
    invoke_inner<std::deca>(format_str, rep);
67
363
    break;
68
362
  case 10:
69
362
    invoke_inner<std::kilo>(format_str, rep);
70
362
    break;
71
327
  case 11:
72
327
    invoke_inner<std::mega>(format_str, rep);
73
327
    break;
74
353
  case 12:
75
353
    invoke_inner<std::giga>(format_str, rep);
76
353
    break;
77
367
  case 13:
78
367
    invoke_inner<std::tera>(format_str, rep);
79
367
    break;
80
338
  case 14:
81
338
    invoke_inner<std::peta>(format_str, rep);
82
338
    break;
83
345
  case 15:
84
345
    invoke_inner<std::exa>(format_str, rep);
85
345
    break;
86
5.26k
  }
87
5.26k
}
void invoke_outer<double>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
5.23k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
5.23k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
5.23k
  if (size <= fixed_size + 1) return;
30
31
5.22k
  const Rep rep = assign_from_buf<Rep>(data);
32
5.22k
  data += fixed_size;
33
5.22k
  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.22k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
5.22k
  switch (period) {
41
360
  case 1:
42
360
    invoke_inner<std::atto>(format_str, rep);
43
360
    break;
44
364
  case 2:
45
364
    invoke_inner<std::femto>(format_str, rep);
46
364
    break;
47
346
  case 3:
48
346
    invoke_inner<std::pico>(format_str, rep);
49
346
    break;
50
342
  case 4:
51
342
    invoke_inner<std::nano>(format_str, rep);
52
342
    break;
53
337
  case 5:
54
337
    invoke_inner<std::micro>(format_str, rep);
55
337
    break;
56
358
  case 6:
57
358
    invoke_inner<std::milli>(format_str, rep);
58
358
    break;
59
343
  case 7:
60
343
    invoke_inner<std::centi>(format_str, rep);
61
343
    break;
62
341
  case 8:
63
341
    invoke_inner<std::deci>(format_str, rep);
64
341
    break;
65
357
  case 9:
66
357
    invoke_inner<std::deca>(format_str, rep);
67
357
    break;
68
360
  case 10:
69
360
    invoke_inner<std::kilo>(format_str, rep);
70
360
    break;
71
332
  case 11:
72
332
    invoke_inner<std::mega>(format_str, rep);
73
332
    break;
74
355
  case 12:
75
355
    invoke_inner<std::giga>(format_str, rep);
76
355
    break;
77
344
  case 13:
78
344
    invoke_inner<std::tera>(format_str, rep);
79
344
    break;
80
353
  case 14:
81
353
    invoke_inner<std::peta>(format_str, rep);
82
353
    break;
83
332
  case 15:
84
332
    invoke_inner<std::exa>(format_str, rep);
85
332
    break;
86
5.22k
  }
87
5.22k
}
void invoke_outer<long double>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
5.29k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
5.29k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
5.29k
  if (size <= fixed_size + 1) return;
30
31
5.29k
  const Rep rep = assign_from_buf<Rep>(data);
32
5.29k
  data += fixed_size;
33
5.29k
  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.29k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
5.29k
  switch (period) {
41
371
  case 1:
42
371
    invoke_inner<std::atto>(format_str, rep);
43
371
    break;
44
359
  case 2:
45
359
    invoke_inner<std::femto>(format_str, rep);
46
359
    break;
47
344
  case 3:
48
344
    invoke_inner<std::pico>(format_str, rep);
49
344
    break;
50
347
  case 4:
51
347
    invoke_inner<std::nano>(format_str, rep);
52
347
    break;
53
346
  case 5:
54
346
    invoke_inner<std::micro>(format_str, rep);
55
346
    break;
56
346
  case 6:
57
346
    invoke_inner<std::milli>(format_str, rep);
58
346
    break;
59
364
  case 7:
60
364
    invoke_inner<std::centi>(format_str, rep);
61
364
    break;
62
347
  case 8:
63
347
    invoke_inner<std::deci>(format_str, rep);
64
347
    break;
65
349
  case 9:
66
349
    invoke_inner<std::deca>(format_str, rep);
67
349
    break;
68
368
  case 10:
69
368
    invoke_inner<std::kilo>(format_str, rep);
70
368
    break;
71
351
  case 11:
72
351
    invoke_inner<std::mega>(format_str, rep);
73
351
    break;
74
363
  case 12:
75
363
    invoke_inner<std::giga>(format_str, rep);
76
363
    break;
77
339
  case 13:
78
339
    invoke_inner<std::tera>(format_str, rep);
79
339
    break;
80
354
  case 14:
81
354
    invoke_inner<std::peta>(format_str, rep);
82
354
    break;
83
342
  case 15:
84
342
    invoke_inner<std::exa>(format_str, rep);
85
342
    break;
86
5.29k
  }
87
5.29k
}
88
89
47.1k
extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
90
47.1k
  if (size <= 4) return 0;
91
92
47.1k
  const auto representation = data[0];
93
47.1k
  const auto period = data[1];
94
47.1k
  data += 2;
95
47.1k
  size -= 2;
96
97
47.1k
  switch (representation) {
98
3.26k
  case 1:
99
3.26k
    invoke_outer<char>(data, size, period);
100
3.26k
    break;
101
3.34k
  case 2:
102
3.34k
    invoke_outer<signed char>(data, size, period);
103
3.34k
    break;
104
3.10k
  case 3:
105
3.10k
    invoke_outer<unsigned char>(data, size, period);
106
3.10k
    break;
107
3.35k
  case 4:
108
3.35k
    invoke_outer<short>(data, size, period);
109
3.35k
    break;
110
3.11k
  case 5:
111
3.11k
    invoke_outer<unsigned short>(data, size, period);
112
3.11k
    break;
113
3.53k
  case 6:
114
3.53k
    invoke_outer<int>(data, size, period);
115
3.53k
    break;
116
3.20k
  case 7:
117
3.20k
    invoke_outer<unsigned int>(data, size, period);
118
3.20k
    break;
119
4.66k
  case 8:
120
4.66k
    invoke_outer<long>(data, size, period);
121
4.66k
    break;
122
3.76k
  case 9:
123
3.76k
    invoke_outer<unsigned long>(data, size, period);
124
3.76k
    break;
125
5.26k
  case 10:
126
5.26k
    invoke_outer<float>(data, size, period);
127
5.26k
    break;
128
5.23k
  case 11:
129
5.23k
    invoke_outer<double>(data, size, period);
130
5.23k
    break;
131
5.29k
  case 12:
132
5.29k
    invoke_outer<long double>(data, size, period);
133
5.29k
    break;
134
47.1k
  }
135
47.1k
  return 0;
136
47.1k
}