#ifndef LLVM_SUPPORT_NATIVE_FORMATTING_H
#define LLVM_SUPPORT_NATIVE_FORMATTING_H
-#include "llvm/ADT/Optional.h"
#include "llvm/Support/raw_ostream.h"
#include <cstdint>
namespace llvm {
-enum class FloatStyle { Exponent, ExponentUpper, Fixed, Percent };
-enum class IntegerStyle {
- Exponent,
- ExponentUpper,
- Integer,
- Fixed,
- Number,
- Percent,
- HexUpperPrefix,
- HexUpperNoPrefix,
- HexLowerPrefix,
- HexLowerNoPrefix
-};
-enum class HexPrintStyle { Upper, Lower, PrefixUpper, PrefixLower };
-
-IntegerStyle hexStyleToIntHexStyle(HexPrintStyle S);
-
-size_t getDefaultPrecision(FloatStyle Style);
-size_t getDefaultPrecision(IntegerStyle Style);
-size_t getDefaultPrecision(HexPrintStyle Style);
-
-void write_integer(raw_ostream &S, unsigned int N, IntegerStyle Style,
- Optional<size_t> Precision = None,
- Optional<int> Width = None);
-void write_integer(raw_ostream &S, int N, IntegerStyle Style,
- Optional<size_t> Precision = None,
- Optional<int> Width = None);
-void write_integer(raw_ostream &S, unsigned long N, IntegerStyle Style,
- Optional<size_t> Precision = None,
- Optional<int> Width = None);
-void write_integer(raw_ostream &S, long N, IntegerStyle Style,
- Optional<size_t> Precision = None,
- Optional<int> Width = None);
-void write_integer(raw_ostream &S, unsigned long long N, IntegerStyle Style,
- Optional<size_t> Precision = None,
- Optional<int> Width = None);
-void write_integer(raw_ostream &S, long long N, IntegerStyle Style,
- Optional<size_t> Precision = None,
- Optional<int> Width = None);
-
-void write_hex(raw_ostream &S, uint64_t N, HexPrintStyle Style,
- Optional<size_t> Precision = None, Optional<int> Width = None);
-void write_double(raw_ostream &S, double D, FloatStyle Style,
- Optional<size_t> Precision = None,
- Optional<int> Width = None);
+enum class FloatStyle { Exponent, Decimal };
+
+void write_ulong(raw_ostream &S, unsigned long N, std::size_t MinWidth);
+void write_long(raw_ostream &S, long N, std::size_t MinWidth);
+void write_ulonglong(raw_ostream &S, unsigned long long N,
+ std::size_t MinWidth);
+void write_longlong(raw_ostream &S, long long N, std::size_t MinWidth);
+void write_hex(raw_ostream &S, unsigned long long N, std::size_t MinWidth,
+ bool Upper, bool Prefix);
+void write_double(raw_ostream &S, double D, std::size_t MinWidth,
+ std::size_t MinDecimals, FloatStyle Style);
}
#endif
\ No newline at end of file
#include "llvm/Support/NativeFormatting.h"
-#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/SmallString.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/Support/Format.h"
using namespace llvm;
-static bool isHexStyle(IntegerStyle S) {
- switch (S) {
- case IntegerStyle::HexLowerNoPrefix:
- case IntegerStyle::HexLowerPrefix:
- case IntegerStyle::HexUpperNoPrefix:
- case IntegerStyle::HexUpperPrefix:
- return true;
- default:
- return false;
- }
- LLVM_BUILTIN_UNREACHABLE;
-}
-
-static HexPrintStyle intHexStyleToHexStyle(IntegerStyle S) {
- assert(isHexStyle(S));
- switch (S) {
- case IntegerStyle::HexLowerNoPrefix:
- return HexPrintStyle::Lower;
- case IntegerStyle::HexLowerPrefix:
- return HexPrintStyle::PrefixLower;
- case IntegerStyle::HexUpperNoPrefix:
- return HexPrintStyle::Upper;
- case IntegerStyle::HexUpperPrefix:
- return HexPrintStyle::PrefixUpper;
- default:
- break;
- }
- LLVM_BUILTIN_UNREACHABLE;
-}
-
-static void writePadding(raw_ostream &S, Optional<int> FieldWidth,
- size_t Chars) {
- if (!FieldWidth.hasValue())
- return;
-
- int Pad = *FieldWidth - Chars;
- if (Pad > 0)
- S.indent(Pad);
-}
-
template<typename T, std::size_t N>
static int format_to_buffer(T Value, char (&Buffer)[N]) {
char *EndPtr = std::end(Buffer);
char *CurPtr = EndPtr;
- do {
+ while (Value) {
*--CurPtr = '0' + char(Value % 10);
Value /= 10;
- } while (Value);
- return EndPtr - CurPtr;
-}
-
-static void repeat_char(raw_ostream &S, char C, size_t Times) {
- for (size_t I = 0; I < Times; ++I)
- S << C;
-}
-
-static void writeWithCommas(raw_ostream &S, ArrayRef<char> Buffer) {
- assert(!Buffer.empty());
-
- ArrayRef<char> ThisGroup;
- int InitialDigits = ((Buffer.size() - 1) % 3) + 1;
- ThisGroup = Buffer.take_front(InitialDigits);
- S.write(ThisGroup.data(), ThisGroup.size());
-
- Buffer = Buffer.drop_front(InitialDigits);
- assert(Buffer.size() % 3 == 0);
- while (!Buffer.empty()) {
- S << ',';
- ThisGroup = Buffer.take_front(3);
- S.write(ThisGroup.data(), 3);
- Buffer = Buffer.drop_front(3);
}
+ return EndPtr - CurPtr;
}
-template <typename T>
-static void write_unsigned_impl(raw_ostream &S, T N, IntegerStyle Style,
- Optional<size_t> Precision, Optional<int> Width,
- bool IsNegative) {
- static_assert(std::is_unsigned<T>::value, "Value is not unsigned!");
-
- if (Style == IntegerStyle::Exponent) {
- write_double(S, static_cast<double>(N), FloatStyle::Exponent, Precision,
- Width);
- return;
- } else if (Style == IntegerStyle::ExponentUpper) {
- write_double(S, static_cast<double>(N), FloatStyle::ExponentUpper,
- Precision, Width);
- return;
- } else if (isHexStyle(Style)) {
- write_hex(S, N, intHexStyleToHexStyle(Style), Precision, Width);
+void llvm::write_ulong(raw_ostream &S, unsigned long N, std::size_t MinWidth) {
+ // Zero is a special case.
+ if (N == 0) {
+ if (MinWidth > 0)
+ S.indent(MinWidth - 1);
+ S << '0';
return;
}
- size_t Prec = Precision.getValueOr(getDefaultPrecision(Style));
- char NumberBuffer[128];
- std::memset(NumberBuffer, '0', sizeof(NumberBuffer));
-
- size_t Len = 0;
- Len = format_to_buffer(N, NumberBuffer);
-
- bool WriteDecimal =
- ((Style == IntegerStyle::Fixed || Style == IntegerStyle::Percent) &&
- Prec > 0);
-
- size_t LeadingZeros = 0;
- if ((Style == IntegerStyle::Integer || Style == IntegerStyle::Number) &&
- Prec > 0) {
- if (Prec > Len)
- LeadingZeros = Prec - Len;
- }
-
- Len += LeadingZeros;
-
- // One for the decimal sign, one for each point of precision.
- size_t DecimalChars = WriteDecimal ? 1 + Prec : 0;
-
- // One character for the negative sign.
- size_t Neg = (IsNegative) ? 1 : 0;
-
- // One comma for each group of 3 digits.
- size_t Commas = (Style != IntegerStyle::Number) ? 0 : (Len - 1) / 3;
-
- size_t PercentChars = 0;
- if (Style == IntegerStyle::Percent) {
- // For all numbers except 0, we append two additional 0s.
- PercentChars = (N == 0) ? 1 : 3;
- }
-
- writePadding(S, Width, Len + DecimalChars + Neg + Commas + PercentChars);
-
- if (IsNegative)
- S << '-';
- if (Style == IntegerStyle::Number) {
- writeWithCommas(S, ArrayRef<char>(std::end(NumberBuffer) - Len, Len));
- } else {
- S.write(std::end(NumberBuffer) - Len, Len);
- if (Style == IntegerStyle::Percent && N != 0) {
- // Rather than multiply by 100, write the characters manually, in case the
- // multiplication would overflow.
- S << "00";
- }
- }
-
- if (WriteDecimal) {
- S << '.';
- repeat_char(S, '0', Prec);
- }
- if (Style == IntegerStyle::Percent)
- S << '%';
-}
-
-template <typename T>
-static void write_unsigned(raw_ostream &S, T N, IntegerStyle Style,
- Optional<size_t> Precision, Optional<int> Width,
- bool IsNegative = false) {
- // Output using 32-bit div/mod if possible.
- if (N == static_cast<uint32_t>(N))
- write_unsigned_impl(S, static_cast<uint32_t>(N), Style, Precision, Width,
- IsNegative);
- else
- write_unsigned_impl(S, N, Style, Precision, Width, IsNegative);
+ char NumberBuffer[20];
+ int Len = format_to_buffer(N, NumberBuffer);
+ int Pad = (MinWidth == 0) ? 0 : MinWidth - Len;
+ if (Pad > 0)
+ S.indent(Pad);
+ S.write(std::end(NumberBuffer) - Len, Len);
}
-template <typename T>
-static void write_signed(raw_ostream &S, T N, IntegerStyle Style,
- Optional<size_t> Precision, Optional<int> Width) {
- static_assert(std::is_signed<T>::value, "Value is not signed!");
-
- using UnsignedT = typename std::make_unsigned<T>::type;
-
+void llvm::write_long(raw_ostream &S, long N, std::size_t MinWidth) {
if (N >= 0) {
- write_unsigned(S, static_cast<UnsignedT>(N), Style, Precision, Width);
+ write_ulong(S, static_cast<unsigned long>(N), MinWidth);
return;
}
- UnsignedT UN = -(UnsignedT)N;
- if (isHexStyle(Style)) {
- static_assert(sizeof(UnsignedT) == sizeof(T),
- "Types do not have the same size!");
- std::memcpy(&UN, &N, sizeof(N));
- write_hex(S, UN, intHexStyleToHexStyle(Style), Precision, Width);
- return;
- }
- write_unsigned(S, UN, Style, Precision, Width, true);
-}
+ unsigned long UN = -(unsigned long)N;
+ if (MinWidth > 0)
+ --MinWidth;
-void llvm::write_integer(raw_ostream &S, unsigned int N, IntegerStyle Style,
- Optional<size_t> Precision, Optional<int> Width) {
- write_unsigned(S, N, Style, Precision, Width);
+ char NumberBuffer[20];
+ int Len = format_to_buffer(UN, NumberBuffer);
+ int Pad = (MinWidth == 0) ? 0 : MinWidth - Len;
+ if (Pad > 0)
+ S.indent(Pad);
+ S.write('-');
+ S.write(std::end(NumberBuffer) - Len, Len);
}
-void llvm::write_integer(raw_ostream &S, int N, IntegerStyle Style,
- Optional<size_t> Precision, Optional<int> Width) {
- write_signed(S, N, Style, Precision, Width);
-}
+void llvm::write_ulonglong(raw_ostream &S, unsigned long long N,
+ std::size_t MinWidth) {
+ // Output using 32-bit div/mod when possible.
+ if (N == static_cast<unsigned long>(N)) {
+ write_ulong(S, static_cast<unsigned long>(N), MinWidth);
+ return;
+ }
-void llvm::write_integer(raw_ostream &S, unsigned long N, IntegerStyle Style,
- Optional<size_t> Precision, Optional<int> Width) {
- write_unsigned(S, N, Style, Precision, Width);
+ char NumberBuffer[32];
+ int Len = format_to_buffer(N, NumberBuffer);
+ int Pad = (MinWidth == 0) ? 0 : MinWidth - Len;
+ if (Pad > 0)
+ S.indent(Pad);
+ S.write(std::end(NumberBuffer) - Len, Len);
}
-void llvm::write_integer(raw_ostream &S, long N, IntegerStyle Style,
- Optional<size_t> Precision, Optional<int> Width) {
- write_signed(S, N, Style, Precision, Width);
-}
+void llvm::write_longlong(raw_ostream &S, long long N, std::size_t MinWidth) {
+ if (N >= 0) {
+ write_ulonglong(S, static_cast<unsigned long long>(N), MinWidth);
+ return;
+ }
-void llvm::write_integer(raw_ostream &S, unsigned long long N,
- IntegerStyle Style, Optional<size_t> Precision,
- Optional<int> Width) {
- write_unsigned(S, N, Style, Precision, Width);
-}
+ // Avoid undefined behavior on INT64_MIN with a cast.
+ unsigned long long UN = -(unsigned long long)N;
+ if (MinWidth > 0)
+ --MinWidth;
-void llvm::write_integer(raw_ostream &S, long long N, IntegerStyle Style,
- Optional<size_t> Precision, Optional<int> Width) {
- write_signed(S, N, Style, Precision, Width);
+ char NumberBuffer[32];
+ int Len = format_to_buffer(UN, NumberBuffer);
+ int Pad = (MinWidth == 0) ? 0 : MinWidth - Len;
+ if (Pad > 0)
+ S.indent(Pad);
+ S.write('-');
+ S.write(std::end(NumberBuffer) - Len, Len);
}
-void llvm::write_hex(raw_ostream &S, uint64_t N, HexPrintStyle Style,
- Optional<size_t> Precision, Optional<int> Width) {
- const size_t kMaxWidth = 128u;
-
- size_t Prec =
- std::min(kMaxWidth, Precision.getValueOr(getDefaultPrecision(Style)));
-
+void llvm::write_hex(raw_ostream &S, unsigned long long N, std::size_t MinWidth,
+ bool Upper, bool Prefix) {
unsigned Nibbles = (64 - countLeadingZeros(N) + 3) / 4;
- bool Prefix = (Style == HexPrintStyle::PrefixLower ||
- Style == HexPrintStyle::PrefixUpper);
- bool Upper =
- (Style == HexPrintStyle::Upper || Style == HexPrintStyle::PrefixUpper);
unsigned PrefixChars = Prefix ? 2 : 0;
- unsigned NumChars = std::max(static_cast<unsigned>(Prec),
- std::max(1u, Nibbles) + PrefixChars);
+ unsigned Width = std::max(static_cast<unsigned>(MinWidth),
+ std::max(1u, Nibbles) + PrefixChars);
- char NumberBuffer[kMaxWidth];
- ::memset(NumberBuffer, '0', llvm::array_lengthof(NumberBuffer));
- if (Prefix)
- NumberBuffer[1] = 'x';
- char *EndPtr = NumberBuffer + NumChars;
+ char NumberBuffer[20] = "0x0000000000000000";
+ if (!Prefix)
+ NumberBuffer[1] = '0';
+ char *EndPtr = NumberBuffer + Width;
char *CurPtr = EndPtr;
while (N) {
unsigned char x = static_cast<unsigned char>(N) % 16;
N /= 16;
}
- writePadding(S, Width, NumChars);
- S.write(NumberBuffer, NumChars);
+ S.write(NumberBuffer, Width);
}
-void llvm::write_double(raw_ostream &S, double N, FloatStyle Style,
- Optional<size_t> Precision, Optional<int> Width) {
- size_t Prec = Precision.getValueOr(getDefaultPrecision(Style));
-
- if (std::isnan(N)) {
- writePadding(S, Width, 3);
- S << "nan";
- return;
- } else if (std::isinf(N)) {
- writePadding(S, Width, 3);
- S << "INF";
- return;
- }
-
- char Letter;
- if (Style == FloatStyle::Exponent)
- Letter = 'e';
- else if (Style == FloatStyle::ExponentUpper)
- Letter = 'E';
- else
- Letter = 'f';
-
+void llvm::write_double(raw_ostream &S, double N, std::size_t MinWidth,
+ std::size_t MinDecimals, FloatStyle Style) {
+ char Letter = (Style == FloatStyle::Exponent) ? 'e' : 'f';
SmallString<8> Spec;
llvm::raw_svector_ostream Out(Spec);
- Out << "%." << Prec << Letter;
-
- if (Style == FloatStyle::Exponent || Style == FloatStyle::ExponentUpper) {
+ Out << '%';
+ if (MinWidth > 0)
+ Out << MinWidth;
+ if (MinDecimals > 0)
+ Out << '.' << MinDecimals;
+ Out << Letter;
+
+ if (Style == FloatStyle::Exponent) {
#ifdef _WIN32
// On MSVCRT and compatible, output of %e is incompatible to Posix
// by default. Number of exponent digits should be at least 2. "%+03d"
#if defined(__MINGW32__)
// FIXME: It should be generic to C++11.
if (N == 0.0 && std::signbit(N)) {
- const char *NegativeZero = "-0.000000e+00";
- writePadding(S, Width, strlen(NegativeZero));
- S << NegativeZero;
+ S << "-0.000000e+00";
return;
}
#else
// negative zero
if (fpcl == _FPCLASS_NZ) {
- const char *NegativeZero = "-0.000000e+00";
- writePadding(S, Width, strlen(NegativeZero));
- S << NegativeZero;
+ S << "-0.000000e+00";
return;
}
#endif
- char buf[32];
+ char buf[16];
unsigned len;
len = format(Spec.c_str(), N).snprint(buf, sizeof(buf));
if (len <= sizeof(buf) - 2) {
- if (len >= 5 && (buf[len - 5] == 'e' || buf[len - 5] == 'E') &&
- buf[len - 3] == '0') {
+ if (len >= 5 && buf[len - 5] == 'e' && buf[len - 3] == '0') {
int cs = buf[len - 4];
if (cs == '+' || cs == '-') {
int c1 = buf[len - 2];
}
}
}
- writePadding(S, Width, len);
S << buf;
return;
}
#endif
}
- if (Style == FloatStyle::Percent)
- N *= 100.0;
-
- char Buf[32];
- unsigned Len;
- Len = format(Spec.c_str(), N).snprint(Buf, sizeof(Buf));
- if (Style == FloatStyle::Percent)
- ++Len;
- writePadding(S, Width, Len);
- S << Buf;
- if (Style == FloatStyle::Percent)
- S << '%';
-}
-
-IntegerStyle llvm::hexStyleToIntHexStyle(HexPrintStyle S) {
- switch (S) {
- case HexPrintStyle::Upper:
- return IntegerStyle::HexUpperNoPrefix;
- case HexPrintStyle::Lower:
- return IntegerStyle::HexLowerNoPrefix;
- case HexPrintStyle::PrefixUpper:
- return IntegerStyle::HexUpperPrefix;
- case HexPrintStyle::PrefixLower:
- return IntegerStyle::HexLowerPrefix;
- }
- LLVM_BUILTIN_UNREACHABLE;
-}
-
-size_t llvm::getDefaultPrecision(FloatStyle Style) {
- switch (Style) {
- case FloatStyle::Exponent:
- case FloatStyle::ExponentUpper:
- return 6; // Number of decimal places.
- case FloatStyle::Fixed:
- case FloatStyle::Percent:
- return 2; // Number of decimal places.
- }
- LLVM_BUILTIN_UNREACHABLE;
-}
-
-size_t llvm::getDefaultPrecision(IntegerStyle Style) {
- switch (Style) {
- case IntegerStyle::Exponent:
- case IntegerStyle::ExponentUpper:
- return 6; // Number of decimal places.
- case IntegerStyle::Number:
- case IntegerStyle::Integer:
- return 0; // Minimum number of digits required.
- case IntegerStyle::Fixed:
- return 2; // Number of decimal places.
- case IntegerStyle::Percent:
- return 0; // Number of decimal places.
- case IntegerStyle::HexLowerNoPrefix:
- case IntegerStyle::HexLowerPrefix:
- case IntegerStyle::HexUpperNoPrefix:
- case IntegerStyle::HexUpperPrefix:
- return getDefaultPrecision(intHexStyleToHexStyle(Style));
- }
- LLVM_BUILTIN_UNREACHABLE;
-}
-
-size_t llvm::getDefaultPrecision(HexPrintStyle) {
- // Number of digits in the resulting string.
- return 0;
+ S << format(Spec.c_str(), N);
}
}
raw_ostream &raw_ostream::operator<<(unsigned long N) {
- write_integer(*this, static_cast<uint64_t>(N), IntegerStyle::Integer);
+ write_ulong(*this, N, 0);
return *this;
}
raw_ostream &raw_ostream::operator<<(long N) {
- write_integer(*this, static_cast<int64_t>(N), IntegerStyle::Integer);
+ write_long(*this, N, 0);
return *this;
}
raw_ostream &raw_ostream::operator<<(unsigned long long N) {
- write_integer(*this, static_cast<uint64_t>(N), IntegerStyle::Integer);
+ write_ulonglong(*this, N, 0);
return *this;
}
raw_ostream &raw_ostream::operator<<(long long N) {
- write_integer(*this, static_cast<int64_t>(N), IntegerStyle::Integer);
+ write_longlong(*this, N, 0);
return *this;
}
raw_ostream &raw_ostream::write_hex(unsigned long long N) {
- llvm::write_hex(*this, N, HexPrintStyle::Lower);
+ llvm::write_hex(*this, N, 0, false, false);
return *this;
}
}
raw_ostream &raw_ostream::operator<<(const void *P) {
- llvm::write_hex(*this, (uintptr_t)P, HexPrintStyle::PrefixLower);
+ llvm::write_hex(*this, (uintptr_t)P, 0, false, true);
return *this;
}
raw_ostream &raw_ostream::operator<<(double N) {
- llvm::write_double(*this, N, FloatStyle::Exponent);
+ llvm::write_double(*this, N, 0, 0, FloatStyle::Exponent);
return *this;
}
raw_ostream &raw_ostream::operator<<(const FormattedNumber &FN) {
if (FN.Hex) {
- HexPrintStyle Style;
- if (FN.Upper && FN.HexPrefix)
- Style = HexPrintStyle::PrefixUpper;
- else if (FN.Upper && !FN.HexPrefix)
- Style = HexPrintStyle::Upper;
- else if (!FN.Upper && FN.HexPrefix)
- Style = HexPrintStyle::PrefixLower;
- else
- Style = HexPrintStyle::Lower;
- llvm::write_hex(*this, FN.HexValue, Style, FN.Width, None);
+ llvm::write_hex(*this, FN.HexValue, FN.Width, FN.Upper, FN.HexPrefix);
} else {
- llvm::write_integer(*this, FN.DecValue, IntegerStyle::Integer, None,
- FN.Width);
+ llvm::write_longlong(*this, FN.DecValue, FN.Width);
}
return *this;
}
MathExtrasTest.cpp
MemoryBufferTest.cpp
MemoryTest.cpp
- NativeFormatTests.cpp
Path.cpp
ProcessTest.cpp
ProgramTest.cpp
+++ /dev/null
-//===- llvm/unittest/Support/NativeFormatTests.cpp - formatting tests -----===//
-//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "llvm/ADT/SmallString.h"
-#include "llvm/Support/NativeFormatting.h"
-#include "llvm/Support/raw_ostream.h"
-#include "gtest/gtest.h"
-
-#include <type_traits>
-
-using namespace llvm;
-
-namespace {
-
-template <typename T>
-std::string format_number(T N, IntegerStyle Style,
- Optional<size_t> Precision = None,
- Optional<int> Width = None) {
- std::string S;
- llvm::raw_string_ostream Str(S);
- write_integer(Str, N, Style, Precision, Width);
- Str.flush();
- return S;
-}
-
-template <typename T>
-typename std::enable_if<std::is_pointer<T>::value, std::string>::type
-format_number(T N, HexPrintStyle Style, Optional<size_t> Precision = None,
- Optional<int> Width = None) {
- IntegerStyle IS = hexStyleToIntHexStyle(Style);
- return format_number(reinterpret_cast<uintptr_t>(N), IS, Precision, Width);
-}
-
-std::string format_number(uint64_t N, HexPrintStyle Style,
- Optional<size_t> Precision = None,
- Optional<int> Width = None) {
- std::string S;
- llvm::raw_string_ostream Str(S);
- write_hex(Str, N, Style, Precision, Width);
- Str.flush();
- return S;
-}
-
-std::string format_number(double D, FloatStyle Style,
- Optional<size_t> Precision = None,
- Optional<int> Width = None) {
- std::string S;
- llvm::raw_string_ostream Str(S);
- write_double(Str, D, Style, Precision, Width);
- Str.flush();
- return S;
-}
-
-// Test basic number formatting with various styles and default width and
-// precision.
-TEST(NativeFormatTest, BasicIntegerTests) {
- // Simple fixed point integers. Default precision is 2.
- EXPECT_EQ("0.00", format_number(0, IntegerStyle::Fixed));
- EXPECT_EQ("2425.00", format_number(2425, IntegerStyle::Fixed));
- EXPECT_EQ("-2425.00", format_number(-2425, IntegerStyle::Fixed));
-
- EXPECT_EQ("0.00", format_number(0LL, IntegerStyle::Fixed));
- EXPECT_EQ("257257257235709.00",
- format_number(257257257235709LL, IntegerStyle::Fixed));
- EXPECT_EQ("-257257257235709.00",
- format_number(-257257257235709LL, IntegerStyle::Fixed));
-
- // Simple integers with no decimal. Default precision is 0.
- EXPECT_EQ("0", format_number(0, IntegerStyle::Integer));
- EXPECT_EQ("2425", format_number(2425, IntegerStyle::Integer));
- EXPECT_EQ("-2425", format_number(-2425, IntegerStyle::Integer));
-
- EXPECT_EQ("0", format_number(0LL, IntegerStyle::Integer));
- EXPECT_EQ("257257257235709",
- format_number(257257257235709LL, IntegerStyle::Integer));
- EXPECT_EQ("-257257257235709",
- format_number(-257257257235709LL, IntegerStyle::Integer));
-
- // Exponent based integers. Default precision is 6.
- EXPECT_EQ("3.700000e+01", format_number(37, IntegerStyle::Exponent));
- EXPECT_EQ("4.238000e+03", format_number(4238, IntegerStyle::Exponent));
- EXPECT_EQ("3.700000E+01", format_number(37, IntegerStyle::ExponentUpper));
- EXPECT_EQ("4.238000E+03", format_number(4238, IntegerStyle::ExponentUpper));
-
- // Number formatting. Default precision is 0.
- EXPECT_EQ("0", format_number(0, IntegerStyle::Number));
- EXPECT_EQ("2,425", format_number(2425, IntegerStyle::Number));
- EXPECT_EQ("-2,425", format_number(-2425, IntegerStyle::Number));
- EXPECT_EQ("257,257,257,235,709",
- format_number(257257257235709LL, IntegerStyle::Number));
- EXPECT_EQ("-257,257,257,235,709",
- format_number(-257257257235709LL, IntegerStyle::Number));
-
- // Percent formatting. Default precision is 0.
- EXPECT_EQ("0%", format_number(0, IntegerStyle::Percent));
- EXPECT_EQ("100%", format_number(1, IntegerStyle::Percent));
- EXPECT_EQ("-100%", format_number(-1, IntegerStyle::Percent));
-
- // Hex formatting. Default precision is 0.
- // lower case, prefix.
- EXPECT_EQ("0x0", format_number(0, HexPrintStyle::PrefixLower));
- EXPECT_EQ("0xbeef", format_number(0xbeefLL, HexPrintStyle::PrefixLower));
- EXPECT_EQ("0xdeadbeef",
- format_number(0xdeadbeefLL, HexPrintStyle::PrefixLower));
-
- // upper-case, prefix.
- EXPECT_EQ("0x0", format_number(0, HexPrintStyle::PrefixUpper));
- EXPECT_EQ("0xBEEF", format_number(0xbeefLL, HexPrintStyle::PrefixUpper));
- EXPECT_EQ("0xDEADBEEF",
- format_number(0xdeadbeefLL, HexPrintStyle::PrefixUpper));
-
- // lower-case, no prefix
- EXPECT_EQ("0", format_number(0, HexPrintStyle::Lower));
- EXPECT_EQ("beef", format_number(0xbeefLL, HexPrintStyle::Lower));
- EXPECT_EQ("deadbeef", format_number(0xdeadbeefLL, HexPrintStyle::Lower));
-
- // upper-case, no prefix.
- EXPECT_EQ("0", format_number(0, HexPrintStyle::Upper));
- EXPECT_EQ("BEEF", format_number(0xbeef, HexPrintStyle::Upper));
- EXPECT_EQ("DEADBEEF", format_number(0xdeadbeef, HexPrintStyle::Upper));
-
- EXPECT_EQ("0xFFFFFFFF", format_number(-1, IntegerStyle::HexUpperPrefix));
-}
-
-// Test pointer type formatting with various styles and default width and
-// precision.
-TEST(NativeFormatTest, BasicPointerTests) {
- // lower-case, prefix
- EXPECT_EQ("0x0", format_number((void *)nullptr, HexPrintStyle::PrefixLower));
- EXPECT_EQ("0xbeef",
- format_number((void *)0xbeefLL, HexPrintStyle::PrefixLower));
- EXPECT_EQ("0xdeadbeef",
- format_number((void *)0xdeadbeefLL, HexPrintStyle::PrefixLower));
-
- // upper-case, prefix.
- EXPECT_EQ("0x0", format_number((void *)nullptr, HexPrintStyle::PrefixUpper));
- EXPECT_EQ("0xBEEF",
- format_number((void *)0xbeefLL, HexPrintStyle::PrefixUpper));
- EXPECT_EQ("0xDEADBEEF",
- format_number((void *)0xdeadbeefLL, HexPrintStyle::PrefixUpper));
-
- // lower-case, no prefix
- EXPECT_EQ("0", format_number((void *)nullptr, HexPrintStyle::Lower));
- EXPECT_EQ("beef", format_number((void *)0xbeefLL, HexPrintStyle::Lower));
- EXPECT_EQ("deadbeef",
- format_number((void *)0xdeadbeefLL, HexPrintStyle::Lower));
-
- // upper-case, no prefix.
- EXPECT_EQ("0", format_number((void *)nullptr, HexPrintStyle::Upper));
- EXPECT_EQ("BEEF", format_number((void *)0xbeefLL, HexPrintStyle::Upper));
- EXPECT_EQ("DEADBEEF",
- format_number((void *)0xdeadbeefLL, HexPrintStyle::Upper));
-}
-
-// Test basic floating point formatting with various styles and default width
-// and precision.
-TEST(NativeFormatTest, BasicFloatingPointTests) {
- // Double
- EXPECT_EQ("0.000000e+00", format_number(0.0, FloatStyle::Exponent));
- EXPECT_EQ("-0.000000e+00", format_number(-0.0, FloatStyle::Exponent));
- EXPECT_EQ("1.100000e+00", format_number(1.1, FloatStyle::Exponent));
- EXPECT_EQ("1.100000E+00", format_number(1.1, FloatStyle::ExponentUpper));
-
- // Default precision is 2 for floating points.
- EXPECT_EQ("1.10", format_number(1.1, FloatStyle::Fixed));
- EXPECT_EQ("1.34", format_number(1.34, FloatStyle::Fixed));
- EXPECT_EQ("1.34", format_number(1.344, FloatStyle::Fixed));
- EXPECT_EQ("1.35", format_number(1.346, FloatStyle::Fixed));
-}
-
-// Test common boundary cases and min/max conditions.
-TEST(NativeFormatTest, BoundaryTests) {
- // Min and max.
- EXPECT_EQ("18446744073709551615",
- format_number(UINT64_MAX, IntegerStyle::Integer));
-
- EXPECT_EQ("9223372036854775807",
- format_number(INT64_MAX, IntegerStyle::Integer));
- EXPECT_EQ("-9223372036854775808",
- format_number(INT64_MIN, IntegerStyle::Integer));
-
- EXPECT_EQ("4294967295", format_number(UINT32_MAX, IntegerStyle::Integer));
- EXPECT_EQ("2147483647", format_number(INT32_MAX, IntegerStyle::Integer));
- EXPECT_EQ("-2147483648", format_number(INT32_MIN, IntegerStyle::Integer));
-
- EXPECT_EQ("nan", format_number(std::numeric_limits<double>::quiet_NaN(),
- FloatStyle::Fixed));
- EXPECT_EQ("INF", format_number(std::numeric_limits<double>::infinity(),
- FloatStyle::Fixed));
-}
-
-TEST(NativeFormatTest, HexTests) {
- // Test hex formatting with different widths and precisions.
-
- // Precision less than the value should print the full value anyway.
- EXPECT_EQ("0x0", format_number(0, IntegerStyle::HexLowerPrefix, 0));
- EXPECT_EQ("0xabcde", format_number(0xABCDE, IntegerStyle::HexLowerPrefix, 3));
-
- // Precision greater than the value should pad with 0s.
- // TODO: The prefix should not be counted in the precision. But unfortunately
- // it is and we have to live with it unless we fix all existing users of
- // prefixed hex formatting.
- EXPECT_EQ("0x000", format_number(0, IntegerStyle::HexLowerPrefix, 5));
- EXPECT_EQ("0x0abcde",
- format_number(0xABCDE, IntegerStyle::HexLowerPrefix, 8));
-
- EXPECT_EQ("00000", format_number(0, IntegerStyle::HexLowerNoPrefix, 5));
- EXPECT_EQ("000abcde",
- format_number(0xABCDE, IntegerStyle::HexLowerNoPrefix, 8));
-
- // Try printing more digits than can fit in a uint64.
- EXPECT_EQ("0x00000000000000abcde",
- format_number(0xABCDE, IntegerStyle::HexLowerPrefix, 21));
-
- // Width less than the amount to be printed should print the full amount.
- EXPECT_EQ("0x0", format_number(0, IntegerStyle::HexLowerPrefix, 0, 0));
- EXPECT_EQ("0xabcde",
- format_number(0xABCDE, IntegerStyle::HexLowerPrefix, 0, 0));
-
- // Width greater than the value should pad with spaces.
- EXPECT_EQ(" 0x0", format_number(0, IntegerStyle::HexLowerPrefix, 0, 5));
- EXPECT_EQ(" 0xabcde",
- format_number(0xABCDE, IntegerStyle::HexLowerPrefix, 0, 8));
-
- // Should also work with no prefix.
- EXPECT_EQ(" 000", format_number(0, IntegerStyle::HexLowerNoPrefix, 3, 5));
- EXPECT_EQ(" 0abcde",
- format_number(0xABCDE, IntegerStyle::HexLowerNoPrefix, 6, 9));
-
- // And with pointers.
- EXPECT_EQ(" 0x000",
- format_number((void *)nullptr, HexPrintStyle::PrefixLower, 5, 7));
-
- // Try printing more digits than can fit in a uint64.
- EXPECT_EQ(" 0x000abcde",
- format_number(0xABCDE, IntegerStyle::HexLowerPrefix, 10, 15));
-}
-
-TEST(NativeFormatTest, IntegerTests) {
- // Test plain integer formatting with non-default widths and precisions.
-
- // Too low precision should print the whole number.
- EXPECT_EQ("-10", format_number(-10, IntegerStyle::Integer, 1));
-
- // Additional precision should padd with 0s.
- EXPECT_EQ("-00010", format_number(-10, IntegerStyle::Integer, 5));
- EXPECT_EQ("-00100", format_number(-100, IntegerStyle::Integer, 5));
- EXPECT_EQ("-01000", format_number(-1000, IntegerStyle::Integer, 5));
- EXPECT_EQ("-001234567890",
- format_number(-1234567890, IntegerStyle::Integer, 12));
- EXPECT_EQ("00010", format_number(10, IntegerStyle::Integer, 5));
- EXPECT_EQ("00100", format_number(100, IntegerStyle::Integer, 5));
- EXPECT_EQ("01000", format_number(1000, IntegerStyle::Integer, 5));
- EXPECT_EQ("001234567890",
- format_number(1234567890, IntegerStyle::Integer, 12));
-
- // Too low width should print the full number.
- EXPECT_EQ("-10", format_number(-10, IntegerStyle::Integer, None, 2));
-
- // Additional width should padd with spaces.
- EXPECT_EQ(" -00010", format_number(-10, IntegerStyle::Integer, 5, 8));
- EXPECT_EQ(" -00100", format_number(-100, IntegerStyle::Integer, 5, 8));
- EXPECT_EQ(" -01000", format_number(-1000, IntegerStyle::Integer, 5, 8));
- EXPECT_EQ(" -001234567890",
- format_number(-1234567890, IntegerStyle::Integer, 12, 14));
- EXPECT_EQ(" 00010", format_number(10, IntegerStyle::Integer, 5, 8));
- EXPECT_EQ(" 00100", format_number(100, IntegerStyle::Integer, 5, 8));
- EXPECT_EQ(" 01000", format_number(1000, IntegerStyle::Integer, 5, 8));
- EXPECT_EQ(" 001234567890",
- format_number(1234567890, IntegerStyle::Integer, 12, 14));
-}
-
-TEST(NativeFormatTest, CommaTests) {
- // Test comma grouping with default widths and precisions.
- EXPECT_EQ("0", format_number(0, IntegerStyle::Number));
- EXPECT_EQ("10", format_number(10, IntegerStyle::Number));
- EXPECT_EQ("100", format_number(100, IntegerStyle::Number));
- EXPECT_EQ("1,000", format_number(1000, IntegerStyle::Number));
- EXPECT_EQ("1,234,567,890", format_number(1234567890, IntegerStyle::Number));
-
- // Test comma grouping with non-default widths and precisions.
- EXPECT_EQ("-10", format_number(-10, IntegerStyle::Number));
- EXPECT_EQ("-100", format_number(-100, IntegerStyle::Number));
- EXPECT_EQ("-1,000", format_number(-1000, IntegerStyle::Number));
- EXPECT_EQ("-1,234,567,890", format_number(-1234567890, IntegerStyle::Number));
-
- EXPECT_EQ(" 1,000", format_number(1000, IntegerStyle::Number, None, 7));
- EXPECT_EQ(" -1,000", format_number(-1000, IntegerStyle::Number, None, 7));
- EXPECT_EQ(" -0,001,000", format_number(-1000, IntegerStyle::Number, 7, 11));
- EXPECT_EQ(" 0,001,000", format_number(1000, IntegerStyle::Number, 7, 11));
-}
-
-TEST(NativeFormatTest, PercentTests) {
- // Integer percents.
- EXPECT_EQ("0%", format_number(0, IntegerStyle::Percent));
- EXPECT_EQ("0.00%", format_number(0, IntegerStyle::Percent, 2));
- EXPECT_EQ(" 0.00%", format_number(0, IntegerStyle::Percent, 2, 7));
-
- EXPECT_EQ(" 100.00%", format_number(1, IntegerStyle::Percent, 2, 8));
-
- EXPECT_EQ(" 100%", format_number(1, IntegerStyle::Percent, None, 8));
- EXPECT_EQ(" 100.000%", format_number(1, IntegerStyle::Percent, 3, 9));
-
- // Floating point percents. Default precision is 2 for floating point types,
- // even for 0.
- EXPECT_EQ("0.00%", format_number(0.0, FloatStyle::Percent));
- EXPECT_EQ("0%", format_number(0.0, FloatStyle::Percent, 0));
- EXPECT_EQ(" 0.00%", format_number(0.0, FloatStyle::Percent, 2, 6));
- EXPECT_EQ(" 4.2%", format_number(.042379, FloatStyle::Percent, 1, 5));
- EXPECT_EQ("4.24%", format_number(.042379, FloatStyle::Percent, 2, 5));
- EXPECT_EQ("4.238%", format_number(.042379, FloatStyle::Percent, 3, 5));
- EXPECT_EQ(" 0.424%", format_number(.0042379, FloatStyle::Percent, 3, 8));
- EXPECT_EQ(" -0.424%", format_number(-.0042379, FloatStyle::Percent, 3, 8));
-}
-
-TEST(NativeFormatTest, FixedTests) {
- // Integer fixed numbers. Default precision is 2. Make sure no decimal
- // is printed with 0 precision.
- EXPECT_EQ("1.00", format_number(1, IntegerStyle::Fixed));
- EXPECT_EQ("1", format_number(1, IntegerStyle::Fixed, 0));
- EXPECT_EQ(" 1.00", format_number(1, IntegerStyle::Fixed, 2, 6));
- EXPECT_EQ("-1.00", format_number(-1, IntegerStyle::Fixed));
- EXPECT_EQ("-1.00", format_number(-1, IntegerStyle::Fixed, 2));
- EXPECT_EQ(" -1.00", format_number(-1, IntegerStyle::Fixed, 2, 6));
-
- // Float fixed numbers. Default precision is 2.
- EXPECT_EQ("0.00", format_number(0.0, FloatStyle::Fixed));
- EXPECT_EQ("1.00", format_number(1.0, FloatStyle::Fixed));
-
- // But can be forced to 0
- EXPECT_EQ("0", format_number(0.0, FloatStyle::Fixed, 0));
-
- // It should round up when appropriate.
- EXPECT_EQ("3.14", format_number(3.1415, FloatStyle::Fixed, 2));
- EXPECT_EQ("3.142", format_number(3.1415, FloatStyle::Fixed, 3));
-
- // Padding should work properly with both positive and negative numbers.
- EXPECT_EQ(" 3.14", format_number(3.1415, FloatStyle::Fixed, 2, 7));
- EXPECT_EQ(" 3.142", format_number(3.1415, FloatStyle::Fixed, 3, 7));
- EXPECT_EQ(" -3.14", format_number(-3.1415, FloatStyle::Fixed, 2, 7));
- EXPECT_EQ(" -3.142", format_number(-3.1415, FloatStyle::Fixed, 3, 7));
-}
-}
projects / platform / upstream / llvm.git / commitdiff