Fix coding style and remove duplicate fuzzer

test/fuzzing/fuzzer_common.h

@@ -1,65 +1,52 @@
+// Copyright (c) 2019, Paul Dreik
+// For the license information refer to format.h.
+
 #ifndef FUZZER_COMMON_H
 #define FUZZER_COMMON_H
 
-// Copyright (c) 2019, Paul Dreik
-// License: see LICENSE.rst in the fmt root directory
-
 #include <cstdint>      // std::uint8_t
 #include <cstring>      // memcpy
-#include <type_traits>  // trivially copyable
 
-// one can format to either a string, or a buf. buf is faster,
-// but one may be interested in formatting to a string instead to
-// verify it works as intended. to avoid a combinatoric explosion,
-// select this at compile time instead of dynamically from the fuzz data
+// One can format to either a string, or a buffer. The latter is faster, but
+// one may be interested in formatting to a string instead to verify it works
+// as intended. To avoid a combinatoric explosion, select this at compile time
+// instead of dynamically from the fuzz data.
 #define FMT_FUZZ_FORMAT_TO_STRING 0
 
-// if fmt is given a buffer that is separately allocated,
-// chances that address sanitizer detects out of bound reads is
-// much higher. However, it slows down the fuzzing.
+// If {fmt} is given a buffer that is separately allocated, chances that address
+// sanitizer detects out of bound reads is much higher. However, it slows down
+// the fuzzing.
 #define FMT_FUZZ_SEPARATE_ALLOCATION 1
 
-// To let the the fuzzer mutation be efficient at cross pollinating
-// between different types, use a fixed size format.
-// The same bit pattern, interpreted as another type,
-// is likely interesting.
-// For this, we must know the size of the largest possible type in use.
+namespace fmt_fuzzer {
 
-// There are some problems on travis, claiming Nfixed is not a constant
-// expression which seems to be an issue with older versions of libstdc++
-#if _GLIBCXX_RELEASE >= 7
-#  include <algorithm>
-namespace fmt_fuzzer {
-constexpr auto Nfixed = std::max(sizeof(long double), sizeof(std::intmax_t));
-}
-#else
-namespace fmt_fuzzer {
-constexpr auto Nfixed = 16;
-}
-#endif
+// The size of the largest possible type in use.
+// To let the the fuzzer mutation be efficient at cross pollinating between
+// different types, use a fixed size format. The same bit pattern, interpreted
+// as another type, is likely interesting.
+constexpr auto nfixed = 16;
 
-namespace fmt_fuzzer {
-// view data as a c char pointer.
+// Casts data to a char pointer.
 template <typename T> inline const char* as_chars(const T* data) {
-  return static_cast<const char*>(static_cast<const void*>(data));
+  return reinterpret_cast<const char*>(data);
 }
 
-// view data as a byte pointer
+// Casts data to a byte pointer.
 template <typename T> inline const std::uint8_t* as_bytes(const T* data) {
-  return static_cast<const std::uint8_t*>(static_cast<const void*>(data));
+  return reinterpret_cast<const std::uint8_t*>(data);
 }
 
-// blits bytes from Data to form an (assumed trivially constructible) object
-// of type Item
-template <class Item> inline Item assignFromBuf(const std::uint8_t* Data) {
-  Item item{};
-  std::memcpy(&item, Data, sizeof(Item));
+// Blits bytes from data to form an (assumed trivially constructible) object
+// of type Item.
+template <class Item> inline Item assignFromBuf(const std::uint8_t* data) {
+  auto item = Item();
+  std::memcpy(&item, data, sizeof(Item));
   return item;
 }
 
-// reads a boolean value by looking at the first byte from Data
-template <> inline bool assignFromBuf<bool>(const std::uint8_t* Data) {
-  return !!Data[0];
+// Reads a boolean value by looking at the first byte from data.
+template <> inline bool assignFromBuf<bool>(const std::uint8_t* data) {
+  return *data != 0;
 }
 
 }  // namespace fmt_fuzzer