forked from OSchip/llvm-project
Revert formatting changes.
This reverts r288425 and r284428 as they are causing test crashes on some systems. llvm-svn: 284429
This commit is contained in:
Zachary Turner
parent
47e2c0a9cb
commit
9d58e362d2
|
|
@ -10,48 +10,22 @@
|
|||
#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 HexStyle { Upper, Lower, PrefixUpper, PrefixLower };
|
||||
enum class FloatStyle { Exponent, Decimal };
|
||||
|
||||
IntegerStyle hexStyleToIntHexStyle(HexStyle S);
|
||||
|
||||
size_t getDefaultPrecision(FloatStyle Style);
|
||||
size_t getDefaultPrecision(IntegerStyle Style);
|
||||
size_t getDefaultPrecision(HexStyle Style);
|
||||
|
||||
void write_ulong(raw_ostream &S, unsigned long N, IntegerStyle Style,
|
||||
Optional<size_t> Precision = None, Optional<int> Width = None);
|
||||
void write_long(raw_ostream &S, long N, IntegerStyle Style,
|
||||
Optional<size_t> Precision = None, Optional<int> Width = None);
|
||||
void write_ulonglong(raw_ostream &S, unsigned long long N, IntegerStyle Style,
|
||||
Optional<size_t> Precision = None,
|
||||
Optional<int> Width = None);
|
||||
void write_longlong(raw_ostream &S, long long N, IntegerStyle Style,
|
||||
Optional<size_t> Precision = None,
|
||||
Optional<int> Width = None);
|
||||
void write_hex(raw_ostream &S, unsigned long long N, HexStyle 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);
|
||||
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
|
||||
|
|
@ -9,248 +9,107 @@
|
|||
|
||||
#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 HexStyle intHexStyleToHexStyle(IntegerStyle S) {
|
||||
assert(isHexStyle(S));
|
||||
switch (S) {
|
||||
case IntegerStyle::HexLowerNoPrefix:
|
||||
return HexStyle::Lower;
|
||||
case IntegerStyle::HexLowerPrefix:
|
||||
return HexStyle::PrefixLower;
|
||||
case IntegerStyle::HexUpperNoPrefix:
|
||||
return HexStyle::Upper;
|
||||
case IntegerStyle::HexUpperPrefix:
|
||||
return HexStyle::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);
|
||||
}
|
||||
}
|
||||
|
||||
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 << '%';
|
||||
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_unsigned(raw_ostream &S, T N, IntegerStyle Style,
|
||||
Optional<size_t> Precision, Optional<int> Width,
|
||||
bool IsNegative = false) {
|
||||
write_unsigned_impl(S, N, Style, Precision, Width, IsNegative);
|
||||
}
|
||||
|
||||
static void write_unsigned(raw_ostream &S, uint64_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);
|
||||
return;
|
||||
}
|
||||
write_unsigned_impl(S, N, Style, Precision, Width, IsNegative);
|
||||
}
|
||||
|
||||
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_ulong(raw_ostream &S, unsigned long N, IntegerStyle Style,
|
||||
Optional<size_t> Precision, Optional<int> Width) {
|
||||
write_unsigned(S, N, Style, Precision, Width);
|
||||
}
|
||||
|
||||
void llvm::write_long(raw_ostream &S, long N, IntegerStyle Style,
|
||||
Optional<size_t> Precision, Optional<int> Width) {
|
||||
write_signed(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_ulonglong(raw_ostream &S, unsigned long long N,
|
||||
IntegerStyle Style, Optional<size_t> Precision,
|
||||
Optional<int> Width) {
|
||||
write_unsigned(S, N, Style, Precision, Width);
|
||||
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;
|
||||
}
|
||||
|
||||
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_longlong(raw_ostream &S, long 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;
|
||||
}
|
||||
|
||||
// Avoid undefined behavior on INT64_MIN with a cast.
|
||||
unsigned long long UN = -(unsigned long long)N;
|
||||
if (MinWidth > 0)
|
||||
--MinWidth;
|
||||
|
||||
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, unsigned long long N, HexStyle Style,
|
||||
Optional<size_t> Precision, Optional<int> Width) {
|
||||
constexpr 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 == HexStyle::PrefixLower || Style == HexStyle::PrefixUpper);
|
||||
bool Upper = (Style == HexStyle::Upper || Style == HexStyle::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;
|
||||
|
|
@ -258,37 +117,22 @@ void llvm::write_hex(raw_ostream &S, unsigned long long N, HexStyle Style,
|
|||
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;
|
||||
Out << '%';
|
||||
if (MinWidth > 0)
|
||||
Out << MinWidth;
|
||||
if (MinDecimals > 0)
|
||||
Out << '.' << MinDecimals;
|
||||
Out << Letter;
|
||||
|
||||
if (Style == FloatStyle::Exponent || Style == FloatStyle::ExponentUpper) {
|
||||
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"
|
||||
|
|
@ -296,9 +140,7 @@ void llvm::write_double(raw_ostream &S, double N, FloatStyle Style,
|
|||
#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
|
||||
|
|
@ -306,19 +148,16 @@ void llvm::write_double(raw_ostream &S, double N, FloatStyle Style,
|
|||
|
||||
// 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];
|
||||
|
|
@ -332,75 +171,11 @@ void llvm::write_double(raw_ostream &S, double N, FloatStyle Style,
|
|||
}
|
||||
}
|
||||
}
|
||||
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(HexStyle S) {
|
||||
switch (S) {
|
||||
case HexStyle::Upper:
|
||||
return IntegerStyle::HexUpperNoPrefix;
|
||||
case HexStyle::Lower:
|
||||
return IntegerStyle::HexLowerNoPrefix;
|
||||
case HexStyle::PrefixUpper:
|
||||
return IntegerStyle::HexUpperPrefix;
|
||||
case HexStyle::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(HexStyle) {
|
||||
// Number of digits in the resulting string.
|
||||
return 0;
|
||||
S << format(Spec.c_str(), N);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -114,27 +114,27 @@ void raw_ostream::SetBufferAndMode(char *BufferStart, size_t Size,
|
|||
}
|
||||
|
||||
raw_ostream &raw_ostream::operator<<(unsigned long N) {
|
||||
write_ulong(*this, N, IntegerStyle::Integer);
|
||||
write_ulong(*this, N, 0);
|
||||
return *this;
|
||||
}
|
||||
|
||||
raw_ostream &raw_ostream::operator<<(long N) {
|
||||
write_long(*this, N, IntegerStyle::Integer);
|
||||
write_long(*this, N, 0);
|
||||
return *this;
|
||||
}
|
||||
|
||||
raw_ostream &raw_ostream::operator<<(unsigned long long N) {
|
||||
write_ulonglong(*this, N, IntegerStyle::Integer);
|
||||
write_ulonglong(*this, N, 0);
|
||||
return *this;
|
||||
}
|
||||
|
||||
raw_ostream &raw_ostream::operator<<(long long N) {
|
||||
write_longlong(*this, 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, HexStyle::Lower);
|
||||
llvm::write_hex(*this, N, 0, false, false);
|
||||
return *this;
|
||||
}
|
||||
|
||||
|
|
@ -179,12 +179,12 @@ raw_ostream &raw_ostream::write_escaped(StringRef Str,
|
|||
}
|
||||
|
||||
raw_ostream &raw_ostream::operator<<(const void *P) {
|
||||
llvm::write_hex(*this, (uintptr_t)P, HexStyle::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;
|
||||
}
|
||||
|
||||
|
|
@ -331,19 +331,9 @@ raw_ostream &raw_ostream::operator<<(const FormattedString &FS) {
|
|||
|
||||
raw_ostream &raw_ostream::operator<<(const FormattedNumber &FN) {
|
||||
if (FN.Hex) {
|
||||
HexStyle Style;
|
||||
if (FN.Upper && FN.HexPrefix)
|
||||
Style = HexStyle::PrefixUpper;
|
||||
else if (FN.Upper && !FN.HexPrefix)
|
||||
Style = HexStyle::Upper;
|
||||
else if (!FN.Upper && FN.HexPrefix)
|
||||
Style = HexStyle::PrefixLower;
|
||||
else
|
||||
Style = HexStyle::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_longlong(*this, FN.DecValue, IntegerStyle::Integer, None,
|
||||
FN.Width);
|
||||
llvm::write_longlong(*this, FN.DecValue, FN.Width);
|
||||
}
|
||||
return *this;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -28,7 +28,6 @@ add_llvm_unittest(SupportTests
|
|||
MathExtrasTest.cpp
|
||||
MemoryBufferTest.cpp
|
||||
MemoryTest.cpp
|
||||
NativeFormatTests.cpp
|
||||
Path.cpp
|
||||
ProcessTest.cpp
|
||||
ProgramTest.cpp
|
||||
|
|
|
|||
|
|
@ -1,386 +0,0 @@
|
|||
//===- 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>
|
||||
typename std::enable_if<std::is_signed<T>::value, std::string>::type
|
||||
format_number(T N, IntegerStyle Style, Optional<size_t> Precision = None,
|
||||
Optional<int> Width = None) {
|
||||
return format_number(static_cast<long>(N), Style, Precision, Width);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
typename std::enable_if<std::is_unsigned<T>::value, std::string>::type
|
||||
format_number(T N, IntegerStyle Style, Optional<size_t> Precision = None,
|
||||
Optional<int> Width = None) {
|
||||
return format_number(static_cast<unsigned long>(N), Style, Precision, Width);
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
typename std::enable_if<std::is_pointer<T>::value, std::string>::type
|
||||
format_number(T N, HexStyle 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(unsigned long N, IntegerStyle Style,
|
||||
Optional<size_t> Precision = None,
|
||||
Optional<int> Width = None) {
|
||||
std::string S;
|
||||
llvm::raw_string_ostream Str(S);
|
||||
write_ulong(Str, N, Style, Precision, Width);
|
||||
Str.flush();
|
||||
return S;
|
||||
}
|
||||
|
||||
std::string format_number(long N, IntegerStyle Style,
|
||||
Optional<size_t> Precision = None,
|
||||
Optional<int> Width = None) {
|
||||
std::string S;
|
||||
llvm::raw_string_ostream Str(S);
|
||||
write_long(Str, N, Style, Precision, Width);
|
||||
Str.flush();
|
||||
return S;
|
||||
}
|
||||
|
||||
std::string format_number(unsigned long long N, IntegerStyle Style,
|
||||
Optional<size_t> Precision = None,
|
||||
Optional<int> Width = None) {
|
||||
std::string S;
|
||||
llvm::raw_string_ostream Str(S);
|
||||
write_ulonglong(Str, N, Style, Precision, Width);
|
||||
Str.flush();
|
||||
return S;
|
||||
}
|
||||
|
||||
std::string format_number(long long N, IntegerStyle Style,
|
||||
Optional<size_t> Precision = None,
|
||||
Optional<int> Width = None) {
|
||||
std::string S;
|
||||
llvm::raw_string_ostream Str(S);
|
||||
write_longlong(Str, N, Style, Precision, Width);
|
||||
Str.flush();
|
||||
return S;
|
||||
}
|
||||
|
||||
std::string format_number(unsigned long long N, HexStyle 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, HexStyle::PrefixLower));
|
||||
EXPECT_EQ("0xbeef", format_number(0xbeefLL, HexStyle::PrefixLower));
|
||||
EXPECT_EQ("0xdeadbeef", format_number(0xdeadbeefLL, HexStyle::PrefixLower));
|
||||
|
||||
// upper-case, prefix.
|
||||
EXPECT_EQ("0x0", format_number(0, HexStyle::PrefixUpper));
|
||||
EXPECT_EQ("0xBEEF", format_number(0xbeefLL, HexStyle::PrefixUpper));
|
||||
EXPECT_EQ("0xDEADBEEF", format_number(0xdeadbeefLL, HexStyle::PrefixUpper));
|
||||
|
||||
// lower-case, no prefix
|
||||
EXPECT_EQ("0", format_number(0, HexStyle::Lower));
|
||||
EXPECT_EQ("beef", format_number(0xbeefLL, HexStyle::Lower));
|
||||
EXPECT_EQ("deadbeef", format_number(0xdeadbeefLL, HexStyle::Lower));
|
||||
|
||||
// upper-case, no prefix.
|
||||
EXPECT_EQ("0", format_number(0, HexStyle::Upper));
|
||||
EXPECT_EQ("BEEF", format_number(0xbeef, HexStyle::Upper));
|
||||
EXPECT_EQ("DEADBEEF", format_number(0xdeadbeef, HexStyle::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, HexStyle::PrefixLower));
|
||||
EXPECT_EQ("0xbeef", format_number((void *)0xbeefLL, HexStyle::PrefixLower));
|
||||
EXPECT_EQ("0xdeadbeef",
|
||||
format_number((void *)0xdeadbeefLL, HexStyle::PrefixLower));
|
||||
|
||||
// upper-case, prefix.
|
||||
EXPECT_EQ("0x0", format_number((void *)nullptr, HexStyle::PrefixUpper));
|
||||
EXPECT_EQ("0xBEEF", format_number((void *)0xbeefLL, HexStyle::PrefixUpper));
|
||||
EXPECT_EQ("0xDEADBEEF",
|
||||
format_number((void *)0xdeadbeefLL, HexStyle::PrefixUpper));
|
||||
|
||||
// lower-case, no prefix
|
||||
EXPECT_EQ("0", format_number((void *)nullptr, HexStyle::Lower));
|
||||
EXPECT_EQ("beef", format_number((void *)0xbeefLL, HexStyle::Lower));
|
||||
EXPECT_EQ("deadbeef", format_number((void *)0xdeadbeefLL, HexStyle::Lower));
|
||||
|
||||
// upper-case, no prefix.
|
||||
EXPECT_EQ("0", format_number((void *)nullptr, HexStyle::Upper));
|
||||
EXPECT_EQ("BEEF", format_number((void *)0xbeefLL, HexStyle::Upper));
|
||||
EXPECT_EQ("DEADBEEF", format_number((void *)0xdeadbeefLL, HexStyle::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, HexStyle::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));
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue