Coverage Report

Created: 2026-05-14 06:08

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
43.7k
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
43.7k
  auto value = std::chrono::duration<Rep, Period>(rep);
13
43.7k
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
43.7k
    auto buf = fmt::memory_buffer();
18
43.7k
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
43.7k
#endif
20
43.7k
  } catch (std::exception&) {
21
39.6k
  }
22
43.7k
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, 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
174
  }
22
193
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, 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
183
  }
22
200
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, char>(fmt::v12::basic_string_view<char>, char)
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
157
  }
22
175
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
182
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
182
  auto value = std::chrono::duration<Rep, Period>(rep);
13
182
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
182
    auto buf = fmt::memory_buffer();
18
182
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
182
#endif
20
182
  } catch (std::exception&) {
21
159
  }
22
182
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, char>(fmt::v12::basic_string_view<char>, char)
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, 1000l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
183
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
183
  auto value = std::chrono::duration<Rep, Period>(rep);
13
183
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
183
    auto buf = fmt::memory_buffer();
18
183
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
183
#endif
20
183
  } catch (std::exception&) {
21
160
  }
22
183
}
void invoke_inner<std::__1::ratio<1l, 100l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
185
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
185
  auto value = std::chrono::duration<Rep, Period>(rep);
13
185
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
185
    auto buf = fmt::memory_buffer();
18
185
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
185
#endif
20
185
  } catch (std::exception&) {
21
172
  }
22
185
}
void invoke_inner<std::__1::ratio<1l, 10l>, char>(fmt::v12::basic_string_view<char>, 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
173
  }
22
191
}
void invoke_inner<std::__1::ratio<10l, 1l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
236
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
236
  auto value = std::chrono::duration<Rep, Period>(rep);
13
236
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
236
    auto buf = fmt::memory_buffer();
18
236
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
236
#endif
20
236
  } catch (std::exception&) {
21
207
  }
22
236
}
void invoke_inner<std::__1::ratio<1000l, 1l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
255
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
255
  auto value = std::chrono::duration<Rep, Period>(rep);
13
255
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
255
    auto buf = fmt::memory_buffer();
18
255
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
255
#endif
20
255
  } catch (std::exception&) {
21
236
  }
22
255
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
237
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
237
  auto value = std::chrono::duration<Rep, Period>(rep);
13
237
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
237
    auto buf = fmt::memory_buffer();
18
237
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
237
#endif
20
237
  } catch (std::exception&) {
21
201
  }
22
237
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, 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
197
  }
22
219
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
188
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
188
  auto value = std::chrono::duration<Rep, Period>(rep);
13
188
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
188
    auto buf = fmt::memory_buffer();
18
188
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
188
#endif
20
188
  } catch (std::exception&) {
21
169
  }
22
188
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
192
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
192
  auto value = std::chrono::duration<Rep, Period>(rep);
13
192
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
192
    auto buf = fmt::memory_buffer();
18
192
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
192
#endif
20
192
  } catch (std::exception&) {
21
171
  }
22
192
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, char>(fmt::v12::basic_string_view<char>, char)
Line
Count
Source
11
188
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
188
  auto value = std::chrono::duration<Rep, Period>(rep);
13
188
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
188
    auto buf = fmt::memory_buffer();
18
188
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
188
#endif
20
188
  } catch (std::exception&) {
21
172
  }
22
188
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, signed char>(fmt::v12::basic_string_view<char>, signed 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
174
  }
22
194
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, signed char>(fmt::v12::basic_string_view<char>, signed 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
173
  }
22
201
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
171
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
171
  auto value = std::chrono::duration<Rep, Period>(rep);
13
171
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
171
    auto buf = fmt::memory_buffer();
18
171
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
171
#endif
20
171
  } catch (std::exception&) {
21
157
  }
22
171
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, signed char>(fmt::v12::basic_string_view<char>, signed 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
189
  }
22
198
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
188
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
188
  auto value = std::chrono::duration<Rep, Period>(rep);
13
188
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
188
    auto buf = fmt::memory_buffer();
18
188
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
188
#endif
20
188
  } catch (std::exception&) {
21
167
  }
22
188
}
void invoke_inner<std::__1::ratio<1l, 1000l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
174
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
174
  auto value = std::chrono::duration<Rep, Period>(rep);
13
174
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
174
    auto buf = fmt::memory_buffer();
18
174
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
174
#endif
20
174
  } catch (std::exception&) {
21
159
  }
22
174
}
void invoke_inner<std::__1::ratio<1l, 100l>, signed char>(fmt::v12::basic_string_view<char>, signed 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
188
  }
22
203
}
void invoke_inner<std::__1::ratio<1l, 10l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
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
169
  }
22
190
}
void invoke_inner<std::__1::ratio<10l, 1l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
235
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
235
  auto value = std::chrono::duration<Rep, Period>(rep);
13
235
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
235
    auto buf = fmt::memory_buffer();
18
235
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
235
#endif
20
235
  } catch (std::exception&) {
21
218
  }
22
235
}
void invoke_inner<std::__1::ratio<1000l, 1l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
230
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
230
  auto value = std::chrono::duration<Rep, Period>(rep);
13
230
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
230
    auto buf = fmt::memory_buffer();
18
230
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
230
#endif
20
230
  } catch (std::exception&) {
21
209
  }
22
230
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
236
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
236
  auto value = std::chrono::duration<Rep, Period>(rep);
13
236
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
236
    auto buf = fmt::memory_buffer();
18
236
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
236
#endif
20
236
  } catch (std::exception&) {
21
215
  }
22
236
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
246
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
246
  auto value = std::chrono::duration<Rep, Period>(rep);
13
246
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
246
    auto buf = fmt::memory_buffer();
18
246
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
246
#endif
20
246
  } catch (std::exception&) {
21
229
  }
22
246
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
Line
Count
Source
11
205
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
205
  auto value = std::chrono::duration<Rep, Period>(rep);
13
205
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
205
    auto buf = fmt::memory_buffer();
18
205
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
205
#endif
20
205
  } catch (std::exception&) {
21
185
  }
22
205
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, signed char>(fmt::v12::basic_string_view<char>, signed char)
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<1000000000000000000l, 1l>, signed char>(fmt::v12::basic_string_view<char>, signed 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
166
  }
22
181
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
178
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
178
  auto value = std::chrono::duration<Rep, Period>(rep);
13
178
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
178
    auto buf = fmt::memory_buffer();
18
178
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
178
#endif
20
178
  } catch (std::exception&) {
21
158
  }
22
178
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
173
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
173
  auto value = std::chrono::duration<Rep, Period>(rep);
13
173
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
173
    auto buf = fmt::memory_buffer();
18
173
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
173
#endif
20
173
  } catch (std::exception&) {
21
154
  }
22
173
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
199
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
199
  auto value = std::chrono::duration<Rep, Period>(rep);
13
199
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
199
    auto buf = fmt::memory_buffer();
18
199
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
199
#endif
20
199
  } catch (std::exception&) {
21
171
  }
22
199
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, 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
165
  }
22
193
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
189
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
189
  auto value = std::chrono::duration<Rep, Period>(rep);
13
189
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
189
    auto buf = fmt::memory_buffer();
18
189
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
189
#endif
20
189
  } catch (std::exception&) {
21
165
  }
22
189
}
void invoke_inner<std::__1::ratio<1l, 1000l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
185
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
185
  auto value = std::chrono::duration<Rep, Period>(rep);
13
185
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
185
    auto buf = fmt::memory_buffer();
18
185
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
185
#endif
20
185
  } catch (std::exception&) {
21
171
  }
22
185
}
void invoke_inner<std::__1::ratio<1l, 100l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
176
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
176
  auto value = std::chrono::duration<Rep, Period>(rep);
13
176
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
176
    auto buf = fmt::memory_buffer();
18
176
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
176
#endif
20
176
  } catch (std::exception&) {
21
163
  }
22
176
}
void invoke_inner<std::__1::ratio<1l, 10l>, 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
179
  }
22
194
}
void invoke_inner<std::__1::ratio<10l, 1l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
189
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
189
  auto value = std::chrono::duration<Rep, Period>(rep);
13
189
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
189
    auto buf = fmt::memory_buffer();
18
189
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
189
#endif
20
189
  } catch (std::exception&) {
21
165
  }
22
189
}
void invoke_inner<std::__1::ratio<1000l, 1l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
224
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
224
  auto value = std::chrono::duration<Rep, Period>(rep);
13
224
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
224
    auto buf = fmt::memory_buffer();
18
224
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
224
#endif
20
224
  } catch (std::exception&) {
21
206
  }
22
224
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
213
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
213
  auto value = std::chrono::duration<Rep, Period>(rep);
13
213
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
213
    auto buf = fmt::memory_buffer();
18
213
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
213
#endif
20
213
  } catch (std::exception&) {
21
189
  }
22
213
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned 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
205
  }
22
219
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, 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
182
  }
22
194
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
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
178
  }
22
190
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, unsigned char>(fmt::v12::basic_string_view<char>, unsigned char)
Line
Count
Source
11
202
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
202
  auto value = std::chrono::duration<Rep, Period>(rep);
13
202
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
202
    auto buf = fmt::memory_buffer();
18
202
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
202
#endif
20
202
  } catch (std::exception&) {
21
185
  }
22
202
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, 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<1l, 1000000000000000l>, short>(fmt::v12::basic_string_view<char>, 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
172
  }
22
190
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, short>(fmt::v12::basic_string_view<char>, short)
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
172
  }
22
198
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, short>(fmt::v12::basic_string_view<char>, 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
189
  }
22
206
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
202
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
202
  auto value = std::chrono::duration<Rep, Period>(rep);
13
202
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
202
    auto buf = fmt::memory_buffer();
18
202
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
202
#endif
20
202
  } catch (std::exception&) {
21
177
  }
22
202
}
void invoke_inner<std::__1::ratio<1l, 1000l>, short>(fmt::v12::basic_string_view<char>, short)
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
177
  }
22
193
}
void invoke_inner<std::__1::ratio<1l, 100l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
188
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
188
  auto value = std::chrono::duration<Rep, Period>(rep);
13
188
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
188
    auto buf = fmt::memory_buffer();
18
188
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
188
#endif
20
188
  } catch (std::exception&) {
21
167
  }
22
188
}
void invoke_inner<std::__1::ratio<1l, 10l>, short>(fmt::v12::basic_string_view<char>, 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
184
  }
22
196
}
void invoke_inner<std::__1::ratio<10l, 1l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
252
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
252
  auto value = std::chrono::duration<Rep, Period>(rep);
13
252
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
252
    auto buf = fmt::memory_buffer();
18
252
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
252
#endif
20
252
  } catch (std::exception&) {
21
231
  }
22
252
}
void invoke_inner<std::__1::ratio<1000l, 1l>, short>(fmt::v12::basic_string_view<char>, short)
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
241
  }
22
256
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, short>(fmt::v12::basic_string_view<char>, short)
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
238
  }
22
263
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
229
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
229
  auto value = std::chrono::duration<Rep, Period>(rep);
13
229
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
229
    auto buf = fmt::memory_buffer();
18
229
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
229
#endif
20
229
  } catch (std::exception&) {
21
213
  }
22
229
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, short>(fmt::v12::basic_string_view<char>, short)
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
173
  }
22
193
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, short>(fmt::v12::basic_string_view<char>, 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<1000000000000000000l, 1l>, short>(fmt::v12::basic_string_view<char>, short)
Line
Count
Source
11
180
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
180
  auto value = std::chrono::duration<Rep, Period>(rep);
13
180
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
180
    auto buf = fmt::memory_buffer();
18
180
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
180
#endif
20
180
  } catch (std::exception&) {
21
170
  }
22
180
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
202
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
202
  auto value = std::chrono::duration<Rep, Period>(rep);
13
202
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
202
    auto buf = fmt::memory_buffer();
18
202
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
202
#endif
20
202
  } catch (std::exception&) {
21
190
  }
22
202
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
188
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
188
  auto value = std::chrono::duration<Rep, Period>(rep);
13
188
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
188
    auto buf = fmt::memory_buffer();
18
188
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
188
#endif
20
188
  } catch (std::exception&) {
21
172
  }
22
188
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
179
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
179
  auto value = std::chrono::duration<Rep, Period>(rep);
13
179
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
179
    auto buf = fmt::memory_buffer();
18
179
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
179
#endif
20
179
  } catch (std::exception&) {
21
165
  }
22
179
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
185
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
185
  auto value = std::chrono::duration<Rep, Period>(rep);
13
185
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
185
    auto buf = fmt::memory_buffer();
18
185
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
185
#endif
20
185
  } catch (std::exception&) {
21
161
  }
22
185
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
171
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
171
  auto value = std::chrono::duration<Rep, Period>(rep);
13
171
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
171
    auto buf = fmt::memory_buffer();
18
171
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
171
#endif
20
171
  } catch (std::exception&) {
21
147
  }
22
171
}
void invoke_inner<std::__1::ratio<1l, 1000l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
208
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
208
  auto value = std::chrono::duration<Rep, Period>(rep);
13
208
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
208
    auto buf = fmt::memory_buffer();
18
208
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
208
#endif
20
208
  } catch (std::exception&) {
21
186
  }
22
208
}
void invoke_inner<std::__1::ratio<1l, 100l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
192
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
192
  auto value = std::chrono::duration<Rep, Period>(rep);
13
192
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
192
    auto buf = fmt::memory_buffer();
18
192
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
192
#endif
20
192
  } catch (std::exception&) {
21
170
  }
22
192
}
void invoke_inner<std::__1::ratio<1l, 10l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
180
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
180
  auto value = std::chrono::duration<Rep, Period>(rep);
13
180
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
180
    auto buf = fmt::memory_buffer();
18
180
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
180
#endif
20
180
  } catch (std::exception&) {
21
159
  }
22
180
}
void invoke_inner<std::__1::ratio<10l, 1l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned 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
211
  }
22
228
}
void invoke_inner<std::__1::ratio<1000l, 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
195
  }
22
214
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, 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
189
  }
22
204
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
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
187
  }
22
200
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
183
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
183
  auto value = std::chrono::duration<Rep, Period>(rep);
13
183
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
183
    auto buf = fmt::memory_buffer();
18
183
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
183
#endif
20
183
  } catch (std::exception&) {
21
160
  }
22
183
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, unsigned short>(fmt::v12::basic_string_view<char>, unsigned short)
Line
Count
Source
11
185
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
185
  auto value = std::chrono::duration<Rep, Period>(rep);
13
185
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
185
    auto buf = fmt::memory_buffer();
18
185
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
185
#endif
20
185
  } catch (std::exception&) {
21
166
  }
22
185
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, 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
186
  }
22
197
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, int>(fmt::v12::basic_string_view<char>, int)
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
182
  }
22
215
}
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
201
  }
22
222
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, int>(fmt::v12::basic_string_view<char>, 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
190
  }
22
208
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, int>(fmt::v12::basic_string_view<char>, int)
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
185
  }
22
205
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, int>(fmt::v12::basic_string_view<char>, 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
199
  }
22
223
}
void invoke_inner<std::__1::ratio<1l, 1000l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
212
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
212
  auto value = std::chrono::duration<Rep, Period>(rep);
13
212
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
212
    auto buf = fmt::memory_buffer();
18
212
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
212
#endif
20
212
  } catch (std::exception&) {
21
188
  }
22
212
}
void invoke_inner<std::__1::ratio<1l, 100l>, int>(fmt::v12::basic_string_view<char>, int)
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<1l, 10l>, int>(fmt::v12::basic_string_view<char>, int)
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
179
  }
22
196
}
void invoke_inner<std::__1::ratio<10l, 1l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
268
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
268
  auto value = std::chrono::duration<Rep, Period>(rep);
13
268
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
268
    auto buf = fmt::memory_buffer();
18
268
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
268
#endif
20
268
  } catch (std::exception&) {
21
239
  }
22
268
}
void invoke_inner<std::__1::ratio<1000l, 1l>, int>(fmt::v12::basic_string_view<char>, 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
226
  }
22
249
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, int>(fmt::v12::basic_string_view<char>, int)
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
242
  }
22
267
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, int>(fmt::v12::basic_string_view<char>, int)
Line
Count
Source
11
255
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
255
  auto value = std::chrono::duration<Rep, Period>(rep);
13
255
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
255
    auto buf = fmt::memory_buffer();
18
255
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
255
#endif
20
255
  } catch (std::exception&) {
21
234
  }
22
255
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, int>(fmt::v12::basic_string_view<char>, int)
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
184
  }
22
201
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, int>(fmt::v12::basic_string_view<char>, int)
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
179
  }
22
200
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, int>(fmt::v12::basic_string_view<char>, int)
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
190
  }
22
205
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
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
190
  }
22
204
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
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
150
  }
22
175
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
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
171
  }
22
191
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
180
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
180
  auto value = std::chrono::duration<Rep, Period>(rep);
13
180
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
180
    auto buf = fmt::memory_buffer();
18
180
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
180
#endif
20
180
  } catch (std::exception&) {
21
162
  }
22
180
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
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
182
  }
22
196
}
void invoke_inner<std::__1::ratio<1l, 1000l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
171
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
171
  auto value = std::chrono::duration<Rep, Period>(rep);
13
171
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
171
    auto buf = fmt::memory_buffer();
18
171
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
171
#endif
20
171
  } catch (std::exception&) {
21
156
  }
22
171
}
void invoke_inner<std::__1::ratio<1l, 100l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
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
164
  }
22
181
}
void invoke_inner<std::__1::ratio<1l, 10l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
171
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
171
  auto value = std::chrono::duration<Rep, Period>(rep);
13
171
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
171
    auto buf = fmt::memory_buffer();
18
171
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
171
#endif
20
171
  } catch (std::exception&) {
21
158
  }
22
171
}
void invoke_inner<std::__1::ratio<10l, 1l>, 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
184
  }
22
209
}
void invoke_inner<std::__1::ratio<1000l, 1l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
213
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
213
  auto value = std::chrono::duration<Rep, Period>(rep);
13
213
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
213
    auto buf = fmt::memory_buffer();
18
213
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
213
#endif
20
213
  } catch (std::exception&) {
21
199
  }
22
213
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
240
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
240
  auto value = std::chrono::duration<Rep, Period>(rep);
13
240
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
240
    auto buf = fmt::memory_buffer();
18
240
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
240
#endif
20
240
  } catch (std::exception&) {
21
220
  }
22
240
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
251
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
251
  auto value = std::chrono::duration<Rep, Period>(rep);
13
251
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
251
    auto buf = fmt::memory_buffer();
18
251
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
251
#endif
20
251
  } catch (std::exception&) {
21
233
  }
22
251
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, 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<1000000000000000l, 1l>, unsigned int>(fmt::v12::basic_string_view<char>, unsigned int)
Line
Count
Source
11
213
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
213
  auto value = std::chrono::duration<Rep, Period>(rep);
13
213
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
213
    auto buf = fmt::memory_buffer();
18
213
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
213
#endif
20
213
  } catch (std::exception&) {
21
198
  }
22
213
}
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
198
  }
22
211
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
309
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
309
  auto value = std::chrono::duration<Rep, Period>(rep);
13
309
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
309
    auto buf = fmt::memory_buffer();
18
309
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
309
#endif
20
309
  } catch (std::exception&) {
21
286
  }
22
309
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
328
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
328
  auto value = std::chrono::duration<Rep, Period>(rep);
13
328
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
328
    auto buf = fmt::memory_buffer();
18
328
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
328
#endif
20
328
  } catch (std::exception&) {
21
305
  }
22
328
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
301
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
301
  auto value = std::chrono::duration<Rep, Period>(rep);
13
301
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
301
    auto buf = fmt::memory_buffer();
18
301
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
301
#endif
20
301
  } catch (std::exception&) {
21
269
  }
22
301
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
288
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
288
  auto value = std::chrono::duration<Rep, Period>(rep);
13
288
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
288
    auto buf = fmt::memory_buffer();
18
288
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
288
#endif
20
288
  } catch (std::exception&) {
21
265
  }
22
288
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
272
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
272
  auto value = std::chrono::duration<Rep, Period>(rep);
13
272
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
272
    auto buf = fmt::memory_buffer();
18
272
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
272
#endif
20
272
  } catch (std::exception&) {
21
249
  }
22
272
}
void invoke_inner<std::__1::ratio<1l, 1000l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
287
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
287
  auto value = std::chrono::duration<Rep, Period>(rep);
13
287
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
287
    auto buf = fmt::memory_buffer();
18
287
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
287
#endif
20
287
  } catch (std::exception&) {
21
269
  }
22
287
}
void invoke_inner<std::__1::ratio<1l, 100l>, long>(fmt::v12::basic_string_view<char>, long)
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<1l, 10l>, long>(fmt::v12::basic_string_view<char>, long)
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
212
  }
22
228
}
void invoke_inner<std::__1::ratio<10l, 1l>, 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
278
  }
22
299
}
void invoke_inner<std::__1::ratio<1000l, 1l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
310
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
310
  auto value = std::chrono::duration<Rep, Period>(rep);
13
310
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
310
    auto buf = fmt::memory_buffer();
18
310
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
310
#endif
20
310
  } catch (std::exception&) {
21
291
  }
22
310
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
289
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
289
  auto value = std::chrono::duration<Rep, Period>(rep);
13
289
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
289
    auto buf = fmt::memory_buffer();
18
289
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
289
#endif
20
289
  } catch (std::exception&) {
21
271
  }
22
289
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
274
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
274
  auto value = std::chrono::duration<Rep, Period>(rep);
13
274
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
274
    auto buf = fmt::memory_buffer();
18
274
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
274
#endif
20
274
  } catch (std::exception&) {
21
259
  }
22
274
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
280
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
280
  auto value = std::chrono::duration<Rep, Period>(rep);
13
280
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
280
    auto buf = fmt::memory_buffer();
18
280
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
280
#endif
20
280
  } catch (std::exception&) {
21
264
  }
22
280
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, long>(fmt::v12::basic_string_view<char>, 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
238
  }
22
255
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, long>(fmt::v12::basic_string_view<char>, long)
Line
Count
Source
11
264
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
264
  auto value = std::chrono::duration<Rep, Period>(rep);
13
264
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
264
    auto buf = fmt::memory_buffer();
18
264
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
264
#endif
20
264
  } catch (std::exception&) {
21
253
  }
22
264
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, 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
236
  }
22
257
}
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
219
  }
22
240
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
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
206
  }
22
223
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
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
199
  }
22
219
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
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
196
  }
22
219
}
void invoke_inner<std::__1::ratio<1l, 1000l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
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
207
  }
22
231
}
void invoke_inner<std::__1::ratio<1l, 100l>, 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
228
  }
22
243
}
void invoke_inner<std::__1::ratio<1l, 10l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
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
202
  }
22
220
}
void invoke_inner<std::__1::ratio<10l, 1l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
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
229
  }
22
253
}
void invoke_inner<std::__1::ratio<1000l, 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<1000000l, 1l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
Line
Count
Source
11
262
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
262
  auto value = std::chrono::duration<Rep, Period>(rep);
13
262
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
262
    auto buf = fmt::memory_buffer();
18
262
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
262
#endif
20
262
  } catch (std::exception&) {
21
236
  }
22
262
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
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
206
  }
22
224
}
void invoke_inner<std::__1::ratio<1000000000000l, 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
221
  }
22
244
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
Line
Count
Source
11
229
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
229
  auto value = std::chrono::duration<Rep, Period>(rep);
13
229
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
229
    auto buf = fmt::memory_buffer();
18
229
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
229
#endif
20
229
  } catch (std::exception&) {
21
212
  }
22
229
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, unsigned long>(fmt::v12::basic_string_view<char>, unsigned long)
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
224
  }
22
242
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, 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
313
  }
22
336
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
321
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
321
  auto value = std::chrono::duration<Rep, Period>(rep);
13
321
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
321
    auto buf = fmt::memory_buffer();
18
321
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
321
#endif
20
321
  } catch (std::exception&) {
21
283
  }
22
321
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, float>(fmt::v12::basic_string_view<char>, float)
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, 1000000000l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
305
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
305
  auto value = std::chrono::duration<Rep, Period>(rep);
13
305
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
305
    auto buf = fmt::memory_buffer();
18
305
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
305
#endif
20
305
  } catch (std::exception&) {
21
272
  }
22
305
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
335
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
335
  auto value = std::chrono::duration<Rep, Period>(rep);
13
335
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
335
    auto buf = fmt::memory_buffer();
18
335
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
335
#endif
20
335
  } catch (std::exception&) {
21
300
  }
22
335
}
void invoke_inner<std::__1::ratio<1l, 1000l>, float>(fmt::v12::basic_string_view<char>, float)
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
321
  }
22
351
}
void invoke_inner<std::__1::ratio<1l, 100l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
310
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
310
  auto value = std::chrono::duration<Rep, Period>(rep);
13
310
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
310
    auto buf = fmt::memory_buffer();
18
310
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
310
#endif
20
310
  } catch (std::exception&) {
21
282
  }
22
310
}
void invoke_inner<std::__1::ratio<1l, 10l>, 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
300
  }
22
327
}
void invoke_inner<std::__1::ratio<10l, 1l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
337
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
337
  auto value = std::chrono::duration<Rep, Period>(rep);
13
337
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
337
    auto buf = fmt::memory_buffer();
18
337
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
337
#endif
20
337
  } catch (std::exception&) {
21
309
  }
22
337
}
void invoke_inner<std::__1::ratio<1000l, 1l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
331
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
331
  auto value = std::chrono::duration<Rep, Period>(rep);
13
331
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
331
    auto buf = fmt::memory_buffer();
18
331
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
331
#endif
20
331
  } catch (std::exception&) {
21
302
  }
22
331
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
324
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
324
  auto value = std::chrono::duration<Rep, Period>(rep);
13
324
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
324
    auto buf = fmt::memory_buffer();
18
324
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
324
#endif
20
324
  } catch (std::exception&) {
21
294
  }
22
324
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
314
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
314
  auto value = std::chrono::duration<Rep, Period>(rep);
13
314
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
314
    auto buf = fmt::memory_buffer();
18
314
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
314
#endif
20
314
  } catch (std::exception&) {
21
283
  }
22
314
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, float>(fmt::v12::basic_string_view<char>, float)
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
309
  }
22
332
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
308
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
308
  auto value = std::chrono::duration<Rep, Period>(rep);
13
308
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
308
    auto buf = fmt::memory_buffer();
18
308
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
308
#endif
20
308
  } catch (std::exception&) {
21
277
  }
22
308
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, float>(fmt::v12::basic_string_view<char>, float)
Line
Count
Source
11
291
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
291
  auto value = std::chrono::duration<Rep, Period>(rep);
13
291
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
291
    auto buf = fmt::memory_buffer();
18
291
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
291
#endif
20
291
  } catch (std::exception&) {
21
259
  }
22
291
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
352
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
352
  auto value = std::chrono::duration<Rep, Period>(rep);
13
352
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
352
    auto buf = fmt::memory_buffer();
18
352
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
352
#endif
20
352
  } catch (std::exception&) {
21
321
  }
22
352
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, double>(fmt::v12::basic_string_view<char>, double)
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
282
  }
22
311
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
285
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
285
  auto value = std::chrono::duration<Rep, Period>(rep);
13
285
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
285
    auto buf = fmt::memory_buffer();
18
285
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
285
#endif
20
285
  } catch (std::exception&) {
21
262
  }
22
285
}
void invoke_inner<std::__1::ratio<1l, 1000000000l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
306
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
306
  auto value = std::chrono::duration<Rep, Period>(rep);
13
306
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
306
    auto buf = fmt::memory_buffer();
18
306
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
306
#endif
20
306
  } catch (std::exception&) {
21
276
  }
22
306
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, double>(fmt::v12::basic_string_view<char>, double)
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
303
  }
22
326
}
void invoke_inner<std::__1::ratio<1l, 1000l>, double>(fmt::v12::basic_string_view<char>, double)
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
279
  }
22
312
}
void invoke_inner<std::__1::ratio<1l, 100l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
303
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
303
  auto value = std::chrono::duration<Rep, Period>(rep);
13
303
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
303
    auto buf = fmt::memory_buffer();
18
303
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
303
#endif
20
303
  } catch (std::exception&) {
21
272
  }
22
303
}
void invoke_inner<std::__1::ratio<1l, 10l>, double>(fmt::v12::basic_string_view<char>, double)
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
290
  }
22
325
}
void invoke_inner<std::__1::ratio<10l, 1l>, 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
302
  }
22
337
}
void invoke_inner<std::__1::ratio<1000l, 1l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
333
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
333
  auto value = std::chrono::duration<Rep, Period>(rep);
13
333
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
333
    auto buf = fmt::memory_buffer();
18
333
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
333
#endif
20
333
  } catch (std::exception&) {
21
308
  }
22
333
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
314
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
314
  auto value = std::chrono::duration<Rep, Period>(rep);
13
314
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
314
    auto buf = fmt::memory_buffer();
18
314
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
314
#endif
20
314
  } catch (std::exception&) {
21
286
  }
22
314
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
334
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
334
  auto value = std::chrono::duration<Rep, Period>(rep);
13
334
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
334
    auto buf = fmt::memory_buffer();
18
334
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
334
#endif
20
334
  } catch (std::exception&) {
21
308
  }
22
334
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, double>(fmt::v12::basic_string_view<char>, double)
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
284
  }
22
315
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
304
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
304
  auto value = std::chrono::duration<Rep, Period>(rep);
13
304
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
304
    auto buf = fmt::memory_buffer();
18
304
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
304
#endif
20
304
  } catch (std::exception&) {
21
267
  }
22
304
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, double>(fmt::v12::basic_string_view<char>, double)
Line
Count
Source
11
318
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
318
  auto value = std::chrono::duration<Rep, Period>(rep);
13
318
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
318
    auto buf = fmt::memory_buffer();
18
318
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
318
#endif
20
318
  } catch (std::exception&) {
21
285
  }
22
318
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000000l>, long double>(fmt::v12::basic_string_view<char>, long double)
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
319
  }
22
362
}
void invoke_inner<std::__1::ratio<1l, 1000000000000000l>, long double>(fmt::v12::basic_string_view<char>, long double)
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
302
  }
22
336
}
void invoke_inner<std::__1::ratio<1l, 1000000000000l>, long double>(fmt::v12::basic_string_view<char>, long double)
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<1l, 1000000000l>, long double>(fmt::v12::basic_string_view<char>, long double)
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
273
  }
22
311
}
void invoke_inner<std::__1::ratio<1l, 1000000l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
328
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
328
  auto value = std::chrono::duration<Rep, Period>(rep);
13
328
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
328
    auto buf = fmt::memory_buffer();
18
328
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
328
#endif
20
328
  } catch (std::exception&) {
21
282
  }
22
328
}
void invoke_inner<std::__1::ratio<1l, 1000l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
314
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
314
  auto value = std::chrono::duration<Rep, Period>(rep);
13
314
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
314
    auto buf = fmt::memory_buffer();
18
314
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
314
#endif
20
314
  } catch (std::exception&) {
21
291
  }
22
314
}
void invoke_inner<std::__1::ratio<1l, 100l>, 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
287
  }
22
339
}
void invoke_inner<std::__1::ratio<1l, 10l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
303
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
303
  auto value = std::chrono::duration<Rep, Period>(rep);
13
303
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
303
    auto buf = fmt::memory_buffer();
18
303
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
303
#endif
20
303
  } catch (std::exception&) {
21
278
  }
22
303
}
void invoke_inner<std::__1::ratio<10l, 1l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
321
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
321
  auto value = std::chrono::duration<Rep, Period>(rep);
13
321
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
321
    auto buf = fmt::memory_buffer();
18
321
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
321
#endif
20
321
  } catch (std::exception&) {
21
281
  }
22
321
}
void invoke_inner<std::__1::ratio<1000l, 1l>, long double>(fmt::v12::basic_string_view<char>, long double)
Line
Count
Source
11
309
void invoke_inner(fmt::string_view format_str, Rep rep) {
12
309
  auto value = std::chrono::duration<Rep, Period>(rep);
13
309
  try {
14
#if FMT_FUZZ_FORMAT_TO_STRING
15
    std::string message = fmt::format(fmt::runtime(format_str), value);
16
#else
17
309
    auto buf = fmt::memory_buffer();
18
309
    fmt::format_to(std::back_inserter(buf), fmt::runtime(format_str), value);
19
309
#endif
20
309
  } catch (std::exception&) {
21
279
  }
22
309
}
void invoke_inner<std::__1::ratio<1000000l, 1l>, long double>(fmt::v12::basic_string_view<char>, long double)
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
292
  }
22
326
}
void invoke_inner<std::__1::ratio<1000000000l, 1l>, long double>(fmt::v12::basic_string_view<char>, long double)
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
297
  }
22
336
}
void invoke_inner<std::__1::ratio<1000000000000l, 1l>, long double>(fmt::v12::basic_string_view<char>, long double)
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
292
  }
22
330
}
void invoke_inner<std::__1::ratio<1000000000000000l, 1l>, long double>(fmt::v12::basic_string_view<char>, long double)
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
286
  }
22
338
}
void invoke_inner<std::__1::ratio<1000000000000000000l, 1l>, long double>(fmt::v12::basic_string_view<char>, long 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
311
  }
22
355
}
23
24
// Rep is a duration's representation type.
25
template <typename Rep>
26
43.7k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
43.7k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
43.7k
  if (size <= fixed_size + 1) return;
30
31
43.7k
  const Rep rep = assign_from_buf<Rep>(data);
32
43.7k
  data += fixed_size;
33
43.7k
  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
43.7k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
43.7k
  switch (period) {
41
3.01k
  case 1:
42
3.01k
    invoke_inner<std::atto>(format_str, rep);
43
3.01k
    break;
44
2.88k
  case 2:
45
2.88k
    invoke_inner<std::femto>(format_str, rep);
46
2.88k
    break;
47
2.78k
  case 3:
48
2.78k
    invoke_inner<std::pico>(format_str, rep);
49
2.78k
    break;
50
2.77k
  case 4:
51
2.77k
    invoke_inner<std::nano>(format_str, rep);
52
2.77k
    break;
53
2.82k
  case 5:
54
2.82k
    invoke_inner<std::micro>(format_str, rep);
55
2.82k
    break;
56
2.82k
  case 6:
57
2.82k
    invoke_inner<std::milli>(format_str, rep);
58
2.82k
    break;
59
2.77k
  case 7:
60
2.77k
    invoke_inner<std::centi>(format_str, rep);
61
2.77k
    break;
62
2.72k
  case 8:
63
2.72k
    invoke_inner<std::deci>(format_str, rep);
64
2.72k
    break;
65
3.16k
  case 9:
66
3.16k
    invoke_inner<std::deca>(format_str, rep);
67
3.16k
    break;
68
3.16k
  case 10:
69
3.16k
    invoke_inner<std::kilo>(format_str, rep);
70
3.16k
    break;
71
3.17k
  case 11:
72
3.17k
    invoke_inner<std::mega>(format_str, rep);
73
3.17k
    break;
74
3.10k
  case 12:
75
3.10k
    invoke_inner<std::giga>(format_str, rep);
76
3.10k
    break;
77
2.87k
  case 13:
78
2.87k
    invoke_inner<std::tera>(format_str, rep);
79
2.87k
    break;
80
2.78k
  case 14:
81
2.78k
    invoke_inner<std::peta>(format_str, rep);
82
2.78k
    break;
83
2.83k
  case 15:
84
2.83k
    invoke_inner<std::exa>(format_str, rep);
85
2.83k
    break;
86
43.7k
  }
87
43.7k
}
void invoke_outer<char>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
3.00k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
3.00k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
3.00k
  if (size <= fixed_size + 1) return;
30
31
2.99k
  const Rep rep = assign_from_buf<Rep>(data);
32
2.99k
  data += fixed_size;
33
2.99k
  size -= fixed_size;
34
35
  // data is already allocated separately in libFuzzer so reading past the end
36
  // will most likely be detected anyway.
37
2.99k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
2.99k
  switch (period) {
41
193
  case 1:
42
193
    invoke_inner<std::atto>(format_str, rep);
43
193
    break;
44
200
  case 2:
45
200
    invoke_inner<std::femto>(format_str, rep);
46
200
    break;
47
175
  case 3:
48
175
    invoke_inner<std::pico>(format_str, rep);
49
175
    break;
50
182
  case 4:
51
182
    invoke_inner<std::nano>(format_str, rep);
52
182
    break;
53
175
  case 5:
54
175
    invoke_inner<std::micro>(format_str, rep);
55
175
    break;
56
183
  case 6:
57
183
    invoke_inner<std::milli>(format_str, rep);
58
183
    break;
59
185
  case 7:
60
185
    invoke_inner<std::centi>(format_str, rep);
61
185
    break;
62
191
  case 8:
63
191
    invoke_inner<std::deci>(format_str, rep);
64
191
    break;
65
236
  case 9:
66
236
    invoke_inner<std::deca>(format_str, rep);
67
236
    break;
68
255
  case 10:
69
255
    invoke_inner<std::kilo>(format_str, rep);
70
255
    break;
71
237
  case 11:
72
237
    invoke_inner<std::mega>(format_str, rep);
73
237
    break;
74
219
  case 12:
75
219
    invoke_inner<std::giga>(format_str, rep);
76
219
    break;
77
188
  case 13:
78
188
    invoke_inner<std::tera>(format_str, rep);
79
188
    break;
80
192
  case 14:
81
192
    invoke_inner<std::peta>(format_str, rep);
82
192
    break;
83
188
  case 15:
84
188
    invoke_inner<std::exa>(format_str, rep);
85
188
    break;
86
2.99k
  }
87
2.99k
}
void invoke_outer<signed char>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
3.03k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
3.03k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
3.03k
  if (size <= fixed_size + 1) return;
30
31
3.02k
  const Rep rep = assign_from_buf<Rep>(data);
32
3.02k
  data += fixed_size;
33
3.02k
  size -= fixed_size;
34
35
  // data is already allocated separately in libFuzzer so reading past the end
36
  // will most likely be detected anyway.
37
3.02k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
3.02k
  switch (period) {
41
194
  case 1:
42
194
    invoke_inner<std::atto>(format_str, rep);
43
194
    break;
44
201
  case 2:
45
201
    invoke_inner<std::femto>(format_str, rep);
46
201
    break;
47
171
  case 3:
48
171
    invoke_inner<std::pico>(format_str, rep);
49
171
    break;
50
198
  case 4:
51
198
    invoke_inner<std::nano>(format_str, rep);
52
198
    break;
53
188
  case 5:
54
188
    invoke_inner<std::micro>(format_str, rep);
55
188
    break;
56
174
  case 6:
57
174
    invoke_inner<std::milli>(format_str, rep);
58
174
    break;
59
203
  case 7:
60
203
    invoke_inner<std::centi>(format_str, rep);
61
203
    break;
62
190
  case 8:
63
190
    invoke_inner<std::deci>(format_str, rep);
64
190
    break;
65
235
  case 9:
66
235
    invoke_inner<std::deca>(format_str, rep);
67
235
    break;
68
230
  case 10:
69
230
    invoke_inner<std::kilo>(format_str, rep);
70
230
    break;
71
236
  case 11:
72
236
    invoke_inner<std::mega>(format_str, rep);
73
236
    break;
74
246
  case 12:
75
246
    invoke_inner<std::giga>(format_str, rep);
76
246
    break;
77
205
  case 13:
78
205
    invoke_inner<std::tera>(format_str, rep);
79
205
    break;
80
175
  case 14:
81
175
    invoke_inner<std::peta>(format_str, rep);
82
175
    break;
83
181
  case 15:
84
181
    invoke_inner<std::exa>(format_str, rep);
85
181
    break;
86
3.02k
  }
87
3.02k
}
void invoke_outer<unsigned char>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
2.92k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
2.92k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
2.92k
  if (size <= fixed_size + 1) return;
30
31
2.91k
  const Rep rep = assign_from_buf<Rep>(data);
32
2.91k
  data += fixed_size;
33
2.91k
  size -= fixed_size;
34
35
  // data is already allocated separately in libFuzzer so reading past the end
36
  // will most likely be detected anyway.
37
2.91k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
2.91k
  switch (period) {
41
178
  case 1:
42
178
    invoke_inner<std::atto>(format_str, rep);
43
178
    break;
44
173
  case 2:
45
173
    invoke_inner<std::femto>(format_str, rep);
46
173
    break;
47
199
  case 3:
48
199
    invoke_inner<std::pico>(format_str, rep);
49
199
    break;
50
193
  case 4:
51
193
    invoke_inner<std::nano>(format_str, rep);
52
193
    break;
53
189
  case 5:
54
189
    invoke_inner<std::micro>(format_str, rep);
55
189
    break;
56
185
  case 6:
57
185
    invoke_inner<std::milli>(format_str, rep);
58
185
    break;
59
176
  case 7:
60
176
    invoke_inner<std::centi>(format_str, rep);
61
176
    break;
62
194
  case 8:
63
194
    invoke_inner<std::deci>(format_str, rep);
64
194
    break;
65
189
  case 9:
66
189
    invoke_inner<std::deca>(format_str, rep);
67
189
    break;
68
224
  case 10:
69
224
    invoke_inner<std::kilo>(format_str, rep);
70
224
    break;
71
213
  case 11:
72
213
    invoke_inner<std::mega>(format_str, rep);
73
213
    break;
74
219
  case 12:
75
219
    invoke_inner<std::giga>(format_str, rep);
76
219
    break;
77
194
  case 13:
78
194
    invoke_inner<std::tera>(format_str, rep);
79
194
    break;
80
190
  case 14:
81
190
    invoke_inner<std::peta>(format_str, rep);
82
190
    break;
83
202
  case 15:
84
202
    invoke_inner<std::exa>(format_str, rep);
85
202
    break;
86
2.91k
  }
87
2.91k
}
void invoke_outer<short>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
3.15k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
3.15k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
3.15k
  if (size <= fixed_size + 1) return;
30
31
3.15k
  const Rep rep = assign_from_buf<Rep>(data);
32
3.15k
  data += fixed_size;
33
3.15k
  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.15k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
3.15k
  switch (period) {
41
210
  case 1:
42
210
    invoke_inner<std::atto>(format_str, rep);
43
210
    break;
44
190
  case 2:
45
190
    invoke_inner<std::femto>(format_str, rep);
46
190
    break;
47
198
  case 3:
48
198
    invoke_inner<std::pico>(format_str, rep);
49
198
    break;
50
206
  case 4:
51
206
    invoke_inner<std::nano>(format_str, rep);
52
206
    break;
53
202
  case 5:
54
202
    invoke_inner<std::micro>(format_str, rep);
55
202
    break;
56
193
  case 6:
57
193
    invoke_inner<std::milli>(format_str, rep);
58
193
    break;
59
188
  case 7:
60
188
    invoke_inner<std::centi>(format_str, rep);
61
188
    break;
62
196
  case 8:
63
196
    invoke_inner<std::deci>(format_str, rep);
64
196
    break;
65
252
  case 9:
66
252
    invoke_inner<std::deca>(format_str, rep);
67
252
    break;
68
256
  case 10:
69
256
    invoke_inner<std::kilo>(format_str, rep);
70
256
    break;
71
263
  case 11:
72
263
    invoke_inner<std::mega>(format_str, rep);
73
263
    break;
74
229
  case 12:
75
229
    invoke_inner<std::giga>(format_str, rep);
76
229
    break;
77
193
  case 13:
78
193
    invoke_inner<std::tera>(format_str, rep);
79
193
    break;
80
197
  case 14:
81
197
    invoke_inner<std::peta>(format_str, rep);
82
197
    break;
83
180
  case 15:
84
180
    invoke_inner<std::exa>(format_str, rep);
85
180
    break;
86
3.15k
  }
87
3.15k
}
void invoke_outer<unsigned short>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
2.92k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
2.92k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
2.92k
  if (size <= fixed_size + 1) return;
30
31
2.91k
  const Rep rep = assign_from_buf<Rep>(data);
32
2.91k
  data += fixed_size;
33
2.91k
  size -= fixed_size;
34
35
  // data is already allocated separately in libFuzzer so reading past the end
36
  // will most likely be detected anyway.
37
2.91k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
2.91k
  switch (period) {
41
202
  case 1:
42
202
    invoke_inner<std::atto>(format_str, rep);
43
202
    break;
44
188
  case 2:
45
188
    invoke_inner<std::femto>(format_str, rep);
46
188
    break;
47
179
  case 3:
48
179
    invoke_inner<std::pico>(format_str, rep);
49
179
    break;
50
185
  case 4:
51
185
    invoke_inner<std::nano>(format_str, rep);
52
185
    break;
53
171
  case 5:
54
171
    invoke_inner<std::micro>(format_str, rep);
55
171
    break;
56
208
  case 6:
57
208
    invoke_inner<std::milli>(format_str, rep);
58
208
    break;
59
192
  case 7:
60
192
    invoke_inner<std::centi>(format_str, rep);
61
192
    break;
62
180
  case 8:
63
180
    invoke_inner<std::deci>(format_str, rep);
64
180
    break;
65
228
  case 9:
66
228
    invoke_inner<std::deca>(format_str, rep);
67
228
    break;
68
214
  case 10:
69
214
    invoke_inner<std::kilo>(format_str, rep);
70
214
    break;
71
204
  case 11:
72
204
    invoke_inner<std::mega>(format_str, rep);
73
204
    break;
74
200
  case 12:
75
200
    invoke_inner<std::giga>(format_str, rep);
76
200
    break;
77
183
  case 13:
78
183
    invoke_inner<std::tera>(format_str, rep);
79
183
    break;
80
185
  case 14:
81
185
    invoke_inner<std::peta>(format_str, rep);
82
185
    break;
83
197
  case 15:
84
197
    invoke_inner<std::exa>(format_str, rep);
85
197
    break;
86
2.91k
  }
87
2.91k
}
void invoke_outer<int>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
3.33k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
3.33k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
3.33k
  if (size <= fixed_size + 1) return;
30
31
3.33k
  const Rep rep = assign_from_buf<Rep>(data);
32
3.33k
  data += fixed_size;
33
3.33k
  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.33k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
3.33k
  switch (period) {
41
215
  case 1:
42
215
    invoke_inner<std::atto>(format_str, rep);
43
215
    break;
44
222
  case 2:
45
222
    invoke_inner<std::femto>(format_str, rep);
46
222
    break;
47
208
  case 3:
48
208
    invoke_inner<std::pico>(format_str, rep);
49
208
    break;
50
205
  case 4:
51
205
    invoke_inner<std::nano>(format_str, rep);
52
205
    break;
53
223
  case 5:
54
223
    invoke_inner<std::micro>(format_str, rep);
55
223
    break;
56
212
  case 6:
57
212
    invoke_inner<std::milli>(format_str, rep);
58
212
    break;
59
206
  case 7:
60
206
    invoke_inner<std::centi>(format_str, rep);
61
206
    break;
62
196
  case 8:
63
196
    invoke_inner<std::deci>(format_str, rep);
64
196
    break;
65
268
  case 9:
66
268
    invoke_inner<std::deca>(format_str, rep);
67
268
    break;
68
249
  case 10:
69
249
    invoke_inner<std::kilo>(format_str, rep);
70
249
    break;
71
267
  case 11:
72
267
    invoke_inner<std::mega>(format_str, rep);
73
267
    break;
74
255
  case 12:
75
255
    invoke_inner<std::giga>(format_str, rep);
76
255
    break;
77
201
  case 13:
78
201
    invoke_inner<std::tera>(format_str, rep);
79
201
    break;
80
200
  case 14:
81
200
    invoke_inner<std::peta>(format_str, rep);
82
200
    break;
83
205
  case 15:
84
205
    invoke_inner<std::exa>(format_str, rep);
85
205
    break;
86
3.33k
  }
87
3.33k
}
void invoke_outer<unsigned int>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
3.01k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
3.01k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
3.01k
  if (size <= fixed_size + 1) return;
30
31
3.01k
  const Rep rep = assign_from_buf<Rep>(data);
32
3.01k
  data += fixed_size;
33
3.01k
  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.01k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
3.01k
  switch (period) {
41
204
  case 1:
42
204
    invoke_inner<std::atto>(format_str, rep);
43
204
    break;
44
175
  case 2:
45
175
    invoke_inner<std::femto>(format_str, rep);
46
175
    break;
47
191
  case 3:
48
191
    invoke_inner<std::pico>(format_str, rep);
49
191
    break;
50
180
  case 4:
51
180
    invoke_inner<std::nano>(format_str, rep);
52
180
    break;
53
196
  case 5:
54
196
    invoke_inner<std::micro>(format_str, rep);
55
196
    break;
56
171
  case 6:
57
171
    invoke_inner<std::milli>(format_str, rep);
58
171
    break;
59
181
  case 7:
60
181
    invoke_inner<std::centi>(format_str, rep);
61
181
    break;
62
171
  case 8:
63
171
    invoke_inner<std::deci>(format_str, rep);
64
171
    break;
65
209
  case 9:
66
209
    invoke_inner<std::deca>(format_str, rep);
67
209
    break;
68
213
  case 10:
69
213
    invoke_inner<std::kilo>(format_str, rep);
70
213
    break;
71
240
  case 11:
72
240
    invoke_inner<std::mega>(format_str, rep);
73
240
    break;
74
251
  case 12:
75
251
    invoke_inner<std::giga>(format_str, rep);
76
251
    break;
77
210
  case 13:
78
210
    invoke_inner<std::tera>(format_str, rep);
79
210
    break;
80
213
  case 14:
81
213
    invoke_inner<std::peta>(format_str, rep);
82
213
    break;
83
211
  case 15:
84
211
    invoke_inner<std::exa>(format_str, rep);
85
211
    break;
86
3.01k
  }
87
3.01k
}
void invoke_outer<long>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
4.23k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
4.23k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
4.23k
  if (size <= fixed_size + 1) return;
30
31
4.23k
  const Rep rep = assign_from_buf<Rep>(data);
32
4.23k
  data += fixed_size;
33
4.23k
  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.23k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
4.23k
  switch (period) {
41
309
  case 1:
42
309
    invoke_inner<std::atto>(format_str, rep);
43
309
    break;
44
328
  case 2:
45
328
    invoke_inner<std::femto>(format_str, rep);
46
328
    break;
47
301
  case 3:
48
301
    invoke_inner<std::pico>(format_str, rep);
49
301
    break;
50
288
  case 4:
51
288
    invoke_inner<std::nano>(format_str, rep);
52
288
    break;
53
272
  case 5:
54
272
    invoke_inner<std::micro>(format_str, rep);
55
272
    break;
56
287
  case 6:
57
287
    invoke_inner<std::milli>(format_str, rep);
58
287
    break;
59
249
  case 7:
60
249
    invoke_inner<std::centi>(format_str, rep);
61
249
    break;
62
228
  case 8:
63
228
    invoke_inner<std::deci>(format_str, rep);
64
228
    break;
65
299
  case 9:
66
299
    invoke_inner<std::deca>(format_str, rep);
67
299
    break;
68
310
  case 10:
69
310
    invoke_inner<std::kilo>(format_str, rep);
70
310
    break;
71
289
  case 11:
72
289
    invoke_inner<std::mega>(format_str, rep);
73
289
    break;
74
274
  case 12:
75
274
    invoke_inner<std::giga>(format_str, rep);
76
274
    break;
77
280
  case 13:
78
280
    invoke_inner<std::tera>(format_str, rep);
79
280
    break;
80
255
  case 14:
81
255
    invoke_inner<std::peta>(format_str, rep);
82
255
    break;
83
264
  case 15:
84
264
    invoke_inner<std::exa>(format_str, rep);
85
264
    break;
86
4.23k
  }
87
4.23k
}
void invoke_outer<unsigned long>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
3.55k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
3.55k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
3.55k
  if (size <= fixed_size + 1) return;
30
31
3.55k
  const Rep rep = assign_from_buf<Rep>(data);
32
3.55k
  data += fixed_size;
33
3.55k
  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.55k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
3.55k
  switch (period) {
41
257
  case 1:
42
257
    invoke_inner<std::atto>(format_str, rep);
43
257
    break;
44
240
  case 2:
45
240
    invoke_inner<std::femto>(format_str, rep);
46
240
    break;
47
223
  case 3:
48
223
    invoke_inner<std::pico>(format_str, rep);
49
223
    break;
50
219
  case 4:
51
219
    invoke_inner<std::nano>(format_str, rep);
52
219
    break;
53
219
  case 5:
54
219
    invoke_inner<std::micro>(format_str, rep);
55
219
    break;
56
231
  case 6:
57
231
    invoke_inner<std::milli>(format_str, rep);
58
231
    break;
59
243
  case 7:
60
243
    invoke_inner<std::centi>(format_str, rep);
61
243
    break;
62
220
  case 8:
63
220
    invoke_inner<std::deci>(format_str, rep);
64
220
    break;
65
253
  case 9:
66
253
    invoke_inner<std::deca>(format_str, rep);
67
253
    break;
68
244
  case 10:
69
244
    invoke_inner<std::kilo>(format_str, rep);
70
244
    break;
71
262
  case 11:
72
262
    invoke_inner<std::mega>(format_str, rep);
73
262
    break;
74
224
  case 12:
75
224
    invoke_inner<std::giga>(format_str, rep);
76
224
    break;
77
244
  case 13:
78
244
    invoke_inner<std::tera>(format_str, rep);
79
244
    break;
80
229
  case 14:
81
229
    invoke_inner<std::peta>(format_str, rep);
82
229
    break;
83
242
  case 15:
84
242
    invoke_inner<std::exa>(format_str, rep);
85
242
    break;
86
3.55k
  }
87
3.55k
}
void invoke_outer<float>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
4.86k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
4.86k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
4.86k
  if (size <= fixed_size + 1) return;
30
31
4.86k
  const Rep rep = assign_from_buf<Rep>(data);
32
4.86k
  data += fixed_size;
33
4.86k
  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.86k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
4.86k
  switch (period) {
41
336
  case 1:
42
336
    invoke_inner<std::atto>(format_str, rep);
43
336
    break;
44
321
  case 2:
45
321
    invoke_inner<std::femto>(format_str, rep);
46
321
    break;
47
337
  case 3:
48
337
    invoke_inner<std::pico>(format_str, rep);
49
337
    break;
50
305
  case 4:
51
305
    invoke_inner<std::nano>(format_str, rep);
52
305
    break;
53
335
  case 5:
54
335
    invoke_inner<std::micro>(format_str, rep);
55
335
    break;
56
351
  case 6:
57
351
    invoke_inner<std::milli>(format_str, rep);
58
351
    break;
59
310
  case 7:
60
310
    invoke_inner<std::centi>(format_str, rep);
61
310
    break;
62
327
  case 8:
63
327
    invoke_inner<std::deci>(format_str, rep);
64
327
    break;
65
337
  case 9:
66
337
    invoke_inner<std::deca>(format_str, rep);
67
337
    break;
68
331
  case 10:
69
331
    invoke_inner<std::kilo>(format_str, rep);
70
331
    break;
71
324
  case 11:
72
324
    invoke_inner<std::mega>(format_str, rep);
73
324
    break;
74
314
  case 12:
75
314
    invoke_inner<std::giga>(format_str, rep);
76
314
    break;
77
332
  case 13:
78
332
    invoke_inner<std::tera>(format_str, rep);
79
332
    break;
80
308
  case 14:
81
308
    invoke_inner<std::peta>(format_str, rep);
82
308
    break;
83
291
  case 15:
84
291
    invoke_inner<std::exa>(format_str, rep);
85
291
    break;
86
4.86k
  }
87
4.86k
}
void invoke_outer<double>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
4.77k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
4.77k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
4.77k
  if (size <= fixed_size + 1) return;
30
31
4.77k
  const Rep rep = assign_from_buf<Rep>(data);
32
4.77k
  data += fixed_size;
33
4.77k
  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.77k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
4.77k
  switch (period) {
41
352
  case 1:
42
352
    invoke_inner<std::atto>(format_str, rep);
43
352
    break;
44
311
  case 2:
45
311
    invoke_inner<std::femto>(format_str, rep);
46
311
    break;
47
285
  case 3:
48
285
    invoke_inner<std::pico>(format_str, rep);
49
285
    break;
50
306
  case 4:
51
306
    invoke_inner<std::nano>(format_str, rep);
52
306
    break;
53
326
  case 5:
54
326
    invoke_inner<std::micro>(format_str, rep);
55
326
    break;
56
312
  case 6:
57
312
    invoke_inner<std::milli>(format_str, rep);
58
312
    break;
59
303
  case 7:
60
303
    invoke_inner<std::centi>(format_str, rep);
61
303
    break;
62
325
  case 8:
63
325
    invoke_inner<std::deci>(format_str, rep);
64
325
    break;
65
337
  case 9:
66
337
    invoke_inner<std::deca>(format_str, rep);
67
337
    break;
68
333
  case 10:
69
333
    invoke_inner<std::kilo>(format_str, rep);
70
333
    break;
71
314
  case 11:
72
314
    invoke_inner<std::mega>(format_str, rep);
73
314
    break;
74
334
  case 12:
75
334
    invoke_inner<std::giga>(format_str, rep);
76
334
    break;
77
315
  case 13:
78
315
    invoke_inner<std::tera>(format_str, rep);
79
315
    break;
80
304
  case 14:
81
304
    invoke_inner<std::peta>(format_str, rep);
82
304
    break;
83
318
  case 15:
84
318
    invoke_inner<std::exa>(format_str, rep);
85
318
    break;
86
4.77k
  }
87
4.77k
}
void invoke_outer<long double>(unsigned char const*, unsigned long, int)
Line
Count
Source
26
4.92k
void invoke_outer(const uint8_t* data, size_t size, int period) {
27
  // Always use a fixed location of the data.
28
4.92k
  static_assert(sizeof(Rep) <= fixed_size, "fixed size is too small");
29
4.92k
  if (size <= fixed_size + 1) return;
30
31
4.92k
  const Rep rep = assign_from_buf<Rep>(data);
32
4.92k
  data += fixed_size;
33
4.92k
  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.92k
  const auto format_str = fmt::string_view(as_chars(data), size);
38
39
  // yocto, zepto, zetta and yotta are not handled.
40
4.92k
  switch (period) {
41
362
  case 1:
42
362
    invoke_inner<std::atto>(format_str, rep);
43
362
    break;
44
336
  case 2:
45
336
    invoke_inner<std::femto>(format_str, rep);
46
336
    break;
47
317
  case 3:
48
317
    invoke_inner<std::pico>(format_str, rep);
49
317
    break;
50
311
  case 4:
51
311
    invoke_inner<std::nano>(format_str, rep);
52
311
    break;
53
328
  case 5:
54
328
    invoke_inner<std::micro>(format_str, rep);
55
328
    break;
56
314
  case 6:
57
314
    invoke_inner<std::milli>(format_str, rep);
58
314
    break;
59
339
  case 7:
60
339
    invoke_inner<std::centi>(format_str, rep);
61
339
    break;
62
303
  case 8:
63
303
    invoke_inner<std::deci>(format_str, rep);
64
303
    break;
65
321
  case 9:
66
321
    invoke_inner<std::deca>(format_str, rep);
67
321
    break;
68
309
  case 10:
69
309
    invoke_inner<std::kilo>(format_str, rep);
70
309
    break;
71
326
  case 11:
72
326
    invoke_inner<std::mega>(format_str, rep);
73
326
    break;
74
336
  case 12:
75
336
    invoke_inner<std::giga>(format_str, rep);
76
336
    break;
77
330
  case 13:
78
330
    invoke_inner<std::tera>(format_str, rep);
79
330
    break;
80
338
  case 14:
81
338
    invoke_inner<std::peta>(format_str, rep);
82
338
    break;
83
355
  case 15:
84
355
    invoke_inner<std::exa>(format_str, rep);
85
355
    break;
86
4.92k
  }
87
4.92k
}
88
89
43.7k
extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {
90
43.7k
  if (size <= 4) return 0;
91
92
43.7k
  const auto representation = data[0];
93
43.7k
  const auto period = data[1];
94
43.7k
  data += 2;
95
43.7k
  size -= 2;
96
97
43.7k
  switch (representation) {
98
3.00k
  case 1:
99
3.00k
    invoke_outer<char>(data, size, period);
100
3.00k
    break;
101
3.03k
  case 2:
102
3.03k
    invoke_outer<signed char>(data, size, period);
103
3.03k
    break;
104
2.92k
  case 3:
105
2.92k
    invoke_outer<unsigned char>(data, size, period);
106
2.92k
    break;
107
3.15k
  case 4:
108
3.15k
    invoke_outer<short>(data, size, period);
109
3.15k
    break;
110
2.92k
  case 5:
111
2.92k
    invoke_outer<unsigned short>(data, size, period);
112
2.92k
    break;
113
3.33k
  case 6:
114
3.33k
    invoke_outer<int>(data, size, period);
115
3.33k
    break;
116
3.01k
  case 7:
117
3.01k
    invoke_outer<unsigned int>(data, size, period);
118
3.01k
    break;
119
4.23k
  case 8:
120
4.23k
    invoke_outer<long>(data, size, period);
121
4.23k
    break;
122
3.55k
  case 9:
123
3.55k
    invoke_outer<unsigned long>(data, size, period);
124
3.55k
    break;
125
4.86k
  case 10:
126
4.86k
    invoke_outer<float>(data, size, period);
127
4.86k
    break;
128
4.77k
  case 11:
129
4.77k
    invoke_outer<double>(data, size, period);
130
4.77k
    break;
131
4.92k
  case 12:
132
4.92k
    invoke_outer<long double>(data, size, period);
133
4.92k
    break;
134
43.7k
  }
135
43.7k
  return 0;
136
43.7k
}