diff options
Diffstat (limited to 'contrib/llvm/unittests/ADT')
18 files changed, 3375 insertions, 0 deletions
diff --git a/contrib/llvm/unittests/ADT/APFloatTest.cpp b/contrib/llvm/unittests/ADT/APFloatTest.cpp new file mode 100644 index 0000000..964b04d --- /dev/null +++ b/contrib/llvm/unittests/ADT/APFloatTest.cpp @@ -0,0 +1,579 @@ +//===- llvm/unittest/ADT/APFloat.cpp - APFloat unit tests ---------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include <ostream> +#include <string> +#include "llvm/Support/raw_ostream.h" +#include "gtest/gtest.h" +#include "llvm/ADT/APFloat.h" +#include "llvm/ADT/SmallString.h" +#include "llvm/ADT/SmallVector.h" + +using namespace llvm; + +static double convertToDoubleFromString(const char *Str) { + llvm::APFloat F(0.0); + F.convertFromString(Str, llvm::APFloat::rmNearestTiesToEven); + return F.convertToDouble(); +} + +static std::string convertToString(double d, unsigned Prec, unsigned Pad) { + llvm::SmallVector<char, 100> Buffer; + llvm::APFloat F(d); + F.toString(Buffer, Prec, Pad); + return std::string(Buffer.data(), Buffer.size()); +} + +namespace { + +TEST(APFloatTest, Zero) { + EXPECT_EQ(0.0f, APFloat(APFloat::IEEEsingle, 0.0f).convertToFloat()); + EXPECT_EQ(-0.0f, APFloat(APFloat::IEEEsingle, -0.0f).convertToFloat()); + + EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble, 0.0).convertToDouble()); + EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, -0.0).convertToDouble()); +} + +TEST(APFloatTest, fromZeroDecimalString) { + EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0").convertToDouble()); + EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0").convertToDouble()); + EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0").convertToDouble()); + + EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0.").convertToDouble()); + EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.").convertToDouble()); + EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.").convertToDouble()); + + EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, ".0").convertToDouble()); + EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+.0").convertToDouble()); + EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-.0").convertToDouble()); + + EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0.0").convertToDouble()); + EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.0").convertToDouble()); + EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.0").convertToDouble()); + + EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "00000.").convertToDouble()); + EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+00000.").convertToDouble()); + EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-00000.").convertToDouble()); + + EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble, ".00000").convertToDouble()); + EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+.00000").convertToDouble()); + EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-.00000").convertToDouble()); + + EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0000.00000").convertToDouble()); + EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0000.00000").convertToDouble()); + EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0000.00000").convertToDouble()); +} + +TEST(APFloatTest, fromZeroDecimalSingleExponentString) { + EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0e1").convertToDouble()); + EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0e1").convertToDouble()); + EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0e1").convertToDouble()); + + EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0e+1").convertToDouble()); + EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0e+1").convertToDouble()); + EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0e+1").convertToDouble()); + + EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0e-1").convertToDouble()); + EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0e-1").convertToDouble()); + EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0e-1").convertToDouble()); + + + EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0.e1").convertToDouble()); + EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.e1").convertToDouble()); + EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.e1").convertToDouble()); + + EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0.e+1").convertToDouble()); + EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.e+1").convertToDouble()); + EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.e+1").convertToDouble()); + + EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0.e-1").convertToDouble()); + EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.e-1").convertToDouble()); + EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.e-1").convertToDouble()); + + EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, ".0e1").convertToDouble()); + EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+.0e1").convertToDouble()); + EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-.0e1").convertToDouble()); + + EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, ".0e+1").convertToDouble()); + EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+.0e+1").convertToDouble()); + EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-.0e+1").convertToDouble()); + + EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, ".0e-1").convertToDouble()); + EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+.0e-1").convertToDouble()); + EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-.0e-1").convertToDouble()); + + + EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0.0e1").convertToDouble()); + EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.0e1").convertToDouble()); + EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.0e1").convertToDouble()); + + EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0.0e+1").convertToDouble()); + EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.0e+1").convertToDouble()); + EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.0e+1").convertToDouble()); + + EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0.0e-1").convertToDouble()); + EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0.0e-1").convertToDouble()); + EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0.0e-1").convertToDouble()); + + + EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "000.0000e1").convertToDouble()); + EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+000.0000e+1").convertToDouble()); + EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-000.0000e+1").convertToDouble()); +} + +TEST(APFloatTest, fromZeroDecimalLargeExponentString) { + EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0e1234").convertToDouble()); + EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0e1234").convertToDouble()); + EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0e1234").convertToDouble()); + + EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0e+1234").convertToDouble()); + EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0e+1234").convertToDouble()); + EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0e+1234").convertToDouble()); + + EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0e-1234").convertToDouble()); + EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0e-1234").convertToDouble()); + EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0e-1234").convertToDouble()); + + EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble, "000.0000e1234").convertToDouble()); + EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble, "000.0000e-1234").convertToDouble()); + + EXPECT_EQ(0.0, APFloat(APFloat::IEEEdouble, StringRef("0e1234\02", 6)).convertToDouble()); +} + +TEST(APFloatTest, fromZeroHexadecimalString) { + EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0p1").convertToDouble()); + EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0p1").convertToDouble()); + EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0p1").convertToDouble()); + + EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0p+1").convertToDouble()); + EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0p+1").convertToDouble()); + EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0p+1").convertToDouble()); + + EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0p-1").convertToDouble()); + EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0p-1").convertToDouble()); + EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0p-1").convertToDouble()); + + + EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.p1").convertToDouble()); + EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.p1").convertToDouble()); + EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.p1").convertToDouble()); + + EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.p+1").convertToDouble()); + EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.p+1").convertToDouble()); + EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.p+1").convertToDouble()); + + EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.p-1").convertToDouble()); + EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.p-1").convertToDouble()); + EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.p-1").convertToDouble()); + + + EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x.0p1").convertToDouble()); + EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x.0p1").convertToDouble()); + EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x.0p1").convertToDouble()); + + EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x.0p+1").convertToDouble()); + EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x.0p+1").convertToDouble()); + EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x.0p+1").convertToDouble()); + + EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x.0p-1").convertToDouble()); + EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x.0p-1").convertToDouble()); + EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x.0p-1").convertToDouble()); + + + EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.0p1").convertToDouble()); + EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.0p1").convertToDouble()); + EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.0p1").convertToDouble()); + + EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.0p+1").convertToDouble()); + EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.0p+1").convertToDouble()); + EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.0p+1").convertToDouble()); + + EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.0p-1").convertToDouble()); + EXPECT_EQ(+0.0, APFloat(APFloat::IEEEdouble, "+0x0.0p-1").convertToDouble()); + EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0.0p-1").convertToDouble()); + + + EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x00000.p1").convertToDouble()); + EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0000.00000p1").convertToDouble()); + EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x.00000p1").convertToDouble()); + EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.p1").convertToDouble()); + EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0p1234").convertToDouble()); + EXPECT_EQ(-0.0, APFloat(APFloat::IEEEdouble, "-0x0p1234").convertToDouble()); + EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x00000.p1234").convertToDouble()); + EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0000.00000p1234").convertToDouble()); + EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x.00000p1234").convertToDouble()); + EXPECT_EQ( 0.0, APFloat(APFloat::IEEEdouble, "0x0.p1234").convertToDouble()); +} + +TEST(APFloatTest, fromDecimalString) { + EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble, "1").convertToDouble()); + EXPECT_EQ(2.0, APFloat(APFloat::IEEEdouble, "2.").convertToDouble()); + EXPECT_EQ(0.5, APFloat(APFloat::IEEEdouble, ".5").convertToDouble()); + EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble, "1.0").convertToDouble()); + EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble, "-2").convertToDouble()); + EXPECT_EQ(-4.0, APFloat(APFloat::IEEEdouble, "-4.").convertToDouble()); + EXPECT_EQ(-0.5, APFloat(APFloat::IEEEdouble, "-.5").convertToDouble()); + EXPECT_EQ(-1.5, APFloat(APFloat::IEEEdouble, "-1.5").convertToDouble()); + EXPECT_EQ(1.25e12, APFloat(APFloat::IEEEdouble, "1.25e12").convertToDouble()); + EXPECT_EQ(1.25e+12, APFloat(APFloat::IEEEdouble, "1.25e+12").convertToDouble()); + EXPECT_EQ(1.25e-12, APFloat(APFloat::IEEEdouble, "1.25e-12").convertToDouble()); + EXPECT_EQ(1024.0, APFloat(APFloat::IEEEdouble, "1024.").convertToDouble()); + EXPECT_EQ(1024.05, APFloat(APFloat::IEEEdouble, "1024.05000").convertToDouble()); + EXPECT_EQ(0.05, APFloat(APFloat::IEEEdouble, ".05000").convertToDouble()); + EXPECT_EQ(2.0, APFloat(APFloat::IEEEdouble, "2.").convertToDouble()); + EXPECT_EQ(2.0e2, APFloat(APFloat::IEEEdouble, "2.e2").convertToDouble()); + EXPECT_EQ(2.0e+2, APFloat(APFloat::IEEEdouble, "2.e+2").convertToDouble()); + EXPECT_EQ(2.0e-2, APFloat(APFloat::IEEEdouble, "2.e-2").convertToDouble()); + EXPECT_EQ(2.05e2, APFloat(APFloat::IEEEdouble, "002.05000e2").convertToDouble()); + EXPECT_EQ(2.05e+2, APFloat(APFloat::IEEEdouble, "002.05000e+2").convertToDouble()); + EXPECT_EQ(2.05e-2, APFloat(APFloat::IEEEdouble, "002.05000e-2").convertToDouble()); + EXPECT_EQ(2.05e12, APFloat(APFloat::IEEEdouble, "002.05000e12").convertToDouble()); + EXPECT_EQ(2.05e+12, APFloat(APFloat::IEEEdouble, "002.05000e+12").convertToDouble()); + EXPECT_EQ(2.05e-12, APFloat(APFloat::IEEEdouble, "002.05000e-12").convertToDouble()); + + // These are "carefully selected" to overflow the fast log-base + // calculations in APFloat.cpp + EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "99e99999").isInfinity()); + EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "-99e99999").isInfinity()); + EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "1e-99999").isPosZero()); + EXPECT_TRUE(APFloat(APFloat::IEEEdouble, "-1e-99999").isNegZero()); +} + +TEST(APFloatTest, fromHexadecimalString) { + EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble, "0x1p0").convertToDouble()); + EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble, "+0x1p0").convertToDouble()); + EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble, "-0x1p0").convertToDouble()); + + EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble, "0x1p+0").convertToDouble()); + EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble, "+0x1p+0").convertToDouble()); + EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble, "-0x1p+0").convertToDouble()); + + EXPECT_EQ( 1.0, APFloat(APFloat::IEEEdouble, "0x1p-0").convertToDouble()); + EXPECT_EQ(+1.0, APFloat(APFloat::IEEEdouble, "+0x1p-0").convertToDouble()); + EXPECT_EQ(-1.0, APFloat(APFloat::IEEEdouble, "-0x1p-0").convertToDouble()); + + + EXPECT_EQ( 2.0, APFloat(APFloat::IEEEdouble, "0x1p1").convertToDouble()); + EXPECT_EQ(+2.0, APFloat(APFloat::IEEEdouble, "+0x1p1").convertToDouble()); + EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble, "-0x1p1").convertToDouble()); + + EXPECT_EQ( 2.0, APFloat(APFloat::IEEEdouble, "0x1p+1").convertToDouble()); + EXPECT_EQ(+2.0, APFloat(APFloat::IEEEdouble, "+0x1p+1").convertToDouble()); + EXPECT_EQ(-2.0, APFloat(APFloat::IEEEdouble, "-0x1p+1").convertToDouble()); + + EXPECT_EQ( 0.5, APFloat(APFloat::IEEEdouble, "0x1p-1").convertToDouble()); + EXPECT_EQ(+0.5, APFloat(APFloat::IEEEdouble, "+0x1p-1").convertToDouble()); + EXPECT_EQ(-0.5, APFloat(APFloat::IEEEdouble, "-0x1p-1").convertToDouble()); + + + EXPECT_EQ( 3.0, APFloat(APFloat::IEEEdouble, "0x1.8p1").convertToDouble()); + EXPECT_EQ(+3.0, APFloat(APFloat::IEEEdouble, "+0x1.8p1").convertToDouble()); + EXPECT_EQ(-3.0, APFloat(APFloat::IEEEdouble, "-0x1.8p1").convertToDouble()); + + EXPECT_EQ( 3.0, APFloat(APFloat::IEEEdouble, "0x1.8p+1").convertToDouble()); + EXPECT_EQ(+3.0, APFloat(APFloat::IEEEdouble, "+0x1.8p+1").convertToDouble()); + EXPECT_EQ(-3.0, APFloat(APFloat::IEEEdouble, "-0x1.8p+1").convertToDouble()); + + EXPECT_EQ( 0.75, APFloat(APFloat::IEEEdouble, "0x1.8p-1").convertToDouble()); + EXPECT_EQ(+0.75, APFloat(APFloat::IEEEdouble, "+0x1.8p-1").convertToDouble()); + EXPECT_EQ(-0.75, APFloat(APFloat::IEEEdouble, "-0x1.8p-1").convertToDouble()); + + + EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble, "0x1000.000p1").convertToDouble()); + EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble, "+0x1000.000p1").convertToDouble()); + EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble, "-0x1000.000p1").convertToDouble()); + + EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble, "0x1000.000p+1").convertToDouble()); + EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble, "+0x1000.000p+1").convertToDouble()); + EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble, "-0x1000.000p+1").convertToDouble()); + + EXPECT_EQ( 2048.0, APFloat(APFloat::IEEEdouble, "0x1000.000p-1").convertToDouble()); + EXPECT_EQ(+2048.0, APFloat(APFloat::IEEEdouble, "+0x1000.000p-1").convertToDouble()); + EXPECT_EQ(-2048.0, APFloat(APFloat::IEEEdouble, "-0x1000.000p-1").convertToDouble()); + + + EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble, "0x1000p1").convertToDouble()); + EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble, "+0x1000p1").convertToDouble()); + EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble, "-0x1000p1").convertToDouble()); + + EXPECT_EQ( 8192.0, APFloat(APFloat::IEEEdouble, "0x1000p+1").convertToDouble()); + EXPECT_EQ(+8192.0, APFloat(APFloat::IEEEdouble, "+0x1000p+1").convertToDouble()); + EXPECT_EQ(-8192.0, APFloat(APFloat::IEEEdouble, "-0x1000p+1").convertToDouble()); + + EXPECT_EQ( 2048.0, APFloat(APFloat::IEEEdouble, "0x1000p-1").convertToDouble()); + EXPECT_EQ(+2048.0, APFloat(APFloat::IEEEdouble, "+0x1000p-1").convertToDouble()); + EXPECT_EQ(-2048.0, APFloat(APFloat::IEEEdouble, "-0x1000p-1").convertToDouble()); + + + EXPECT_EQ( 16384.0, APFloat(APFloat::IEEEdouble, "0x10p10").convertToDouble()); + EXPECT_EQ(+16384.0, APFloat(APFloat::IEEEdouble, "+0x10p10").convertToDouble()); + EXPECT_EQ(-16384.0, APFloat(APFloat::IEEEdouble, "-0x10p10").convertToDouble()); + + EXPECT_EQ( 16384.0, APFloat(APFloat::IEEEdouble, "0x10p+10").convertToDouble()); + EXPECT_EQ(+16384.0, APFloat(APFloat::IEEEdouble, "+0x10p+10").convertToDouble()); + EXPECT_EQ(-16384.0, APFloat(APFloat::IEEEdouble, "-0x10p+10").convertToDouble()); + + EXPECT_EQ( 0.015625, APFloat(APFloat::IEEEdouble, "0x10p-10").convertToDouble()); + EXPECT_EQ(+0.015625, APFloat(APFloat::IEEEdouble, "+0x10p-10").convertToDouble()); + EXPECT_EQ(-0.015625, APFloat(APFloat::IEEEdouble, "-0x10p-10").convertToDouble()); + + EXPECT_EQ(1.0625, APFloat(APFloat::IEEEdouble, "0x1.1p0").convertToDouble()); + EXPECT_EQ(1.0, APFloat(APFloat::IEEEdouble, "0x1p0").convertToDouble()); + + EXPECT_EQ(2.71828, convertToDoubleFromString("2.71828")); +} + +TEST(APFloatTest, toString) { + ASSERT_EQ("10", convertToString(10.0, 6, 3)); + ASSERT_EQ("1.0E+1", convertToString(10.0, 6, 0)); + ASSERT_EQ("10100", convertToString(1.01E+4, 5, 2)); + ASSERT_EQ("1.01E+4", convertToString(1.01E+4, 4, 2)); + ASSERT_EQ("1.01E+4", convertToString(1.01E+4, 5, 1)); + ASSERT_EQ("0.0101", convertToString(1.01E-2, 5, 2)); + ASSERT_EQ("0.0101", convertToString(1.01E-2, 4, 2)); + ASSERT_EQ("1.01E-2", convertToString(1.01E-2, 5, 1)); + ASSERT_EQ("0.7853981633974483", convertToString(0.78539816339744830961, 0, 3)); + ASSERT_EQ("4.940656458412465E-324", convertToString(4.9406564584124654e-324, 0, 3)); + ASSERT_EQ("873.1834", convertToString(873.1834, 0, 1)); + ASSERT_EQ("8.731834E+2", convertToString(873.1834, 0, 0)); +} + +static APInt nanbits(const fltSemantics &Sem, + bool SNaN, bool Negative, uint64_t fill) { + APInt apfill(64, fill); + if (SNaN) + return APFloat::getSNaN(Sem, Negative, &apfill).bitcastToAPInt(); + else + return APFloat::getQNaN(Sem, Negative, &apfill).bitcastToAPInt(); +} + +TEST(APFloatTest, makeNaN) { + ASSERT_EQ(0x7fc00000, nanbits(APFloat::IEEEsingle, false, false, 0)); + ASSERT_EQ(0xffc00000, nanbits(APFloat::IEEEsingle, false, true, 0)); + ASSERT_EQ(0x7fc0ae72, nanbits(APFloat::IEEEsingle, false, false, 0xae72)); + ASSERT_EQ(0x7fffae72, nanbits(APFloat::IEEEsingle, false, false, 0xffffae72)); + ASSERT_EQ(0x7fa00000, nanbits(APFloat::IEEEsingle, true, false, 0)); + ASSERT_EQ(0xffa00000, nanbits(APFloat::IEEEsingle, true, true, 0)); + ASSERT_EQ(0x7f80ae72, nanbits(APFloat::IEEEsingle, true, false, 0xae72)); + ASSERT_EQ(0x7fbfae72, nanbits(APFloat::IEEEsingle, true, false, 0xffffae72)); + + ASSERT_EQ(0x7ff8000000000000ULL, nanbits(APFloat::IEEEdouble, false, false, 0)); + ASSERT_EQ(0xfff8000000000000ULL, nanbits(APFloat::IEEEdouble, false, true, 0)); + ASSERT_EQ(0x7ff800000000ae72ULL, nanbits(APFloat::IEEEdouble, false, false, 0xae72)); + ASSERT_EQ(0x7fffffffffffae72ULL, nanbits(APFloat::IEEEdouble, false, false, 0xffffffffffffae72ULL)); + ASSERT_EQ(0x7ff4000000000000ULL, nanbits(APFloat::IEEEdouble, true, false, 0)); + ASSERT_EQ(0xfff4000000000000ULL, nanbits(APFloat::IEEEdouble, true, true, 0)); + ASSERT_EQ(0x7ff000000000ae72ULL, nanbits(APFloat::IEEEdouble, true, false, 0xae72)); + ASSERT_EQ(0x7ff7ffffffffae72ULL, nanbits(APFloat::IEEEdouble, true, false, 0xffffffffffffae72ULL)); +} + +#ifdef GTEST_HAS_DEATH_TEST +#ifndef NDEBUG +TEST(APFloatTest, SemanticsDeath) { + EXPECT_DEATH(APFloat(APFloat::IEEEsingle, 0.0f).convertToDouble(), "Float semantics are not IEEEdouble"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, 0.0 ).convertToFloat(), "Float semantics are not IEEEsingle"); +} + +TEST(APFloatTest, StringDecimalDeath) { + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ""), "Invalid string length"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+"), "String has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-"), "String has no digits"); + + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("\0", 1)), "Invalid character in significand"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1\0", 2)), "Invalid character in significand"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1\02", 3)), "Invalid character in significand"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1\02e1", 5)), "Invalid character in significand"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1e\0", 3)), "Invalid character in exponent"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1e1\0", 4)), "Invalid character in exponent"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("1e1\02", 5)), "Invalid character in exponent"); + + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.0f"), "Invalid character in significand"); + + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ".."), "String contains multiple dots"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "..0"), "String contains multiple dots"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.0.0"), "String contains multiple dots"); +} + +TEST(APFloatTest, StringDecimalSignificandDeath) { + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "."), "Significand has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+."), "Significand has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-."), "Significand has no digits"); + + + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "e"), "Significand has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+e"), "Significand has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-e"), "Significand has no digits"); + + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "e1"), "Significand has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+e1"), "Significand has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-e1"), "Significand has no digits"); + + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ".e1"), "Significand has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+.e1"), "Significand has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-.e1"), "Significand has no digits"); + + + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ".e"), "Significand has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+.e"), "Significand has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-.e"), "Significand has no digits"); +} + +TEST(APFloatTest, StringDecimalExponentDeath) { + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1e"), "Exponent has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+1e"), "Exponent has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-1e"), "Exponent has no digits"); + + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.e"), "Exponent has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+1.e"), "Exponent has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-1.e"), "Exponent has no digits"); + + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ".1e"), "Exponent has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+.1e"), "Exponent has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-.1e"), "Exponent has no digits"); + + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.1e"), "Exponent has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+1.1e"), "Exponent has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-1.1e"), "Exponent has no digits"); + + + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1e+"), "Exponent has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1e-"), "Exponent has no digits"); + + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ".1e"), "Exponent has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ".1e+"), "Exponent has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, ".1e-"), "Exponent has no digits"); + + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.0e"), "Exponent has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.0e+"), "Exponent has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "1.0e-"), "Exponent has no digits"); +} + +TEST(APFloatTest, StringHexadecimalDeath) { + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x"), "Invalid string"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x"), "Invalid string"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x"), "Invalid string"); + + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x0"), "Hex strings require an exponent"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x0"), "Hex strings require an exponent"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x0"), "Hex strings require an exponent"); + + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x0."), "Hex strings require an exponent"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x0."), "Hex strings require an exponent"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x0."), "Hex strings require an exponent"); + + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x.0"), "Hex strings require an exponent"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.0"), "Hex strings require an exponent"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.0"), "Hex strings require an exponent"); + + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x0.0"), "Hex strings require an exponent"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x0.0"), "Hex strings require an exponent"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x0.0"), "Hex strings require an exponent"); + + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x\0", 3)), "Invalid character in significand"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1\0", 4)), "Invalid character in significand"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1\02", 5)), "Invalid character in significand"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1\02p1", 7)), "Invalid character in significand"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1p\0", 5)), "Invalid character in exponent"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1p1\0", 6)), "Invalid character in exponent"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, StringRef("0x1p1\02", 7)), "Invalid character in exponent"); + + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1p0f"), "Invalid character in exponent"); + + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x..p1"), "String contains multiple dots"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x..0p1"), "String contains multiple dots"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1.0.0p1"), "String contains multiple dots"); +} + +TEST(APFloatTest, StringHexadecimalSignificandDeath) { + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x."), "Significand has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x."), "Significand has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x."), "Significand has no digits"); + + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0xp"), "Significand has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0xp"), "Significand has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0xp"), "Significand has no digits"); + + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0xp+"), "Significand has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0xp+"), "Significand has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0xp+"), "Significand has no digits"); + + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0xp-"), "Significand has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0xp-"), "Significand has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0xp-"), "Significand has no digits"); + + + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x.p"), "Significand has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.p"), "Significand has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.p"), "Significand has no digits"); + + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x.p+"), "Significand has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.p+"), "Significand has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.p+"), "Significand has no digits"); + + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x.p-"), "Significand has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.p-"), "Significand has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.p-"), "Significand has no digits"); +} + +TEST(APFloatTest, StringHexadecimalExponentDeath) { + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1p"), "Exponent has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1p"), "Exponent has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1p"), "Exponent has no digits"); + + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1p+"), "Exponent has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1p+"), "Exponent has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1p+"), "Exponent has no digits"); + + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1p-"), "Exponent has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1p-"), "Exponent has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1p-"), "Exponent has no digits"); + + + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1.p"), "Exponent has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.p"), "Exponent has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.p"), "Exponent has no digits"); + + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1.p+"), "Exponent has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.p+"), "Exponent has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.p+"), "Exponent has no digits"); + + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1.p-"), "Exponent has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.p-"), "Exponent has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.p-"), "Exponent has no digits"); + + + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x.1p"), "Exponent has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.1p"), "Exponent has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.1p"), "Exponent has no digits"); + + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x.1p+"), "Exponent has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.1p+"), "Exponent has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.1p+"), "Exponent has no digits"); + + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x.1p-"), "Exponent has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x.1p-"), "Exponent has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x.1p-"), "Exponent has no digits"); + + + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1.1p"), "Exponent has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.1p"), "Exponent has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.1p"), "Exponent has no digits"); + + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1.1p+"), "Exponent has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.1p+"), "Exponent has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.1p+"), "Exponent has no digits"); + + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "0x1.1p-"), "Exponent has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "+0x1.1p-"), "Exponent has no digits"); + EXPECT_DEATH(APFloat(APFloat::IEEEdouble, "-0x1.1p-"), "Exponent has no digits"); +} +#endif +#endif + +} diff --git a/contrib/llvm/unittests/ADT/APIntTest.cpp b/contrib/llvm/unittests/ADT/APIntTest.cpp new file mode 100644 index 0000000..d08e86a --- /dev/null +++ b/contrib/llvm/unittests/ADT/APIntTest.cpp @@ -0,0 +1,346 @@ +//===- llvm/unittest/ADT/APInt.cpp - APInt unit tests ---------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include <ostream> +#include "gtest/gtest.h" +#include "llvm/ADT/APInt.h" +#include "llvm/ADT/SmallString.h" + +using namespace llvm; + +namespace { + +// Test that APInt shift left works when bitwidth > 64 and shiftamt == 0 +TEST(APIntTest, ShiftLeftByZero) { + APInt One = APInt::getNullValue(65) + 1; + APInt Shl = One.shl(0); + EXPECT_EQ(true, Shl[0]); + EXPECT_EQ(false, Shl[1]); +} + +TEST(APIntTest, i128_NegativeCount) { + APInt Minus3(128, static_cast<uint64_t>(-3), true); + EXPECT_EQ(126u, Minus3.countLeadingOnes()); + EXPECT_EQ(-3, Minus3.getSExtValue()); + + APInt Minus1(128, static_cast<uint64_t>(-1), true); + EXPECT_EQ(0u, Minus1.countLeadingZeros()); + EXPECT_EQ(128u, Minus1.countLeadingOnes()); + EXPECT_EQ(128u, Minus1.getActiveBits()); + EXPECT_EQ(0u, Minus1.countTrailingZeros()); + EXPECT_EQ(128u, Minus1.countTrailingOnes()); + EXPECT_EQ(128u, Minus1.countPopulation()); + EXPECT_EQ(-1, Minus1.getSExtValue()); +} + +TEST(APIntTest, i33_Count) { + APInt i33minus2(33, static_cast<uint64_t>(-2), true); + EXPECT_EQ(0u, i33minus2.countLeadingZeros()); + EXPECT_EQ(32u, i33minus2.countLeadingOnes()); + EXPECT_EQ(33u, i33minus2.getActiveBits()); + EXPECT_EQ(1u, i33minus2.countTrailingZeros()); + EXPECT_EQ(32u, i33minus2.countPopulation()); + EXPECT_EQ(-2, i33minus2.getSExtValue()); + EXPECT_EQ(((uint64_t)-2)&((1ull<<33) -1), i33minus2.getZExtValue()); +} + +TEST(APIntTest, i65_Count) { + APInt i65minus(65, 0, true); + i65minus.set(64); + EXPECT_EQ(0u, i65minus.countLeadingZeros()); + EXPECT_EQ(1u, i65minus.countLeadingOnes()); + EXPECT_EQ(65u, i65minus.getActiveBits()); + EXPECT_EQ(64u, i65minus.countTrailingZeros()); + EXPECT_EQ(1u, i65minus.countPopulation()); +} + +TEST(APIntTest, i128_PositiveCount) { + APInt u128max = APInt::getAllOnesValue(128); + EXPECT_EQ(128u, u128max.countLeadingOnes()); + EXPECT_EQ(0u, u128max.countLeadingZeros()); + EXPECT_EQ(128u, u128max.getActiveBits()); + EXPECT_EQ(0u, u128max.countTrailingZeros()); + EXPECT_EQ(128u, u128max.countTrailingOnes()); + EXPECT_EQ(128u, u128max.countPopulation()); + + APInt u64max(128, static_cast<uint64_t>(-1), false); + EXPECT_EQ(64u, u64max.countLeadingZeros()); + EXPECT_EQ(0u, u64max.countLeadingOnes()); + EXPECT_EQ(64u, u64max.getActiveBits()); + EXPECT_EQ(0u, u64max.countTrailingZeros()); + EXPECT_EQ(64u, u64max.countTrailingOnes()); + EXPECT_EQ(64u, u64max.countPopulation()); + EXPECT_EQ((uint64_t)~0ull, u64max.getZExtValue()); + + APInt zero(128, 0, true); + EXPECT_EQ(128u, zero.countLeadingZeros()); + EXPECT_EQ(0u, zero.countLeadingOnes()); + EXPECT_EQ(0u, zero.getActiveBits()); + EXPECT_EQ(128u, zero.countTrailingZeros()); + EXPECT_EQ(0u, zero.countTrailingOnes()); + EXPECT_EQ(0u, zero.countPopulation()); + EXPECT_EQ(0u, zero.getSExtValue()); + EXPECT_EQ(0u, zero.getZExtValue()); + + APInt one(128, 1, true); + EXPECT_EQ(127u, one.countLeadingZeros()); + EXPECT_EQ(0u, one.countLeadingOnes()); + EXPECT_EQ(1u, one.getActiveBits()); + EXPECT_EQ(0u, one.countTrailingZeros()); + EXPECT_EQ(1u, one.countTrailingOnes()); + EXPECT_EQ(1u, one.countPopulation()); + EXPECT_EQ(1, one.getSExtValue()); + EXPECT_EQ(1u, one.getZExtValue()); +} + +TEST(APIntTest, i1) { + const APInt neg_two(1, static_cast<uint64_t>(-2), true); + const APInt neg_one(1, static_cast<uint64_t>(-1), true); + const APInt zero(1, 0); + const APInt one(1, 1); + const APInt two(1, 2); + + EXPECT_EQ(0, neg_two.getSExtValue()); + EXPECT_EQ(-1, neg_one.getSExtValue()); + EXPECT_EQ(1u, neg_one.getZExtValue()); + EXPECT_EQ(0u, zero.getZExtValue()); + EXPECT_EQ(-1, one.getSExtValue()); + EXPECT_EQ(1u, one.getZExtValue()); + EXPECT_EQ(0u, two.getZExtValue()); + EXPECT_EQ(0, two.getSExtValue()); + + // Basic equalities for 1-bit values. + EXPECT_EQ(zero, two); + EXPECT_EQ(zero, neg_two); + EXPECT_EQ(one, neg_one); + EXPECT_EQ(two, neg_two); + + // Additions. + EXPECT_EQ(two, one + one); + EXPECT_EQ(zero, neg_one + one); + EXPECT_EQ(neg_two, neg_one + neg_one); + + // Subtractions. + EXPECT_EQ(neg_two, neg_one - one); + EXPECT_EQ(two, one - neg_one); + EXPECT_EQ(zero, one - one); + + // Shifts. + EXPECT_EQ(zero, one << one); + EXPECT_EQ(one, one << zero); + EXPECT_EQ(zero, one.shl(1)); + EXPECT_EQ(one, one.shl(0)); + EXPECT_EQ(zero, one.lshr(1)); + EXPECT_EQ(zero, one.ashr(1)); + + // Multiplies. + EXPECT_EQ(neg_one, neg_one * one); + EXPECT_EQ(neg_one, one * neg_one); + EXPECT_EQ(one, neg_one * neg_one); + EXPECT_EQ(one, one * one); + + // Divides. + EXPECT_EQ(neg_one, one.sdiv(neg_one)); + EXPECT_EQ(neg_one, neg_one.sdiv(one)); + EXPECT_EQ(one, neg_one.sdiv(neg_one)); + EXPECT_EQ(one, one.sdiv(one)); + + EXPECT_EQ(neg_one, one.udiv(neg_one)); + EXPECT_EQ(neg_one, neg_one.udiv(one)); + EXPECT_EQ(one, neg_one.udiv(neg_one)); + EXPECT_EQ(one, one.udiv(one)); + + // Remainders. + EXPECT_EQ(zero, neg_one.srem(one)); + EXPECT_EQ(zero, neg_one.urem(one)); + EXPECT_EQ(zero, one.srem(neg_one)); +} + +TEST(APIntTest, fromString) { + EXPECT_EQ(APInt(32, 0), APInt(32, "0", 2)); + EXPECT_EQ(APInt(32, 1), APInt(32, "1", 2)); + EXPECT_EQ(APInt(32, 2), APInt(32, "10", 2)); + EXPECT_EQ(APInt(32, 3), APInt(32, "11", 2)); + EXPECT_EQ(APInt(32, 4), APInt(32, "100", 2)); + + EXPECT_EQ(APInt(32, 0), APInt(32, "+0", 2)); + EXPECT_EQ(APInt(32, 1), APInt(32, "+1", 2)); + EXPECT_EQ(APInt(32, 2), APInt(32, "+10", 2)); + EXPECT_EQ(APInt(32, 3), APInt(32, "+11", 2)); + EXPECT_EQ(APInt(32, 4), APInt(32, "+100", 2)); + + EXPECT_EQ(APInt(32, uint64_t(-0LL)), APInt(32, "-0", 2)); + EXPECT_EQ(APInt(32, uint64_t(-1LL)), APInt(32, "-1", 2)); + EXPECT_EQ(APInt(32, uint64_t(-2LL)), APInt(32, "-10", 2)); + EXPECT_EQ(APInt(32, uint64_t(-3LL)), APInt(32, "-11", 2)); + EXPECT_EQ(APInt(32, uint64_t(-4LL)), APInt(32, "-100", 2)); + + + EXPECT_EQ(APInt(32, 0), APInt(32, "0", 8)); + EXPECT_EQ(APInt(32, 1), APInt(32, "1", 8)); + EXPECT_EQ(APInt(32, 7), APInt(32, "7", 8)); + EXPECT_EQ(APInt(32, 8), APInt(32, "10", 8)); + EXPECT_EQ(APInt(32, 15), APInt(32, "17", 8)); + EXPECT_EQ(APInt(32, 16), APInt(32, "20", 8)); + + EXPECT_EQ(APInt(32, +0), APInt(32, "+0", 8)); + EXPECT_EQ(APInt(32, +1), APInt(32, "+1", 8)); + EXPECT_EQ(APInt(32, +7), APInt(32, "+7", 8)); + EXPECT_EQ(APInt(32, +8), APInt(32, "+10", 8)); + EXPECT_EQ(APInt(32, +15), APInt(32, "+17", 8)); + EXPECT_EQ(APInt(32, +16), APInt(32, "+20", 8)); + + EXPECT_EQ(APInt(32, uint64_t(-0LL)), APInt(32, "-0", 8)); + EXPECT_EQ(APInt(32, uint64_t(-1LL)), APInt(32, "-1", 8)); + EXPECT_EQ(APInt(32, uint64_t(-7LL)), APInt(32, "-7", 8)); + EXPECT_EQ(APInt(32, uint64_t(-8LL)), APInt(32, "-10", 8)); + EXPECT_EQ(APInt(32, uint64_t(-15LL)), APInt(32, "-17", 8)); + EXPECT_EQ(APInt(32, uint64_t(-16LL)), APInt(32, "-20", 8)); + + + EXPECT_EQ(APInt(32, 0), APInt(32, "0", 10)); + EXPECT_EQ(APInt(32, 1), APInt(32, "1", 10)); + EXPECT_EQ(APInt(32, 9), APInt(32, "9", 10)); + EXPECT_EQ(APInt(32, 10), APInt(32, "10", 10)); + EXPECT_EQ(APInt(32, 19), APInt(32, "19", 10)); + EXPECT_EQ(APInt(32, 20), APInt(32, "20", 10)); + + EXPECT_EQ(APInt(32, uint64_t(-0LL)), APInt(32, "-0", 10)); + EXPECT_EQ(APInt(32, uint64_t(-1LL)), APInt(32, "-1", 10)); + EXPECT_EQ(APInt(32, uint64_t(-9LL)), APInt(32, "-9", 10)); + EXPECT_EQ(APInt(32, uint64_t(-10LL)), APInt(32, "-10", 10)); + EXPECT_EQ(APInt(32, uint64_t(-19LL)), APInt(32, "-19", 10)); + EXPECT_EQ(APInt(32, uint64_t(-20LL)), APInt(32, "-20", 10)); + + + EXPECT_EQ(APInt(32, 0), APInt(32, "0", 16)); + EXPECT_EQ(APInt(32, 1), APInt(32, "1", 16)); + EXPECT_EQ(APInt(32, 15), APInt(32, "F", 16)); + EXPECT_EQ(APInt(32, 16), APInt(32, "10", 16)); + EXPECT_EQ(APInt(32, 31), APInt(32, "1F", 16)); + EXPECT_EQ(APInt(32, 32), APInt(32, "20", 16)); + + EXPECT_EQ(APInt(32, uint64_t(-0LL)), APInt(32, "-0", 16)); + EXPECT_EQ(APInt(32, uint64_t(-1LL)), APInt(32, "-1", 16)); + EXPECT_EQ(APInt(32, uint64_t(-15LL)), APInt(32, "-F", 16)); + EXPECT_EQ(APInt(32, uint64_t(-16LL)), APInt(32, "-10", 16)); + EXPECT_EQ(APInt(32, uint64_t(-31LL)), APInt(32, "-1F", 16)); + EXPECT_EQ(APInt(32, uint64_t(-32LL)), APInt(32, "-20", 16)); +} + +TEST(APIntTest, StringBitsNeeded2) { + EXPECT_EQ(1U, APInt::getBitsNeeded( "0", 2)); + EXPECT_EQ(1U, APInt::getBitsNeeded( "1", 2)); + EXPECT_EQ(2U, APInt::getBitsNeeded( "10", 2)); + EXPECT_EQ(2U, APInt::getBitsNeeded( "11", 2)); + EXPECT_EQ(3U, APInt::getBitsNeeded("100", 2)); + + EXPECT_EQ(1U, APInt::getBitsNeeded( "+0", 2)); + EXPECT_EQ(1U, APInt::getBitsNeeded( "+1", 2)); + EXPECT_EQ(2U, APInt::getBitsNeeded( "+10", 2)); + EXPECT_EQ(2U, APInt::getBitsNeeded( "+11", 2)); + EXPECT_EQ(3U, APInt::getBitsNeeded("+100", 2)); + + EXPECT_EQ(2U, APInt::getBitsNeeded( "-0", 2)); + EXPECT_EQ(2U, APInt::getBitsNeeded( "-1", 2)); + EXPECT_EQ(3U, APInt::getBitsNeeded( "-10", 2)); + EXPECT_EQ(3U, APInt::getBitsNeeded( "-11", 2)); + EXPECT_EQ(4U, APInt::getBitsNeeded("-100", 2)); +} + +TEST(APIntTest, StringBitsNeeded8) { + EXPECT_EQ(3U, APInt::getBitsNeeded( "0", 8)); + EXPECT_EQ(3U, APInt::getBitsNeeded( "7", 8)); + EXPECT_EQ(6U, APInt::getBitsNeeded("10", 8)); + EXPECT_EQ(6U, APInt::getBitsNeeded("17", 8)); + EXPECT_EQ(6U, APInt::getBitsNeeded("20", 8)); + + EXPECT_EQ(3U, APInt::getBitsNeeded( "+0", 8)); + EXPECT_EQ(3U, APInt::getBitsNeeded( "+7", 8)); + EXPECT_EQ(6U, APInt::getBitsNeeded("+10", 8)); + EXPECT_EQ(6U, APInt::getBitsNeeded("+17", 8)); + EXPECT_EQ(6U, APInt::getBitsNeeded("+20", 8)); + + EXPECT_EQ(4U, APInt::getBitsNeeded( "-0", 8)); + EXPECT_EQ(4U, APInt::getBitsNeeded( "-7", 8)); + EXPECT_EQ(7U, APInt::getBitsNeeded("-10", 8)); + EXPECT_EQ(7U, APInt::getBitsNeeded("-17", 8)); + EXPECT_EQ(7U, APInt::getBitsNeeded("-20", 8)); +} + +TEST(APIntTest, StringBitsNeeded10) { + EXPECT_EQ(1U, APInt::getBitsNeeded( "0", 10)); + EXPECT_EQ(2U, APInt::getBitsNeeded( "3", 10)); + EXPECT_EQ(4U, APInt::getBitsNeeded( "9", 10)); + EXPECT_EQ(4U, APInt::getBitsNeeded("10", 10)); + EXPECT_EQ(5U, APInt::getBitsNeeded("19", 10)); + EXPECT_EQ(5U, APInt::getBitsNeeded("20", 10)); + + EXPECT_EQ(1U, APInt::getBitsNeeded( "+0", 10)); + EXPECT_EQ(4U, APInt::getBitsNeeded( "+9", 10)); + EXPECT_EQ(4U, APInt::getBitsNeeded("+10", 10)); + EXPECT_EQ(5U, APInt::getBitsNeeded("+19", 10)); + EXPECT_EQ(5U, APInt::getBitsNeeded("+20", 10)); + + EXPECT_EQ(2U, APInt::getBitsNeeded( "-0", 10)); + EXPECT_EQ(5U, APInt::getBitsNeeded( "-9", 10)); + EXPECT_EQ(5U, APInt::getBitsNeeded("-10", 10)); + EXPECT_EQ(6U, APInt::getBitsNeeded("-19", 10)); + EXPECT_EQ(6U, APInt::getBitsNeeded("-20", 10)); +} + +TEST(APIntTest, StringBitsNeeded16) { + EXPECT_EQ(4U, APInt::getBitsNeeded( "0", 16)); + EXPECT_EQ(4U, APInt::getBitsNeeded( "F", 16)); + EXPECT_EQ(8U, APInt::getBitsNeeded("10", 16)); + EXPECT_EQ(8U, APInt::getBitsNeeded("1F", 16)); + EXPECT_EQ(8U, APInt::getBitsNeeded("20", 16)); + + EXPECT_EQ(4U, APInt::getBitsNeeded( "+0", 16)); + EXPECT_EQ(4U, APInt::getBitsNeeded( "+F", 16)); + EXPECT_EQ(8U, APInt::getBitsNeeded("+10", 16)); + EXPECT_EQ(8U, APInt::getBitsNeeded("+1F", 16)); + EXPECT_EQ(8U, APInt::getBitsNeeded("+20", 16)); + + EXPECT_EQ(5U, APInt::getBitsNeeded( "-0", 16)); + EXPECT_EQ(5U, APInt::getBitsNeeded( "-F", 16)); + EXPECT_EQ(9U, APInt::getBitsNeeded("-10", 16)); + EXPECT_EQ(9U, APInt::getBitsNeeded("-1F", 16)); + EXPECT_EQ(9U, APInt::getBitsNeeded("-20", 16)); +} + +TEST(APIntTest, Log2) { + EXPECT_EQ(APInt(15, 7).logBase2(), 2U); + EXPECT_EQ(APInt(15, 7).ceilLogBase2(), 3U); + EXPECT_EQ(APInt(15, 7).exactLogBase2(), -1); + EXPECT_EQ(APInt(15, 8).logBase2(), 3U); + EXPECT_EQ(APInt(15, 8).ceilLogBase2(), 3U); + EXPECT_EQ(APInt(15, 8).exactLogBase2(), 3); + EXPECT_EQ(APInt(15, 9).logBase2(), 3U); + EXPECT_EQ(APInt(15, 9).ceilLogBase2(), 4U); + EXPECT_EQ(APInt(15, 9).exactLogBase2(), -1); +} + +#ifdef GTEST_HAS_DEATH_TEST +#ifndef NDEBUG +TEST(APIntTest, StringDeath) { + EXPECT_DEATH(APInt(0, "", 0), "Bitwidth too small"); + EXPECT_DEATH(APInt(32, "", 0), "Invalid string length"); + EXPECT_DEATH(APInt(32, "0", 0), "Radix should be 2, 8, 10, or 16!"); + EXPECT_DEATH(APInt(32, "", 10), "Invalid string length"); + EXPECT_DEATH(APInt(32, "-", 10), "String is only a sign, needs a value."); + EXPECT_DEATH(APInt(1, "1234", 10), "Insufficient bit width"); + EXPECT_DEATH(APInt(32, "\0", 10), "Invalid string length"); + EXPECT_DEATH(APInt(32, StringRef("1\02", 3), 10), "Invalid character in digit string"); + EXPECT_DEATH(APInt(32, "1L", 10), "Invalid character in digit string"); +} +#endif +#endif + +} diff --git a/contrib/llvm/unittests/ADT/BitVectorTest.cpp b/contrib/llvm/unittests/ADT/BitVectorTest.cpp new file mode 100644 index 0000000..a9fc133 --- /dev/null +++ b/contrib/llvm/unittests/ADT/BitVectorTest.cpp @@ -0,0 +1,194 @@ +//===- llvm/unittest/ADT/BitVectorTest.cpp - BitVector tests --------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// Some of these tests fail on PowerPC for unknown reasons. +#ifndef __ppc__ + +#include "llvm/ADT/BitVector.h" +#include "gtest/gtest.h" + +using namespace llvm; + +namespace { + +TEST(BitVectorTest, TrivialOperation) { + BitVector Vec; + EXPECT_EQ(0U, Vec.count()); + EXPECT_EQ(0U, Vec.size()); + EXPECT_FALSE(Vec.any()); + EXPECT_TRUE(Vec.none()); + EXPECT_TRUE(Vec.empty()); + + Vec.resize(5, true); + EXPECT_EQ(5U, Vec.count()); + EXPECT_EQ(5U, Vec.size()); + EXPECT_TRUE(Vec.any()); + EXPECT_FALSE(Vec.none()); + EXPECT_FALSE(Vec.empty()); + + Vec.resize(11); + EXPECT_EQ(5U, Vec.count()); + EXPECT_EQ(11U, Vec.size()); + EXPECT_TRUE(Vec.any()); + EXPECT_FALSE(Vec.none()); + EXPECT_FALSE(Vec.empty()); + + BitVector Inv = ~Vec; + EXPECT_EQ(6U, Inv.count()); + EXPECT_EQ(11U, Inv.size()); + EXPECT_TRUE(Inv.any()); + EXPECT_FALSE(Inv.none()); + EXPECT_FALSE(Inv.empty()); + + EXPECT_FALSE(Inv == Vec); + EXPECT_TRUE(Inv != Vec); + Vec = ~Vec; + EXPECT_TRUE(Inv == Vec); + EXPECT_FALSE(Inv != Vec); + + // Add some "interesting" data to Vec. + Vec.resize(23, true); + Vec.resize(25, false); + Vec.resize(26, true); + Vec.resize(29, false); + Vec.resize(33, true); + Vec.resize(57, false); + unsigned Count = 0; + for (unsigned i = Vec.find_first(); i != -1u; i = Vec.find_next(i)) { + ++Count; + EXPECT_TRUE(Vec[i]); + EXPECT_TRUE(Vec.test(i)); + } + EXPECT_EQ(Count, Vec.count()); + EXPECT_EQ(Count, 23u); + EXPECT_FALSE(Vec[0]); + EXPECT_TRUE(Vec[32]); + EXPECT_FALSE(Vec[56]); + Vec.resize(61, false); + + BitVector Copy = Vec; + BitVector Alt(3, false); + Alt.resize(6, true); + std::swap(Alt, Vec); + EXPECT_TRUE(Copy == Alt); + EXPECT_TRUE(Vec.size() == 6); + EXPECT_TRUE(Vec.count() == 3); + EXPECT_TRUE(Vec.find_first() == 3); + std::swap(Copy, Vec); + + // Add some more "interesting" data. + Vec.resize(68, true); + Vec.resize(78, false); + Vec.resize(89, true); + Vec.resize(90, false); + Vec.resize(91, true); + Vec.resize(130, false); + Count = 0; + for (unsigned i = Vec.find_first(); i != -1u; i = Vec.find_next(i)) { + ++Count; + EXPECT_TRUE(Vec[i]); + EXPECT_TRUE(Vec.test(i)); + } + EXPECT_EQ(Count, Vec.count()); + EXPECT_EQ(Count, 42u); + EXPECT_FALSE(Vec[0]); + EXPECT_TRUE(Vec[32]); + EXPECT_FALSE(Vec[60]); + EXPECT_FALSE(Vec[129]); + + Vec.flip(60); + EXPECT_TRUE(Vec[60]); + EXPECT_EQ(Count + 1, Vec.count()); + Vec.flip(60); + EXPECT_FALSE(Vec[60]); + EXPECT_EQ(Count, Vec.count()); + + Vec.reset(32); + EXPECT_FALSE(Vec[32]); + EXPECT_EQ(Count - 1, Vec.count()); + Vec.set(32); + EXPECT_TRUE(Vec[32]); + EXPECT_EQ(Count, Vec.count()); + + Vec.flip(); + EXPECT_EQ(Vec.size() - Count, Vec.count()); + + Vec.reset(); + EXPECT_EQ(0U, Vec.count()); + EXPECT_EQ(130U, Vec.size()); + EXPECT_FALSE(Vec.any()); + EXPECT_TRUE(Vec.none()); + EXPECT_FALSE(Vec.empty()); + + Inv = ~BitVector(); + EXPECT_EQ(0U, Inv.count()); + EXPECT_EQ(0U, Inv.size()); + EXPECT_FALSE(Inv.any()); + EXPECT_TRUE(Inv.none()); + EXPECT_TRUE(Inv.empty()); + + Vec.clear(); + EXPECT_EQ(0U, Vec.count()); + EXPECT_EQ(0U, Vec.size()); + EXPECT_FALSE(Vec.any()); + EXPECT_TRUE(Vec.none()); + EXPECT_TRUE(Vec.empty()); +} + +TEST(BitVectorTest, CompoundAssignment) { + BitVector A; + A.resize(10); + A.set(4); + A.set(7); + + BitVector B; + B.resize(50); + B.set(5); + B.set(18); + + A |= B; + EXPECT_TRUE(A.test(4)); + EXPECT_TRUE(A.test(5)); + EXPECT_TRUE(A.test(7)); + EXPECT_TRUE(A.test(18)); + EXPECT_EQ(4U, A.count()); + EXPECT_EQ(50U, A.size()); + + B.resize(10); + B.set(); + B.reset(2); + B.reset(7); + A &= B; + EXPECT_FALSE(A.test(2)); + EXPECT_FALSE(A.test(7)); + EXPECT_EQ(2U, A.count()); + EXPECT_EQ(50U, A.size()); + + B.resize(100); + B.set(); + + A ^= B; + EXPECT_TRUE(A.test(2)); + EXPECT_TRUE(A.test(7)); + EXPECT_EQ(98U, A.count()); + EXPECT_EQ(100U, A.size()); +} + +TEST(BitVectorTest, ProxyIndex) { + BitVector Vec(3); + EXPECT_TRUE(Vec.none()); + Vec[0] = Vec[1] = Vec[2] = true; + EXPECT_EQ(Vec.size(), Vec.count()); + Vec[2] = Vec[1] = Vec[0] = false; + EXPECT_TRUE(Vec.none()); +} + +} + +#endif diff --git a/contrib/llvm/unittests/ADT/DeltaAlgorithmTest.cpp b/contrib/llvm/unittests/ADT/DeltaAlgorithmTest.cpp new file mode 100644 index 0000000..a1884cd --- /dev/null +++ b/contrib/llvm/unittests/ADT/DeltaAlgorithmTest.cpp @@ -0,0 +1,100 @@ +//===- llvm/unittest/ADT/DeltaAlgorithmTest.cpp ---------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "gtest/gtest.h" +#include "llvm/ADT/DeltaAlgorithm.h" +#include <algorithm> +#include <cstdarg> +using namespace llvm; + +namespace std { + +std::ostream &operator<<(std::ostream &OS, + const std::set<unsigned> &S) { + OS << "{"; + for (std::set<unsigned>::const_iterator it = S.begin(), + ie = S.end(); it != ie; ++it) { + if (it != S.begin()) + OS << ","; + OS << *it; + } + OS << "}"; + return OS; +} + +} + +namespace { + +class FixedDeltaAlgorithm : public DeltaAlgorithm { + changeset_ty FailingSet; + unsigned NumTests; + +protected: + virtual bool ExecuteOneTest(const changeset_ty &Changes) { + ++NumTests; + return std::includes(Changes.begin(), Changes.end(), + FailingSet.begin(), FailingSet.end()); + } + +public: + FixedDeltaAlgorithm(const changeset_ty &_FailingSet) + : FailingSet(_FailingSet), + NumTests(0) {} + + unsigned getNumTests() const { return NumTests; } +}; + +std::set<unsigned> fixed_set(unsigned N, ...) { + std::set<unsigned> S; + va_list ap; + va_start(ap, N); + for (unsigned i = 0; i != N; ++i) + S.insert(va_arg(ap, unsigned)); + va_end(ap); + return S; +} + +std::set<unsigned> range(unsigned Start, unsigned End) { + std::set<unsigned> S; + while (Start != End) + S.insert(Start++); + return S; +} + +std::set<unsigned> range(unsigned N) { + return range(0, N); +} + +TEST(DeltaAlgorithmTest, Basic) { + // P = {3,5,7} \in S + // [0, 20) should minimize to {3,5,7} in a reasonable number of tests. + std::set<unsigned> Fails = fixed_set(3, 3, 5, 7); + FixedDeltaAlgorithm FDA(Fails); + EXPECT_EQ(fixed_set(3, 3, 5, 7), FDA.Run(range(20))); + EXPECT_GE(33U, FDA.getNumTests()); + + // P = {3,5,7} \in S + // [10, 20) should minimize to [10,20) + EXPECT_EQ(range(10,20), FDA.Run(range(10,20))); + + // P = [0,4) \in S + // [0, 4) should minimize to [0,4) in 11 tests. + // + // 11 = |{ {}, + // {0}, {1}, {2}, {3}, + // {1, 2, 3}, {0, 2, 3}, {0, 1, 3}, {0, 1, 2}, + // {0, 1}, {2, 3} }| + FDA = FixedDeltaAlgorithm(range(10)); + EXPECT_EQ(range(4), FDA.Run(range(4))); + EXPECT_EQ(11U, FDA.getNumTests()); +} + +} + diff --git a/contrib/llvm/unittests/ADT/DenseMapTest.cpp b/contrib/llvm/unittests/ADT/DenseMapTest.cpp new file mode 100644 index 0000000..afac651 --- /dev/null +++ b/contrib/llvm/unittests/ADT/DenseMapTest.cpp @@ -0,0 +1,179 @@ +//===- llvm/unittest/ADT/DenseMapMap.cpp - DenseMap unit tests --*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "gtest/gtest.h" +#include "llvm/ADT/DenseMap.h" + +using namespace llvm; + +namespace { + +// Test fixture +class DenseMapTest : public testing::Test { +protected: + DenseMap<uint32_t, uint32_t> uintMap; + DenseMap<uint32_t *, uint32_t *> uintPtrMap; + uint32_t dummyInt; +}; + +// Empty map tests +TEST_F(DenseMapTest, EmptyIntMapTest) { + // Size tests + EXPECT_EQ(0u, uintMap.size()); + EXPECT_TRUE(uintMap.empty()); + + // Iterator tests + EXPECT_TRUE(uintMap.begin() == uintMap.end()); + + // Lookup tests + EXPECT_FALSE(uintMap.count(0u)); + EXPECT_TRUE(uintMap.find(0u) == uintMap.end()); + EXPECT_EQ(0u, uintMap.lookup(0u)); +} + +// Empty map tests for pointer map +TEST_F(DenseMapTest, EmptyPtrMapTest) { + // Size tests + EXPECT_EQ(0u, uintPtrMap.size()); + EXPECT_TRUE(uintPtrMap.empty()); + + // Iterator tests + EXPECT_TRUE(uintPtrMap.begin() == uintPtrMap.end()); + + // Lookup tests + EXPECT_FALSE(uintPtrMap.count(&dummyInt)); + EXPECT_TRUE(uintPtrMap.find(&dummyInt) == uintPtrMap.begin()); + EXPECT_EQ(0, uintPtrMap.lookup(&dummyInt)); +} + +// Constant map tests +TEST_F(DenseMapTest, ConstEmptyMapTest) { + const DenseMap<uint32_t, uint32_t> & constUintMap = uintMap; + const DenseMap<uint32_t *, uint32_t *> & constUintPtrMap = uintPtrMap; + EXPECT_EQ(0u, constUintMap.size()); + EXPECT_EQ(0u, constUintPtrMap.size()); + EXPECT_TRUE(constUintMap.empty()); + EXPECT_TRUE(constUintPtrMap.empty()); + EXPECT_TRUE(constUintMap.begin() == constUintMap.end()); + EXPECT_TRUE(constUintPtrMap.begin() == constUintPtrMap.end()); +} + +// A map with a single entry +TEST_F(DenseMapTest, SingleEntryMapTest) { + uintMap[0] = 1; + + // Size tests + EXPECT_EQ(1u, uintMap.size()); + EXPECT_FALSE(uintMap.begin() == uintMap.end()); + EXPECT_FALSE(uintMap.empty()); + + // Iterator tests + DenseMap<uint32_t, uint32_t>::iterator it = uintMap.begin(); + EXPECT_EQ(0u, it->first); + EXPECT_EQ(1u, it->second); + ++it; + EXPECT_TRUE(it == uintMap.end()); + + // Lookup tests + EXPECT_TRUE(uintMap.count(0u)); + EXPECT_TRUE(uintMap.find(0u) == uintMap.begin()); + EXPECT_EQ(1u, uintMap.lookup(0u)); + EXPECT_EQ(1u, uintMap[0]); +} + +// Test clear() method +TEST_F(DenseMapTest, ClearTest) { + uintMap[0] = 1; + uintMap.clear(); + + EXPECT_EQ(0u, uintMap.size()); + EXPECT_TRUE(uintMap.empty()); + EXPECT_TRUE(uintMap.begin() == uintMap.end()); +} + +// Test erase(iterator) method +TEST_F(DenseMapTest, EraseTest) { + uintMap[0] = 1; + uintMap.erase(uintMap.begin()); + + EXPECT_EQ(0u, uintMap.size()); + EXPECT_TRUE(uintMap.empty()); + EXPECT_TRUE(uintMap.begin() == uintMap.end()); +} + +// Test erase(value) method +TEST_F(DenseMapTest, EraseTest2) { + uintMap[0] = 1; + uintMap.erase(0); + + EXPECT_EQ(0u, uintMap.size()); + EXPECT_TRUE(uintMap.empty()); + EXPECT_TRUE(uintMap.begin() == uintMap.end()); +} + +// Test insert() method +TEST_F(DenseMapTest, InsertTest) { + uintMap.insert(std::make_pair(0u, 1u)); + EXPECT_EQ(1u, uintMap.size()); + EXPECT_EQ(1u, uintMap[0]); +} + +// Test copy constructor method +TEST_F(DenseMapTest, CopyConstructorTest) { + uintMap[0] = 1; + DenseMap<uint32_t, uint32_t> copyMap(uintMap); + + EXPECT_EQ(1u, copyMap.size()); + EXPECT_EQ(1u, copyMap[0]); +} + +// Test assignment operator method +TEST_F(DenseMapTest, AssignmentTest) { + uintMap[0] = 1; + DenseMap<uint32_t, uint32_t> copyMap = uintMap; + + EXPECT_EQ(1u, copyMap.size()); + EXPECT_EQ(1u, copyMap[0]); +} + +// A more complex iteration test +TEST_F(DenseMapTest, IterationTest) { + bool visited[100]; + + // Insert 100 numbers into the map + for (int i = 0; i < 100; ++i) { + visited[i] = false; + uintMap[i] = 3; + } + + // Iterate over all numbers and mark each one found. + for (DenseMap<uint32_t, uint32_t>::iterator it = uintMap.begin(); + it != uintMap.end(); ++it) { + visited[it->first] = true; + } + + // Ensure every number was visited. + for (int i = 0; i < 100; ++i) { + ASSERT_TRUE(visited[i]) << "Entry #" << i << " was never visited"; + } +} + +// const_iterator test +TEST_F(DenseMapTest, ConstIteratorTest) { + // Check conversion from iterator to const_iterator. + DenseMap<uint32_t, uint32_t>::iterator it = uintMap.begin(); + DenseMap<uint32_t, uint32_t>::const_iterator cit(it); + EXPECT_TRUE(it == cit); + + // Check copying of const_iterators. + DenseMap<uint32_t, uint32_t>::const_iterator cit2(cit); + EXPECT_TRUE(cit == cit2); +} + +} diff --git a/contrib/llvm/unittests/ADT/DenseSetTest.cpp b/contrib/llvm/unittests/ADT/DenseSetTest.cpp new file mode 100644 index 0000000..7a35f52 --- /dev/null +++ b/contrib/llvm/unittests/ADT/DenseSetTest.cpp @@ -0,0 +1,30 @@ +//===- llvm/unittest/ADT/DenseSetTest.cpp - DenseSet unit tests --*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "gtest/gtest.h" +#include <llvm/ADT/DenseSet.h> + +using namespace llvm; + +namespace { + +// Test fixture +class DenseSetTest : public testing::Test { +}; + +// Test hashing with a set of only two entries. +TEST_F(DenseSetTest, DoubleEntrySetTest) { + llvm::DenseSet<unsigned> set(2); + set.insert(0); + set.insert(1); + // Original failure was an infinite loop in this call: + EXPECT_EQ(0, set.count(2)); +} + +} diff --git a/contrib/llvm/unittests/ADT/ImmutableSetTest.cpp b/contrib/llvm/unittests/ADT/ImmutableSetTest.cpp new file mode 100644 index 0000000..1be510d --- /dev/null +++ b/contrib/llvm/unittests/ADT/ImmutableSetTest.cpp @@ -0,0 +1,201 @@ +//===----------- ImmutableSetTest.cpp - ImmutableSet unit tests ------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "gtest/gtest.h" +#include "llvm/ADT/ImmutableSet.h" + +using namespace llvm; + +namespace { +class ImmutableSetTest : public testing::Test { +protected: + // for callback tests + static char buffer[10]; + + struct MyIter { + int counter; + char *ptr; + + MyIter() : counter(0), ptr(buffer) { + for (unsigned i=0; i<sizeof(buffer);++i) buffer[i]='\0'; + } + void operator()(char c) { + *ptr++ = c; + ++counter; + } + }; +}; +char ImmutableSetTest::buffer[10]; + + +TEST_F(ImmutableSetTest, EmptyIntSetTest) { + ImmutableSet<int>::Factory f; + + EXPECT_TRUE(f.GetEmptySet() == f.GetEmptySet()); + EXPECT_FALSE(f.GetEmptySet() != f.GetEmptySet()); + EXPECT_TRUE(f.GetEmptySet().isEmpty()); + + ImmutableSet<int> S = f.GetEmptySet(); + EXPECT_EQ(0u, S.getHeight()); + EXPECT_TRUE(S.begin() == S.end()); + EXPECT_FALSE(S.begin() != S.end()); +} + + +TEST_F(ImmutableSetTest, OneElemIntSetTest) { + ImmutableSet<int>::Factory f; + ImmutableSet<int> S = f.GetEmptySet(); + + ImmutableSet<int> S2 = f.Add(S, 3); + EXPECT_TRUE(S.isEmpty()); + EXPECT_FALSE(S2.isEmpty()); + EXPECT_FALSE(S == S2); + EXPECT_TRUE(S != S2); + EXPECT_FALSE(S.contains(3)); + EXPECT_TRUE(S2.contains(3)); + EXPECT_FALSE(S2.begin() == S2.end()); + EXPECT_TRUE(S2.begin() != S2.end()); + + ImmutableSet<int> S3 = f.Add(S, 2); + EXPECT_TRUE(S.isEmpty()); + EXPECT_FALSE(S3.isEmpty()); + EXPECT_FALSE(S == S3); + EXPECT_TRUE(S != S3); + EXPECT_FALSE(S.contains(2)); + EXPECT_TRUE(S3.contains(2)); + + EXPECT_FALSE(S2 == S3); + EXPECT_TRUE(S2 != S3); + EXPECT_FALSE(S2.contains(2)); + EXPECT_FALSE(S3.contains(3)); +} + +TEST_F(ImmutableSetTest, MultiElemIntSetTest) { + ImmutableSet<int>::Factory f; + ImmutableSet<int> S = f.GetEmptySet(); + + ImmutableSet<int> S2 = f.Add(f.Add(f.Add(S, 3), 4), 5); + ImmutableSet<int> S3 = f.Add(f.Add(f.Add(S2, 9), 20), 43); + ImmutableSet<int> S4 = f.Add(S2, 9); + + EXPECT_TRUE(S.isEmpty()); + EXPECT_FALSE(S2.isEmpty()); + EXPECT_FALSE(S3.isEmpty()); + EXPECT_FALSE(S4.isEmpty()); + + EXPECT_FALSE(S.contains(3)); + EXPECT_FALSE(S.contains(9)); + + EXPECT_TRUE(S2.contains(3)); + EXPECT_TRUE(S2.contains(4)); + EXPECT_TRUE(S2.contains(5)); + EXPECT_FALSE(S2.contains(9)); + EXPECT_FALSE(S2.contains(0)); + + EXPECT_TRUE(S3.contains(43)); + EXPECT_TRUE(S3.contains(20)); + EXPECT_TRUE(S3.contains(9)); + EXPECT_TRUE(S3.contains(3)); + EXPECT_TRUE(S3.contains(4)); + EXPECT_TRUE(S3.contains(5)); + EXPECT_FALSE(S3.contains(0)); + + EXPECT_TRUE(S4.contains(9)); + EXPECT_TRUE(S4.contains(3)); + EXPECT_TRUE(S4.contains(4)); + EXPECT_TRUE(S4.contains(5)); + EXPECT_FALSE(S4.contains(20)); + EXPECT_FALSE(S4.contains(43)); +} + +TEST_F(ImmutableSetTest, RemoveIntSetTest) { + ImmutableSet<int>::Factory f; + ImmutableSet<int> S = f.GetEmptySet(); + + ImmutableSet<int> S2 = f.Add(f.Add(S, 4), 5); + ImmutableSet<int> S3 = f.Add(S2, 3); + ImmutableSet<int> S4 = f.Remove(S3, 3); + + EXPECT_TRUE(S3.contains(3)); + EXPECT_FALSE(S2.contains(3)); + EXPECT_FALSE(S4.contains(3)); + + EXPECT_TRUE(S2 == S4); + EXPECT_TRUE(S3 != S2); + EXPECT_TRUE(S3 != S4); + + EXPECT_TRUE(S3.contains(4)); + EXPECT_TRUE(S3.contains(5)); + + EXPECT_TRUE(S4.contains(4)); + EXPECT_TRUE(S4.contains(5)); +} + +TEST_F(ImmutableSetTest, CallbackCharSetTest) { + ImmutableSet<char>::Factory f; + ImmutableSet<char> S = f.GetEmptySet(); + + ImmutableSet<char> S2 = f.Add(f.Add(f.Add(S, 'a'), 'e'), 'i'); + ImmutableSet<char> S3 = f.Add(f.Add(S2, 'o'), 'u'); + + S3.foreach<MyIter>(); + + ASSERT_STREQ("aeiou", buffer); +} + +TEST_F(ImmutableSetTest, Callback2CharSetTest) { + ImmutableSet<char>::Factory f; + ImmutableSet<char> S = f.GetEmptySet(); + + ImmutableSet<char> S2 = f.Add(f.Add(f.Add(S, 'b'), 'c'), 'd'); + ImmutableSet<char> S3 = f.Add(f.Add(f.Add(S2, 'f'), 'g'), 'h'); + + MyIter obj; + S3.foreach<MyIter>(obj); + ASSERT_STREQ("bcdfgh", buffer); + ASSERT_EQ(6, obj.counter); + + MyIter obj2; + S2.foreach<MyIter>(obj2); + ASSERT_STREQ("bcd", buffer); + ASSERT_EQ(3, obj2.counter); + + MyIter obj3; + S.foreach<MyIter>(obj); + ASSERT_STREQ("", buffer); + ASSERT_EQ(0, obj3.counter); +} + +TEST_F(ImmutableSetTest, IterLongSetTest) { + ImmutableSet<long>::Factory f; + ImmutableSet<long> S = f.GetEmptySet(); + + ImmutableSet<long> S2 = f.Add(f.Add(f.Add(S, 0), 1), 2); + ImmutableSet<long> S3 = f.Add(f.Add(f.Add(S2, 3), 4), 5); + + int i = 0; + for (ImmutableSet<long>::iterator I = S.begin(), E = S.end(); I != E; ++I) { + ASSERT_EQ(i++, *I); + } + ASSERT_EQ(0, i); + + i = 0; + for (ImmutableSet<long>::iterator I = S2.begin(), E = S2.end(); I != E; ++I) { + ASSERT_EQ(i++, *I); + } + ASSERT_EQ(3, i); + + i = 0; + for (ImmutableSet<long>::iterator I = S3.begin(), E = S3.end(); I != E; I++) { + ASSERT_EQ(i++, *I); + } + ASSERT_EQ(6, i); +} + +} diff --git a/contrib/llvm/unittests/ADT/Makefile b/contrib/llvm/unittests/ADT/Makefile new file mode 100644 index 0000000..fe08328 --- /dev/null +++ b/contrib/llvm/unittests/ADT/Makefile @@ -0,0 +1,23 @@ +##===- unittests/ADT/Makefile ------------------------------*- Makefile -*-===## +# +# The LLVM Compiler Infrastructure +# +# This file is distributed under the University of Illinois Open Source +# License. See LICENSE.TXT for details. +# +##===----------------------------------------------------------------------===## + +LEVEL = ../.. +TESTNAME = ADT +LINK_COMPONENTS := core support + +include $(LEVEL)/Makefile.config + +# Xfail BitVectorTest for now on PPC Darwin. 7598360. +ifeq ($(ARCH),PowerPC) +ifeq ($(TARGET_OS),Darwin) +CPP.Flags += -DXFAIL +endif +endif + +include $(LLVM_SRC_ROOT)/unittests/Makefile.unittest diff --git a/contrib/llvm/unittests/ADT/SmallBitVectorTest.cpp b/contrib/llvm/unittests/ADT/SmallBitVectorTest.cpp new file mode 100644 index 0000000..9c69aad --- /dev/null +++ b/contrib/llvm/unittests/ADT/SmallBitVectorTest.cpp @@ -0,0 +1,189 @@ +//===- llvm/unittest/ADT/SmallBitVectorTest.cpp - SmallBitVector 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/SmallBitVector.h" +#include "gtest/gtest.h" + +using namespace llvm; + +namespace { + +TEST(SmallBitVectorTest, TrivialOperation) { + SmallBitVector Vec; + EXPECT_EQ(0U, Vec.count()); + EXPECT_EQ(0U, Vec.size()); + EXPECT_FALSE(Vec.any()); + EXPECT_TRUE(Vec.none()); + EXPECT_TRUE(Vec.empty()); + + Vec.resize(5, true); + EXPECT_EQ(5U, Vec.count()); + EXPECT_EQ(5U, Vec.size()); + EXPECT_TRUE(Vec.any()); + EXPECT_FALSE(Vec.none()); + EXPECT_FALSE(Vec.empty()); + + Vec.resize(11); + EXPECT_EQ(5U, Vec.count()); + EXPECT_EQ(11U, Vec.size()); + EXPECT_TRUE(Vec.any()); + EXPECT_FALSE(Vec.none()); + EXPECT_FALSE(Vec.empty()); + + SmallBitVector Inv = ~Vec; + EXPECT_EQ(6U, Inv.count()); + EXPECT_EQ(11U, Inv.size()); + EXPECT_TRUE(Inv.any()); + EXPECT_FALSE(Inv.none()); + EXPECT_FALSE(Inv.empty()); + + EXPECT_FALSE(Inv == Vec); + EXPECT_TRUE(Inv != Vec); + Vec = ~Vec; + EXPECT_TRUE(Inv == Vec); + EXPECT_FALSE(Inv != Vec); + + // Add some "interesting" data to Vec. + Vec.resize(23, true); + Vec.resize(25, false); + Vec.resize(26, true); + Vec.resize(29, false); + Vec.resize(33, true); + Vec.resize(57, false); + unsigned Count = 0; + for (unsigned i = Vec.find_first(); i != -1u; i = Vec.find_next(i)) { + ++Count; + EXPECT_TRUE(Vec[i]); + EXPECT_TRUE(Vec.test(i)); + } + EXPECT_EQ(Count, Vec.count()); + EXPECT_EQ(Count, 23u); + EXPECT_FALSE(Vec[0]); + EXPECT_TRUE(Vec[32]); + EXPECT_FALSE(Vec[56]); + Vec.resize(61, false); + + SmallBitVector Copy = Vec; + SmallBitVector Alt(3, false); + Alt.resize(6, true); + std::swap(Alt, Vec); + EXPECT_TRUE(Copy == Alt); + EXPECT_TRUE(Vec.size() == 6); + EXPECT_TRUE(Vec.count() == 3); + EXPECT_TRUE(Vec.find_first() == 3); + std::swap(Copy, Vec); + + // Add some more "interesting" data. + Vec.resize(68, true); + Vec.resize(78, false); + Vec.resize(89, true); + Vec.resize(90, false); + Vec.resize(91, true); + Vec.resize(130, false); + Count = 0; + for (unsigned i = Vec.find_first(); i != -1u; i = Vec.find_next(i)) { + ++Count; + EXPECT_TRUE(Vec[i]); + EXPECT_TRUE(Vec.test(i)); + } + EXPECT_EQ(Count, Vec.count()); + EXPECT_EQ(Count, 42u); + EXPECT_FALSE(Vec[0]); + EXPECT_TRUE(Vec[32]); + EXPECT_FALSE(Vec[60]); + EXPECT_FALSE(Vec[129]); + + Vec.flip(60); + EXPECT_TRUE(Vec[60]); + EXPECT_EQ(Count + 1, Vec.count()); + Vec.flip(60); + EXPECT_FALSE(Vec[60]); + EXPECT_EQ(Count, Vec.count()); + + Vec.reset(32); + EXPECT_FALSE(Vec[32]); + EXPECT_EQ(Count - 1, Vec.count()); + Vec.set(32); + EXPECT_TRUE(Vec[32]); + EXPECT_EQ(Count, Vec.count()); + + Vec.flip(); + EXPECT_EQ(Vec.size() - Count, Vec.count()); + + Vec.reset(); + EXPECT_EQ(0U, Vec.count()); + EXPECT_EQ(130U, Vec.size()); + EXPECT_FALSE(Vec.any()); + EXPECT_TRUE(Vec.none()); + EXPECT_FALSE(Vec.empty()); + + Inv = ~SmallBitVector(); + EXPECT_EQ(0U, Inv.count()); + EXPECT_EQ(0U, Inv.size()); + EXPECT_FALSE(Inv.any()); + EXPECT_TRUE(Inv.none()); + EXPECT_TRUE(Inv.empty()); + + Vec.clear(); + EXPECT_EQ(0U, Vec.count()); + EXPECT_EQ(0U, Vec.size()); + EXPECT_FALSE(Vec.any()); + EXPECT_TRUE(Vec.none()); + EXPECT_TRUE(Vec.empty()); +} + +TEST(SmallBitVectorTest, CompoundAssignment) { + SmallBitVector A; + A.resize(10); + A.set(4); + A.set(7); + + SmallBitVector B; + B.resize(50); + B.set(5); + B.set(18); + + A |= B; + EXPECT_TRUE(A.test(4)); + EXPECT_TRUE(A.test(5)); + EXPECT_TRUE(A.test(7)); + EXPECT_TRUE(A.test(18)); + EXPECT_EQ(4U, A.count()); + EXPECT_EQ(50U, A.size()); + + B.resize(10); + B.set(); + B.reset(2); + B.reset(7); + A &= B; + EXPECT_FALSE(A.test(2)); + EXPECT_FALSE(A.test(7)); + EXPECT_EQ(2U, A.count()); + EXPECT_EQ(50U, A.size()); + + B.resize(100); + B.set(); + + A ^= B; + EXPECT_TRUE(A.test(2)); + EXPECT_TRUE(A.test(7)); + EXPECT_EQ(98U, A.count()); + EXPECT_EQ(100U, A.size()); +} + +TEST(SmallBitVectorTest, ProxyIndex) { + SmallBitVector Vec(3); + EXPECT_TRUE(Vec.none()); + Vec[0] = Vec[1] = Vec[2] = true; + EXPECT_EQ(Vec.size(), Vec.count()); + Vec[2] = Vec[1] = Vec[0] = false; + EXPECT_TRUE(Vec.none()); +} + +} diff --git a/contrib/llvm/unittests/ADT/SmallStringTest.cpp b/contrib/llvm/unittests/ADT/SmallStringTest.cpp new file mode 100644 index 0000000..099d815 --- /dev/null +++ b/contrib/llvm/unittests/ADT/SmallStringTest.cpp @@ -0,0 +1,48 @@ +//===- llvm/unittest/ADT/SmallStringTest.cpp ------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// SmallString unit tests. +// +//===----------------------------------------------------------------------===// + +#include "gtest/gtest.h" +#include "llvm/ADT/SmallString.h" +#include <stdarg.h> +#include <climits> +#include <cstring> + +using namespace llvm; + +namespace { + +// Test fixture class +class SmallStringTest : public testing::Test { +protected: + typedef SmallString<40> StringType; + + StringType theString; + + void assertEmpty(StringType & v) { + // Size tests + EXPECT_EQ(0u, v.size()); + EXPECT_TRUE(v.empty()); + // Iterator tests + EXPECT_TRUE(v.begin() == v.end()); + } +}; + +// New string test. +TEST_F(SmallStringTest, EmptyStringTest) { + SCOPED_TRACE("EmptyStringTest"); + assertEmpty(theString); + EXPECT_TRUE(theString.rbegin() == theString.rend()); +} + +} + diff --git a/contrib/llvm/unittests/ADT/SmallVectorTest.cpp b/contrib/llvm/unittests/ADT/SmallVectorTest.cpp new file mode 100644 index 0000000..991c7d6 --- /dev/null +++ b/contrib/llvm/unittests/ADT/SmallVectorTest.cpp @@ -0,0 +1,408 @@ +//===- llvm/unittest/ADT/SmallVectorTest.cpp ------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// +// SmallVector unit tests. +// +//===----------------------------------------------------------------------===// + +#include "gtest/gtest.h" +#include "llvm/ADT/SmallVector.h" +#include <stdarg.h> +#include <list> + +using namespace llvm; + +namespace { + +/// A helper class that counts the total number of constructor and +/// destructor calls. +class Constructable { +private: + static int numConstructorCalls; + static int numDestructorCalls; + static int numAssignmentCalls; + + int value; + +public: + Constructable() : value(0) { + ++numConstructorCalls; + } + + Constructable(int val) : value(val) { + ++numConstructorCalls; + } + + Constructable(const Constructable & src) { + value = src.value; + ++numConstructorCalls; + } + + ~Constructable() { + ++numDestructorCalls; + } + + Constructable & operator=(const Constructable & src) { + value = src.value; + ++numAssignmentCalls; + return *this; + } + + int getValue() const { + return abs(value); + } + + static void reset() { + numConstructorCalls = 0; + numDestructorCalls = 0; + numAssignmentCalls = 0; + } + + static int getNumConstructorCalls() { + return numConstructorCalls; + } + + static int getNumDestructorCalls() { + return numDestructorCalls; + } + + friend bool operator==(const Constructable & c0, const Constructable & c1) { + return c0.getValue() == c1.getValue(); + } + + friend bool operator!=(const Constructable & c0, const Constructable & c1) { + return c0.getValue() != c1.getValue(); + } +}; + +int Constructable::numConstructorCalls; +int Constructable::numDestructorCalls; +int Constructable::numAssignmentCalls; + +// Test fixture class +class SmallVectorTest : public testing::Test { +protected: + typedef SmallVector<Constructable, 4> VectorType; + + VectorType theVector; + VectorType otherVector; + + void SetUp() { + Constructable::reset(); + } + + void assertEmpty(VectorType & v) { + // Size tests + EXPECT_EQ(0u, v.size()); + EXPECT_TRUE(v.empty()); + + // Iterator tests + EXPECT_TRUE(v.begin() == v.end()); + } + + // Assert that theVector contains the specified values, in order. + void assertValuesInOrder(VectorType & v, size_t size, ...) { + EXPECT_EQ(size, v.size()); + + va_list ap; + va_start(ap, size); + for (size_t i = 0; i < size; ++i) { + int value = va_arg(ap, int); + EXPECT_EQ(value, v[i].getValue()); + } + + va_end(ap); + } + + // Generate a sequence of values to initialize the vector. + void makeSequence(VectorType & v, int start, int end) { + for (int i = start; i <= end; ++i) { + v.push_back(Constructable(i)); + } + } +}; + +// New vector test. +TEST_F(SmallVectorTest, EmptyVectorTest) { + SCOPED_TRACE("EmptyVectorTest"); + assertEmpty(theVector); + EXPECT_TRUE(theVector.rbegin() == theVector.rend()); + EXPECT_EQ(0, Constructable::getNumConstructorCalls()); + EXPECT_EQ(0, Constructable::getNumDestructorCalls()); +} + +// Simple insertions and deletions. +TEST_F(SmallVectorTest, PushPopTest) { + SCOPED_TRACE("PushPopTest"); + + // Push an element + theVector.push_back(Constructable(1)); + + // Size tests + assertValuesInOrder(theVector, 1u, 1); + EXPECT_FALSE(theVector.begin() == theVector.end()); + EXPECT_FALSE(theVector.empty()); + + // Push another element + theVector.push_back(Constructable(2)); + assertValuesInOrder(theVector, 2u, 1, 2); + + // Pop one element + theVector.pop_back(); + assertValuesInOrder(theVector, 1u, 1); + + // Pop another element + theVector.pop_back(); + assertEmpty(theVector); + + // Check number of constructor calls. Should be 2 for each list element, + // one for the argument to push_back, and one for the list element itself. + EXPECT_EQ(4, Constructable::getNumConstructorCalls()); + EXPECT_EQ(4, Constructable::getNumDestructorCalls()); +} + +// Clear test. +TEST_F(SmallVectorTest, ClearTest) { + SCOPED_TRACE("ClearTest"); + + makeSequence(theVector, 1, 2); + theVector.clear(); + + assertEmpty(theVector); + EXPECT_EQ(4, Constructable::getNumConstructorCalls()); + EXPECT_EQ(4, Constructable::getNumDestructorCalls()); +} + +// Resize smaller test. +TEST_F(SmallVectorTest, ResizeShrinkTest) { + SCOPED_TRACE("ResizeShrinkTest"); + + makeSequence(theVector, 1, 3); + theVector.resize(1); + + assertValuesInOrder(theVector, 1u, 1); + EXPECT_EQ(6, Constructable::getNumConstructorCalls()); + EXPECT_EQ(5, Constructable::getNumDestructorCalls()); +} + +// Resize bigger test. +TEST_F(SmallVectorTest, ResizeGrowTest) { + SCOPED_TRACE("ResizeGrowTest"); + + theVector.resize(2); + + // The extra constructor/destructor calls come from the temporary object used + // to initialize the contents of the resized array (via copy construction). + EXPECT_EQ(3, Constructable::getNumConstructorCalls()); + EXPECT_EQ(1, Constructable::getNumDestructorCalls()); + EXPECT_EQ(2u, theVector.size()); +} + +// Resize with fill value. +TEST_F(SmallVectorTest, ResizeFillTest) { + SCOPED_TRACE("ResizeFillTest"); + + theVector.resize(3, Constructable(77)); + assertValuesInOrder(theVector, 3u, 77, 77, 77); +} + +// Overflow past fixed size. +TEST_F(SmallVectorTest, OverflowTest) { + SCOPED_TRACE("OverflowTest"); + + // Push more elements than the fixed size. + makeSequence(theVector, 1, 10); + + // Test size and values. + EXPECT_EQ(10u, theVector.size()); + for (int i = 0; i < 10; ++i) { + EXPECT_EQ(i+1, theVector[i].getValue()); + } + + // Now resize back to fixed size. + theVector.resize(1); + + assertValuesInOrder(theVector, 1u, 1); +} + +// Iteration tests. +TEST_F(SmallVectorTest, IterationTest) { + makeSequence(theVector, 1, 2); + + // Forward Iteration + VectorType::iterator it = theVector.begin(); + EXPECT_TRUE(*it == theVector.front()); + EXPECT_TRUE(*it == theVector[0]); + EXPECT_EQ(1, it->getValue()); + ++it; + EXPECT_TRUE(*it == theVector[1]); + EXPECT_TRUE(*it == theVector.back()); + EXPECT_EQ(2, it->getValue()); + ++it; + EXPECT_TRUE(it == theVector.end()); + --it; + EXPECT_TRUE(*it == theVector[1]); + EXPECT_EQ(2, it->getValue()); + --it; + EXPECT_TRUE(*it == theVector[0]); + EXPECT_EQ(1, it->getValue()); + + // Reverse Iteration + VectorType::reverse_iterator rit = theVector.rbegin(); + EXPECT_TRUE(*rit == theVector[1]); + EXPECT_EQ(2, rit->getValue()); + ++rit; + EXPECT_TRUE(*rit == theVector[0]); + EXPECT_EQ(1, rit->getValue()); + ++rit; + EXPECT_TRUE(rit == theVector.rend()); + --rit; + EXPECT_TRUE(*rit == theVector[0]); + EXPECT_EQ(1, rit->getValue()); + --rit; + EXPECT_TRUE(*rit == theVector[1]); + EXPECT_EQ(2, rit->getValue()); +} + +// Swap test. +TEST_F(SmallVectorTest, SwapTest) { + SCOPED_TRACE("SwapTest"); + + makeSequence(theVector, 1, 2); + std::swap(theVector, otherVector); + + assertEmpty(theVector); + assertValuesInOrder(otherVector, 2u, 1, 2); +} + +// Append test +TEST_F(SmallVectorTest, AppendTest) { + SCOPED_TRACE("AppendTest"); + + makeSequence(otherVector, 2, 3); + + theVector.push_back(Constructable(1)); + theVector.append(otherVector.begin(), otherVector.end()); + + assertValuesInOrder(theVector, 3u, 1, 2, 3); +} + +// Append repeated test +TEST_F(SmallVectorTest, AppendRepeatedTest) { + SCOPED_TRACE("AppendRepeatedTest"); + + theVector.push_back(Constructable(1)); + theVector.append(2, Constructable(77)); + assertValuesInOrder(theVector, 3u, 1, 77, 77); +} + +// Assign test +TEST_F(SmallVectorTest, AssignTest) { + SCOPED_TRACE("AssignTest"); + + theVector.push_back(Constructable(1)); + theVector.assign(2, Constructable(77)); + assertValuesInOrder(theVector, 2u, 77, 77); +} + +// Erase a single element +TEST_F(SmallVectorTest, EraseTest) { + SCOPED_TRACE("EraseTest"); + + makeSequence(theVector, 1, 3); + theVector.erase(theVector.begin()); + assertValuesInOrder(theVector, 2u, 2, 3); +} + +// Erase a range of elements +TEST_F(SmallVectorTest, EraseRangeTest) { + SCOPED_TRACE("EraseRangeTest"); + + makeSequence(theVector, 1, 3); + theVector.erase(theVector.begin(), theVector.begin() + 2); + assertValuesInOrder(theVector, 1u, 3); +} + +// Insert a single element. +TEST_F(SmallVectorTest, InsertTest) { + SCOPED_TRACE("InsertTest"); + + makeSequence(theVector, 1, 3); + theVector.insert(theVector.begin() + 1, Constructable(77)); + assertValuesInOrder(theVector, 4u, 1, 77, 2, 3); +} + +// Insert repeated elements. +TEST_F(SmallVectorTest, InsertRepeatedTest) { + SCOPED_TRACE("InsertRepeatedTest"); + + makeSequence(theVector, 10, 15); + theVector.insert(theVector.begin() + 1, 2, Constructable(16)); + assertValuesInOrder(theVector, 8u, 10, 16, 16, 11, 12, 13, 14, 15); +} + +// Insert range. +TEST_F(SmallVectorTest, InsertRangeTest) { + SCOPED_TRACE("InsertRepeatedTest"); + + makeSequence(theVector, 1, 3); + theVector.insert(theVector.begin() + 1, 3, Constructable(77)); + assertValuesInOrder(theVector, 6u, 1, 77, 77, 77, 2, 3); +} + +// Comparison tests. +TEST_F(SmallVectorTest, ComparisonTest) { + SCOPED_TRACE("ComparisonTest"); + + makeSequence(theVector, 1, 3); + makeSequence(otherVector, 1, 3); + + EXPECT_TRUE(theVector == otherVector); + EXPECT_FALSE(theVector != otherVector); + + otherVector.clear(); + makeSequence(otherVector, 2, 4); + + EXPECT_FALSE(theVector == otherVector); + EXPECT_TRUE(theVector != otherVector); +} + +// Constant vector tests. +TEST_F(SmallVectorTest, ConstVectorTest) { + const VectorType constVector; + + EXPECT_EQ(0u, constVector.size()); + EXPECT_TRUE(constVector.empty()); + EXPECT_TRUE(constVector.begin() == constVector.end()); +} + +// Direct array access. +TEST_F(SmallVectorTest, DirectVectorTest) { + EXPECT_EQ(0u, theVector.size()); + EXPECT_LE(4u, theVector.capacity()); + EXPECT_EQ(0, Constructable::getNumConstructorCalls()); + theVector.end()[0] = 1; + theVector.end()[1] = 2; + theVector.end()[2] = 3; + theVector.end()[3] = 4; + theVector.set_size(4); + EXPECT_EQ(4u, theVector.size()); + EXPECT_EQ(4, Constructable::getNumConstructorCalls()); + EXPECT_EQ(1, theVector[0].getValue()); + EXPECT_EQ(2, theVector[1].getValue()); + EXPECT_EQ(3, theVector[2].getValue()); + EXPECT_EQ(4, theVector[3].getValue()); +} + +TEST_F(SmallVectorTest, IteratorTest) { + std::list<int> L; + theVector.insert(theVector.end(), L.begin(), L.end()); +} + +} diff --git a/contrib/llvm/unittests/ADT/SparseBitVectorTest.cpp b/contrib/llvm/unittests/ADT/SparseBitVectorTest.cpp new file mode 100644 index 0000000..d8fc5ce --- /dev/null +++ b/contrib/llvm/unittests/ADT/SparseBitVectorTest.cpp @@ -0,0 +1,36 @@ +//===- llvm/unittest/ADT/SparseBitVectorTest.cpp - SparseBitVector 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/SparseBitVector.h" +#include "gtest/gtest.h" + +using namespace llvm; + +namespace { + +TEST(SparseBitVectorTest, TrivialOperation) { + SparseBitVector<> Vec; + EXPECT_EQ(0U, Vec.count()); + EXPECT_FALSE(Vec.test(17)); + Vec.set(5); + EXPECT_TRUE(Vec.test(5)); + EXPECT_FALSE(Vec.test(17)); + Vec.reset(6); + EXPECT_TRUE(Vec.test(5)); + EXPECT_FALSE(Vec.test(6)); + Vec.reset(5); + EXPECT_FALSE(Vec.test(5)); + EXPECT_TRUE(Vec.test_and_set(17)); + EXPECT_FALSE(Vec.test_and_set(17)); + EXPECT_TRUE(Vec.test(17)); + Vec.clear(); + EXPECT_FALSE(Vec.test(17)); +} + +} diff --git a/contrib/llvm/unittests/ADT/StringMapTest.cpp b/contrib/llvm/unittests/ADT/StringMapTest.cpp new file mode 100644 index 0000000..413f068 --- /dev/null +++ b/contrib/llvm/unittests/ADT/StringMapTest.cpp @@ -0,0 +1,207 @@ +//===- llvm/unittest/ADT/StringMapMap.cpp - StringMap unit tests ----------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "gtest/gtest.h" +#include "llvm/ADT/StringMap.h" +#include "llvm/System/DataTypes.h" +using namespace llvm; + +namespace { + +// Test fixture +class StringMapTest : public testing::Test { +protected: + StringMap<uint32_t> testMap; + + static const char testKey[]; + static const uint32_t testValue; + static const char* testKeyFirst; + static size_t testKeyLength; + static const std::string testKeyStr; + + void assertEmptyMap() { + // Size tests + EXPECT_EQ(0u, testMap.size()); + EXPECT_TRUE(testMap.empty()); + + // Iterator tests + EXPECT_TRUE(testMap.begin() == testMap.end()); + + // Lookup tests + EXPECT_EQ(0u, testMap.count(testKey)); + EXPECT_EQ(0u, testMap.count(StringRef(testKeyFirst, testKeyLength))); + EXPECT_EQ(0u, testMap.count(testKeyStr)); + EXPECT_TRUE(testMap.find(testKey) == testMap.end()); + EXPECT_TRUE(testMap.find(StringRef(testKeyFirst, testKeyLength)) == + testMap.end()); + EXPECT_TRUE(testMap.find(testKeyStr) == testMap.end()); + } + + void assertSingleItemMap() { + // Size tests + EXPECT_EQ(1u, testMap.size()); + EXPECT_FALSE(testMap.begin() == testMap.end()); + EXPECT_FALSE(testMap.empty()); + + // Iterator tests + StringMap<uint32_t>::iterator it = testMap.begin(); + EXPECT_STREQ(testKey, it->first()); + EXPECT_EQ(testValue, it->second); + ++it; + EXPECT_TRUE(it == testMap.end()); + + // Lookup tests + EXPECT_EQ(1u, testMap.count(testKey)); + EXPECT_EQ(1u, testMap.count(StringRef(testKeyFirst, testKeyLength))); + EXPECT_EQ(1u, testMap.count(testKeyStr)); + EXPECT_TRUE(testMap.find(testKey) == testMap.begin()); + EXPECT_TRUE(testMap.find(StringRef(testKeyFirst, testKeyLength)) == + testMap.begin()); + EXPECT_TRUE(testMap.find(testKeyStr) == testMap.begin()); + } +}; + +const char StringMapTest::testKey[] = "key"; +const uint32_t StringMapTest::testValue = 1u; +const char* StringMapTest::testKeyFirst = testKey; +size_t StringMapTest::testKeyLength = sizeof(testKey) - 1; +const std::string StringMapTest::testKeyStr(testKey); + +// Empty map tests. +TEST_F(StringMapTest, EmptyMapTest) { + SCOPED_TRACE("EmptyMapTest"); + assertEmptyMap(); +} + +// Constant map tests. +TEST_F(StringMapTest, ConstEmptyMapTest) { + const StringMap<uint32_t>& constTestMap = testMap; + + // Size tests + EXPECT_EQ(0u, constTestMap.size()); + EXPECT_TRUE(constTestMap.empty()); + + // Iterator tests + EXPECT_TRUE(constTestMap.begin() == constTestMap.end()); + + // Lookup tests + EXPECT_EQ(0u, constTestMap.count(testKey)); + EXPECT_EQ(0u, constTestMap.count(StringRef(testKeyFirst, testKeyLength))); + EXPECT_EQ(0u, constTestMap.count(testKeyStr)); + EXPECT_TRUE(constTestMap.find(testKey) == constTestMap.end()); + EXPECT_TRUE(constTestMap.find(StringRef(testKeyFirst, testKeyLength)) == + constTestMap.end()); + EXPECT_TRUE(constTestMap.find(testKeyStr) == constTestMap.end()); +} + +// A map with a single entry. +TEST_F(StringMapTest, SingleEntryMapTest) { + SCOPED_TRACE("SingleEntryMapTest"); + testMap[testKey] = testValue; + assertSingleItemMap(); +} + +// Test clear() method. +TEST_F(StringMapTest, ClearTest) { + SCOPED_TRACE("ClearTest"); + testMap[testKey] = testValue; + testMap.clear(); + assertEmptyMap(); +} + +// Test erase(iterator) method. +TEST_F(StringMapTest, EraseIteratorTest) { + SCOPED_TRACE("EraseIteratorTest"); + testMap[testKey] = testValue; + testMap.erase(testMap.begin()); + assertEmptyMap(); +} + +// Test erase(value) method. +TEST_F(StringMapTest, EraseValueTest) { + SCOPED_TRACE("EraseValueTest"); + testMap[testKey] = testValue; + testMap.erase(testKey); + assertEmptyMap(); +} + +// Test inserting two values and erasing one. +TEST_F(StringMapTest, InsertAndEraseTest) { + SCOPED_TRACE("InsertAndEraseTest"); + testMap[testKey] = testValue; + testMap["otherKey"] = 2; + testMap.erase("otherKey"); + assertSingleItemMap(); +} + +// A more complex iteration test. +TEST_F(StringMapTest, IterationTest) { + bool visited[100]; + + // Insert 100 numbers into the map + for (int i = 0; i < 100; ++i) { + std::stringstream ss; + ss << "key_" << i; + testMap[ss.str()] = i; + visited[i] = false; + } + + // Iterate over all numbers and mark each one found. + for (StringMap<uint32_t>::iterator it = testMap.begin(); + it != testMap.end(); ++it) { + std::stringstream ss; + ss << "key_" << it->second; + ASSERT_STREQ(ss.str().c_str(), it->first()); + visited[it->second] = true; + } + + // Ensure every number was visited. + for (int i = 0; i < 100; ++i) { + ASSERT_TRUE(visited[i]) << "Entry #" << i << " was never visited"; + } +} + +} // end anonymous namespace + +namespace llvm { + +template <> +class StringMapEntryInitializer<uint32_t> { +public: + template <typename InitTy> + static void Initialize(StringMapEntry<uint32_t> &T, InitTy InitVal) { + T.second = InitVal; + } +}; + +} // end llvm namespace + +namespace { + +// Test StringMapEntry::Create() method. +TEST_F(StringMapTest, StringMapEntryTest) { + StringMap<uint32_t>::value_type* entry = + StringMap<uint32_t>::value_type::Create( + testKeyFirst, testKeyFirst + testKeyLength, 1u); + EXPECT_STREQ(testKey, entry->first()); + EXPECT_EQ(1u, entry->second); + free(entry); +} + +// Test insert() method. +TEST_F(StringMapTest, InsertTest) { + SCOPED_TRACE("InsertTest"); + testMap.insert( + StringMap<uint32_t>::value_type::Create( + testKeyFirst, testKeyFirst + testKeyLength, + testMap.getAllocator(), 1u)); + assertSingleItemMap(); +} + +} // end anonymous namespace diff --git a/contrib/llvm/unittests/ADT/StringRefTest.cpp b/contrib/llvm/unittests/ADT/StringRefTest.cpp new file mode 100644 index 0000000..887ba5d --- /dev/null +++ b/contrib/llvm/unittests/ADT/StringRefTest.cpp @@ -0,0 +1,273 @@ +//===- llvm/unittest/ADT/StringRefTest.cpp - StringRef unit tests ---------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "gtest/gtest.h" +#include "llvm/ADT/StringRef.h" +#include "llvm/ADT/SmallVector.h" +#include "llvm/Support/raw_ostream.h" +using namespace llvm; + +namespace llvm { + +std::ostream &operator<<(std::ostream &OS, const StringRef &S) { + OS << S; + return OS; +} + +std::ostream &operator<<(std::ostream &OS, + const std::pair<StringRef, StringRef> &P) { + OS << "(" << P.first << ", " << P.second << ")"; + return OS; +} + +} + +namespace { +TEST(StringRefTest, Construction) { + EXPECT_EQ("", StringRef()); + EXPECT_EQ("hello", StringRef("hello")); + EXPECT_EQ("hello", StringRef("hello world", 5)); + EXPECT_EQ("hello", StringRef(std::string("hello"))); +} + +TEST(StringRefTest, Iteration) { + StringRef S("hello"); + const char *p = "hello"; + for (const char *it = S.begin(), *ie = S.end(); it != ie; ++it, ++p) + EXPECT_EQ(*it, *p); +} + +TEST(StringRefTest, StringOps) { + const char *p = "hello"; + EXPECT_EQ(p, StringRef(p, 0).data()); + EXPECT_TRUE(StringRef().empty()); + EXPECT_EQ((size_t) 5, StringRef("hello").size()); + EXPECT_EQ(-1, StringRef("aab").compare("aad")); + EXPECT_EQ( 0, StringRef("aab").compare("aab")); + EXPECT_EQ( 1, StringRef("aab").compare("aaa")); + EXPECT_EQ(-1, StringRef("aab").compare("aabb")); + EXPECT_EQ( 1, StringRef("aab").compare("aa")); + + EXPECT_EQ(-1, StringRef("aab").compare_numeric("aad")); + EXPECT_EQ( 0, StringRef("aab").compare_numeric("aab")); + EXPECT_EQ( 1, StringRef("aab").compare_numeric("aaa")); + EXPECT_EQ(-1, StringRef("aab").compare_numeric("aabb")); + EXPECT_EQ( 1, StringRef("aab").compare_numeric("aa")); + EXPECT_EQ(-1, StringRef("1").compare_numeric("10")); + EXPECT_EQ( 0, StringRef("10").compare_numeric("10")); + EXPECT_EQ( 0, StringRef("10a").compare_numeric("10a")); + EXPECT_EQ( 1, StringRef("2").compare_numeric("1")); + EXPECT_EQ( 0, StringRef("llvm_v1i64_ty").compare_numeric("llvm_v1i64_ty")); +} + +TEST(StringRefTest, Operators) { + EXPECT_EQ("", StringRef()); + EXPECT_TRUE(StringRef("aab") < StringRef("aad")); + EXPECT_FALSE(StringRef("aab") < StringRef("aab")); + EXPECT_TRUE(StringRef("aab") <= StringRef("aab")); + EXPECT_FALSE(StringRef("aab") <= StringRef("aaa")); + EXPECT_TRUE(StringRef("aad") > StringRef("aab")); + EXPECT_FALSE(StringRef("aab") > StringRef("aab")); + EXPECT_TRUE(StringRef("aab") >= StringRef("aab")); + EXPECT_FALSE(StringRef("aaa") >= StringRef("aab")); + EXPECT_EQ(StringRef("aab"), StringRef("aab")); + EXPECT_FALSE(StringRef("aab") == StringRef("aac")); + EXPECT_FALSE(StringRef("aab") != StringRef("aab")); + EXPECT_TRUE(StringRef("aab") != StringRef("aac")); + EXPECT_EQ('a', StringRef("aab")[1]); +} + +TEST(StringRefTest, Substr) { + StringRef Str("hello"); + EXPECT_EQ("lo", Str.substr(3)); + EXPECT_EQ("", Str.substr(100)); + EXPECT_EQ("hello", Str.substr(0, 100)); + EXPECT_EQ("o", Str.substr(4, 10)); +} + +TEST(StringRefTest, Slice) { + StringRef Str("hello"); + EXPECT_EQ("l", Str.slice(2, 3)); + EXPECT_EQ("ell", Str.slice(1, 4)); + EXPECT_EQ("llo", Str.slice(2, 100)); + EXPECT_EQ("", Str.slice(2, 1)); + EXPECT_EQ("", Str.slice(10, 20)); +} + +TEST(StringRefTest, Split) { + StringRef Str("hello"); + EXPECT_EQ(std::make_pair(StringRef("hello"), StringRef("")), + Str.split('X')); + EXPECT_EQ(std::make_pair(StringRef("h"), StringRef("llo")), + Str.split('e')); + EXPECT_EQ(std::make_pair(StringRef(""), StringRef("ello")), + Str.split('h')); + EXPECT_EQ(std::make_pair(StringRef("he"), StringRef("lo")), + Str.split('l')); + EXPECT_EQ(std::make_pair(StringRef("hell"), StringRef("")), + Str.split('o')); + + EXPECT_EQ(std::make_pair(StringRef("hello"), StringRef("")), + Str.rsplit('X')); + EXPECT_EQ(std::make_pair(StringRef("h"), StringRef("llo")), + Str.rsplit('e')); + EXPECT_EQ(std::make_pair(StringRef(""), StringRef("ello")), + Str.rsplit('h')); + EXPECT_EQ(std::make_pair(StringRef("hel"), StringRef("o")), + Str.rsplit('l')); + EXPECT_EQ(std::make_pair(StringRef("hell"), StringRef("")), + Str.rsplit('o')); +} + +TEST(StringRefTest, Split2) { + SmallVector<StringRef, 5> parts; + SmallVector<StringRef, 5> expected; + + expected.push_back("ab"); expected.push_back("c"); + StringRef(",ab,,c,").split(parts, ",", -1, false); + EXPECT_TRUE(parts == expected); + + expected.clear(); parts.clear(); + expected.push_back(""); expected.push_back("ab"); expected.push_back(""); + expected.push_back("c"); expected.push_back(""); + StringRef(",ab,,c,").split(parts, ",", -1, true); + EXPECT_TRUE(parts == expected); + + expected.clear(); parts.clear(); + expected.push_back(""); + StringRef("").split(parts, ",", -1, true); + EXPECT_TRUE(parts == expected); + + expected.clear(); parts.clear(); + StringRef("").split(parts, ",", -1, false); + EXPECT_TRUE(parts == expected); + + expected.clear(); parts.clear(); + StringRef(",").split(parts, ",", -1, false); + EXPECT_TRUE(parts == expected); + + expected.clear(); parts.clear(); + expected.push_back(""); expected.push_back(""); + StringRef(",").split(parts, ",", -1, true); + EXPECT_TRUE(parts == expected); + + expected.clear(); parts.clear(); + expected.push_back("a"); expected.push_back("b"); + StringRef("a,b").split(parts, ",", -1, true); + EXPECT_TRUE(parts == expected); + + // Test MaxSplit + expected.clear(); parts.clear(); + expected.push_back("a,,b,c"); + StringRef("a,,b,c").split(parts, ",", 0, true); + EXPECT_TRUE(parts == expected); + + expected.clear(); parts.clear(); + expected.push_back("a,,b,c"); + StringRef("a,,b,c").split(parts, ",", 0, false); + EXPECT_TRUE(parts == expected); + + expected.clear(); parts.clear(); + expected.push_back("a"); expected.push_back(",b,c"); + StringRef("a,,b,c").split(parts, ",", 1, true); + EXPECT_TRUE(parts == expected); + + expected.clear(); parts.clear(); + expected.push_back("a"); expected.push_back(",b,c"); + StringRef("a,,b,c").split(parts, ",", 1, false); + EXPECT_TRUE(parts == expected); + + expected.clear(); parts.clear(); + expected.push_back("a"); expected.push_back(""); expected.push_back("b,c"); + StringRef("a,,b,c").split(parts, ",", 2, true); + EXPECT_TRUE(parts == expected); + + expected.clear(); parts.clear(); + expected.push_back("a"); expected.push_back("b,c"); + StringRef("a,,b,c").split(parts, ",", 2, false); + EXPECT_TRUE(parts == expected); + + expected.clear(); parts.clear(); + expected.push_back("a"); expected.push_back(""); expected.push_back("b"); + expected.push_back("c"); + StringRef("a,,b,c").split(parts, ",", 3, true); + EXPECT_TRUE(parts == expected); + + expected.clear(); parts.clear(); + expected.push_back("a"); expected.push_back("b"); expected.push_back("c"); + StringRef("a,,b,c").split(parts, ",", 3, false); + EXPECT_TRUE(parts == expected); +} + +TEST(StringRefTest, StartsWith) { + StringRef Str("hello"); + EXPECT_TRUE(Str.startswith("he")); + EXPECT_FALSE(Str.startswith("helloworld")); + EXPECT_FALSE(Str.startswith("hi")); +} + +TEST(StringRefTest, EndsWith) { + StringRef Str("hello"); + EXPECT_TRUE(Str.endswith("lo")); + EXPECT_FALSE(Str.endswith("helloworld")); + EXPECT_FALSE(Str.endswith("worldhello")); + EXPECT_FALSE(Str.endswith("so")); +} + +TEST(StringRefTest, Find) { + StringRef Str("hello"); + EXPECT_EQ(2U, Str.find('l')); + EXPECT_EQ(StringRef::npos, Str.find('z')); + EXPECT_EQ(StringRef::npos, Str.find("helloworld")); + EXPECT_EQ(0U, Str.find("hello")); + EXPECT_EQ(1U, Str.find("ello")); + EXPECT_EQ(StringRef::npos, Str.find("zz")); + EXPECT_EQ(2U, Str.find("ll", 2)); + EXPECT_EQ(StringRef::npos, Str.find("ll", 3)); + + EXPECT_EQ(3U, Str.rfind('l')); + EXPECT_EQ(StringRef::npos, Str.rfind('z')); + EXPECT_EQ(StringRef::npos, Str.rfind("helloworld")); + EXPECT_EQ(0U, Str.rfind("hello")); + EXPECT_EQ(1U, Str.rfind("ello")); + EXPECT_EQ(StringRef::npos, Str.rfind("zz")); + + EXPECT_EQ(2U, Str.find_first_of('l')); + EXPECT_EQ(1U, Str.find_first_of("el")); + EXPECT_EQ(StringRef::npos, Str.find_first_of("xyz")); + + EXPECT_EQ(1U, Str.find_first_not_of('h')); + EXPECT_EQ(4U, Str.find_first_not_of("hel")); + EXPECT_EQ(StringRef::npos, Str.find_first_not_of("hello")); +} + +TEST(StringRefTest, Count) { + StringRef Str("hello"); + EXPECT_EQ(2U, Str.count('l')); + EXPECT_EQ(1U, Str.count('o')); + EXPECT_EQ(0U, Str.count('z')); + EXPECT_EQ(0U, Str.count("helloworld")); + EXPECT_EQ(1U, Str.count("hello")); + EXPECT_EQ(1U, Str.count("ello")); + EXPECT_EQ(0U, Str.count("zz")); +} + +TEST(StringRefTest, EditDistance) { + StringRef Str("hello"); + EXPECT_EQ(2U, Str.edit_distance("hill")); +} + +TEST(StringRefTest, Misc) { + std::string Storage; + raw_string_ostream OS(Storage); + OS << StringRef("hello"); + EXPECT_EQ("hello", OS.str()); +} + +} // end anonymous namespace diff --git a/contrib/llvm/unittests/ADT/TripleTest.cpp b/contrib/llvm/unittests/ADT/TripleTest.cpp new file mode 100644 index 0000000..1a9e81a --- /dev/null +++ b/contrib/llvm/unittests/ADT/TripleTest.cpp @@ -0,0 +1,149 @@ +//===----------- Triple.cpp - Triple unit tests ---------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "gtest/gtest.h" +#include "llvm/ADT/Triple.h" + +using namespace llvm; + +namespace { + +TEST(TripleTest, BasicParsing) { + Triple T; + + T = Triple(""); + EXPECT_EQ("", T.getArchName().str()); + EXPECT_EQ("", T.getVendorName().str()); + EXPECT_EQ("", T.getOSName().str()); + EXPECT_EQ("", T.getEnvironmentName().str()); + + T = Triple("-"); + EXPECT_EQ("", T.getArchName().str()); + EXPECT_EQ("", T.getVendorName().str()); + EXPECT_EQ("", T.getOSName().str()); + EXPECT_EQ("", T.getEnvironmentName().str()); + + T = Triple("--"); + EXPECT_EQ("", T.getArchName().str()); + EXPECT_EQ("", T.getVendorName().str()); + EXPECT_EQ("", T.getOSName().str()); + EXPECT_EQ("", T.getEnvironmentName().str()); + + T = Triple("---"); + EXPECT_EQ("", T.getArchName().str()); + EXPECT_EQ("", T.getVendorName().str()); + EXPECT_EQ("", T.getOSName().str()); + EXPECT_EQ("", T.getEnvironmentName().str()); + + T = Triple("----"); + EXPECT_EQ("", T.getArchName().str()); + EXPECT_EQ("", T.getVendorName().str()); + EXPECT_EQ("", T.getOSName().str()); + EXPECT_EQ("-", T.getEnvironmentName().str()); + + T = Triple("a"); + EXPECT_EQ("a", T.getArchName().str()); + EXPECT_EQ("", T.getVendorName().str()); + EXPECT_EQ("", T.getOSName().str()); + EXPECT_EQ("", T.getEnvironmentName().str()); + + T = Triple("a-b"); + EXPECT_EQ("a", T.getArchName().str()); + EXPECT_EQ("b", T.getVendorName().str()); + EXPECT_EQ("", T.getOSName().str()); + EXPECT_EQ("", T.getEnvironmentName().str()); + + T = Triple("a-b-c"); + EXPECT_EQ("a", T.getArchName().str()); + EXPECT_EQ("b", T.getVendorName().str()); + EXPECT_EQ("c", T.getOSName().str()); + EXPECT_EQ("", T.getEnvironmentName().str()); + + T = Triple("a-b-c-d"); + EXPECT_EQ("a", T.getArchName().str()); + EXPECT_EQ("b", T.getVendorName().str()); + EXPECT_EQ("c", T.getOSName().str()); + EXPECT_EQ("d", T.getEnvironmentName().str()); +} + +TEST(TripleTest, ParsedIDs) { + Triple T; + + T = Triple("i386-apple-darwin"); + EXPECT_EQ(Triple::x86, T.getArch()); + EXPECT_EQ(Triple::Apple, T.getVendor()); + EXPECT_EQ(Triple::Darwin, T.getOS()); + + T = Triple("x86_64-pc-linux-gnu"); + EXPECT_EQ(Triple::x86_64, T.getArch()); + EXPECT_EQ(Triple::PC, T.getVendor()); + EXPECT_EQ(Triple::Linux, T.getOS()); + + T = Triple("powerpc-dunno-notsure"); + EXPECT_EQ(Triple::ppc, T.getArch()); + EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); + EXPECT_EQ(Triple::UnknownOS, T.getOS()); + + T = Triple("huh"); + EXPECT_EQ(Triple::UnknownArch, T.getArch()); + + // Two exceptional cases. + + T = Triple("i386-mingw32"); + EXPECT_EQ(Triple::x86, T.getArch()); + EXPECT_EQ(Triple::PC, T.getVendor()); + EXPECT_EQ(Triple::MinGW32, T.getOS()); + + T = Triple("arm-elf"); + EXPECT_EQ(Triple::arm, T.getArch()); + EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); + EXPECT_EQ(Triple::UnknownOS, T.getOS()); +} + +TEST(TripleTest, MutateName) { + Triple T; + EXPECT_EQ(Triple::UnknownArch, T.getArch()); + EXPECT_EQ(Triple::UnknownVendor, T.getVendor()); + EXPECT_EQ(Triple::UnknownOS, T.getOS()); + + T.setArchName("i386"); + EXPECT_EQ(Triple::x86, T.getArch()); + EXPECT_EQ("i386--", T.getTriple()); + + T.setVendorName("pc"); + EXPECT_EQ(Triple::x86, T.getArch()); + EXPECT_EQ(Triple::PC, T.getVendor()); + EXPECT_EQ("i386-pc-", T.getTriple()); + + T.setOSName("linux"); + EXPECT_EQ(Triple::x86, T.getArch()); + EXPECT_EQ(Triple::PC, T.getVendor()); + EXPECT_EQ(Triple::Linux, T.getOS()); + EXPECT_EQ("i386-pc-linux", T.getTriple()); + + T.setEnvironmentName("gnu"); + EXPECT_EQ(Triple::x86, T.getArch()); + EXPECT_EQ(Triple::PC, T.getVendor()); + EXPECT_EQ(Triple::Linux, T.getOS()); + EXPECT_EQ("i386-pc-linux-gnu", T.getTriple()); + + T.setOSName("freebsd"); + EXPECT_EQ(Triple::x86, T.getArch()); + EXPECT_EQ(Triple::PC, T.getVendor()); + EXPECT_EQ(Triple::FreeBSD, T.getOS()); + EXPECT_EQ("i386-pc-freebsd-gnu", T.getTriple()); + + T.setOSAndEnvironmentName("darwin"); + EXPECT_EQ(Triple::x86, T.getArch()); + EXPECT_EQ(Triple::PC, T.getVendor()); + EXPECT_EQ(Triple::Darwin, T.getOS()); + EXPECT_EQ("i386-pc-darwin", T.getTriple()); +} + +} diff --git a/contrib/llvm/unittests/ADT/TwineTest.cpp b/contrib/llvm/unittests/ADT/TwineTest.cpp new file mode 100644 index 0000000..61e8a0a --- /dev/null +++ b/contrib/llvm/unittests/ADT/TwineTest.cpp @@ -0,0 +1,75 @@ +//===- TwineTest.cpp - Twine unit tests -----------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "gtest/gtest.h" +#include "llvm/ADT/Twine.h" +#include "llvm/Support/raw_ostream.h" +using namespace llvm; + +namespace { + +std::string repr(const Twine &Value) { + std::string res; + llvm::raw_string_ostream OS(res); + Value.printRepr(OS); + return OS.str(); +} + +TEST(TwineTest, Construction) { + EXPECT_EQ("", Twine().str()); + EXPECT_EQ("hi", Twine("hi").str()); + EXPECT_EQ("hi", Twine(std::string("hi")).str()); + EXPECT_EQ("hi", Twine(StringRef("hi")).str()); + EXPECT_EQ("hi", Twine(StringRef(std::string("hi"))).str()); + EXPECT_EQ("hi", Twine(StringRef("hithere", 2)).str()); +} + +TEST(TwineTest, Numbers) { + EXPECT_EQ("123", Twine(123U).str()); + EXPECT_EQ("123", Twine(123).str()); + EXPECT_EQ("-123", Twine(-123).str()); + EXPECT_EQ("123", Twine(123).str()); + EXPECT_EQ("-123", Twine(-123).str()); + EXPECT_EQ("123", Twine((char) 123).str()); + EXPECT_EQ("-123", Twine((signed char) -123).str()); + + EXPECT_EQ("7b", Twine::utohexstr(123).str()); +} + +TEST(TwineTest, Concat) { + // Check verse repr, since we care about the actual representation not just + // the result. + + // Concat with null. + EXPECT_EQ("(Twine null empty)", + repr(Twine("hi").concat(Twine::createNull()))); + EXPECT_EQ("(Twine null empty)", + repr(Twine::createNull().concat(Twine("hi")))); + + // Concat with empty. + EXPECT_EQ("(Twine cstring:\"hi\" empty)", + repr(Twine("hi").concat(Twine()))); + EXPECT_EQ("(Twine cstring:\"hi\" empty)", + repr(Twine().concat(Twine("hi")))); + + // Concatenation of unary ropes. + EXPECT_EQ("(Twine cstring:\"a\" cstring:\"b\")", + repr(Twine("a").concat(Twine("b")))); + + // Concatenation of other ropes. + EXPECT_EQ("(Twine rope:(Twine cstring:\"a\" cstring:\"b\") cstring:\"c\")", + repr(Twine("a").concat(Twine("b")).concat(Twine("c")))); + EXPECT_EQ("(Twine cstring:\"a\" rope:(Twine cstring:\"b\" cstring:\"c\"))", + repr(Twine("a").concat(Twine("b").concat(Twine("c"))))); +} + + // I suppose linking in the entire code generator to add a unit test to check + // the code size of the concat operation is overkill... :) + +} // end anonymous namespace diff --git a/contrib/llvm/unittests/ADT/ValueMapTest.cpp b/contrib/llvm/unittests/ADT/ValueMapTest.cpp new file mode 100644 index 0000000..2fc0938 --- /dev/null +++ b/contrib/llvm/unittests/ADT/ValueMapTest.cpp @@ -0,0 +1,294 @@ +//===- llvm/unittest/ADT/ValueMapTest.cpp - ValueMap unit tests -*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "llvm/ADT/ValueMap.h" +#include "llvm/Instructions.h" +#include "llvm/LLVMContext.h" +#include "llvm/ADT/OwningPtr.h" +#include "llvm/Config/config.h" + +#include "gtest/gtest.h" + +using namespace llvm; + +namespace { + +// Test fixture +template<typename T> +class ValueMapTest : public testing::Test { +protected: + Constant *ConstantV; + OwningPtr<BitCastInst> BitcastV; + OwningPtr<BinaryOperator> AddV; + + ValueMapTest() : + ConstantV(ConstantInt::get(Type::getInt32Ty(getGlobalContext()), 0)), + BitcastV(new BitCastInst(ConstantV, Type::getInt32Ty(getGlobalContext()))), + AddV(BinaryOperator::CreateAdd(ConstantV, ConstantV)) { + } +}; + +// Run everything on Value*, a subtype to make sure that casting works as +// expected, and a const subtype to make sure we cast const correctly. +typedef ::testing::Types<Value, Instruction, const Instruction> KeyTypes; +TYPED_TEST_CASE(ValueMapTest, KeyTypes); + +TYPED_TEST(ValueMapTest, Null) { + ValueMap<TypeParam*, int> VM1; + VM1[NULL] = 7; + EXPECT_EQ(7, VM1.lookup(NULL)); +} + +TYPED_TEST(ValueMapTest, FollowsValue) { + ValueMap<TypeParam*, int> VM; + VM[this->BitcastV.get()] = 7; + EXPECT_EQ(7, VM.lookup(this->BitcastV.get())); + EXPECT_EQ(0, VM.count(this->AddV.get())); + this->BitcastV->replaceAllUsesWith(this->AddV.get()); + EXPECT_EQ(7, VM.lookup(this->AddV.get())); + EXPECT_EQ(0, VM.count(this->BitcastV.get())); + this->AddV.reset(); + EXPECT_EQ(0, VM.count(this->AddV.get())); + EXPECT_EQ(0, VM.count(this->BitcastV.get())); + EXPECT_EQ(0U, VM.size()); +} + +TYPED_TEST(ValueMapTest, OperationsWork) { + ValueMap<TypeParam*, int> VM; + ValueMap<TypeParam*, int> VM2(16); (void)VM2; + typename ValueMapConfig<TypeParam*>::ExtraData Data; + ValueMap<TypeParam*, int> VM3(Data, 16); (void)VM3; + EXPECT_TRUE(VM.empty()); + + VM[this->BitcastV.get()] = 7; + + // Find: + typename ValueMap<TypeParam*, int>::iterator I = + VM.find(this->BitcastV.get()); + ASSERT_TRUE(I != VM.end()); + EXPECT_EQ(this->BitcastV.get(), I->first); + EXPECT_EQ(7, I->second); + EXPECT_TRUE(VM.find(this->AddV.get()) == VM.end()); + + // Const find: + const ValueMap<TypeParam*, int> &CVM = VM; + typename ValueMap<TypeParam*, int>::const_iterator CI = + CVM.find(this->BitcastV.get()); + ASSERT_TRUE(CI != CVM.end()); + EXPECT_EQ(this->BitcastV.get(), CI->first); + EXPECT_EQ(7, CI->second); + EXPECT_TRUE(CVM.find(this->AddV.get()) == CVM.end()); + + // Insert: + std::pair<typename ValueMap<TypeParam*, int>::iterator, bool> InsertResult1 = + VM.insert(std::make_pair(this->AddV.get(), 3)); + EXPECT_EQ(this->AddV.get(), InsertResult1.first->first); + EXPECT_EQ(3, InsertResult1.first->second); + EXPECT_TRUE(InsertResult1.second); + EXPECT_EQ(true, VM.count(this->AddV.get())); + std::pair<typename ValueMap<TypeParam*, int>::iterator, bool> InsertResult2 = + VM.insert(std::make_pair(this->AddV.get(), 5)); + EXPECT_EQ(this->AddV.get(), InsertResult2.first->first); + EXPECT_EQ(3, InsertResult2.first->second); + EXPECT_FALSE(InsertResult2.second); + + // Erase: + VM.erase(InsertResult2.first); + EXPECT_EQ(false, VM.count(this->AddV.get())); + EXPECT_EQ(true, VM.count(this->BitcastV.get())); + VM.erase(this->BitcastV.get()); + EXPECT_EQ(false, VM.count(this->BitcastV.get())); + EXPECT_EQ(0U, VM.size()); + + // Range insert: + SmallVector<std::pair<Instruction*, int>, 2> Elems; + Elems.push_back(std::make_pair(this->AddV.get(), 1)); + Elems.push_back(std::make_pair(this->BitcastV.get(), 2)); + VM.insert(Elems.begin(), Elems.end()); + EXPECT_EQ(1, VM.lookup(this->AddV.get())); + EXPECT_EQ(2, VM.lookup(this->BitcastV.get())); +} + +template<typename ExpectedType, typename VarType> +void CompileAssertHasType(VarType) { + typedef char assert[is_same<ExpectedType, VarType>::value ? 1 : -1]; +} + +TYPED_TEST(ValueMapTest, Iteration) { + ValueMap<TypeParam*, int> VM; + VM[this->BitcastV.get()] = 2; + VM[this->AddV.get()] = 3; + size_t size = 0; + for (typename ValueMap<TypeParam*, int>::iterator I = VM.begin(), E = VM.end(); + I != E; ++I) { + ++size; + std::pair<TypeParam*, int> value = *I; (void)value; + CompileAssertHasType<TypeParam*>(I->first); + if (I->second == 2) { + EXPECT_EQ(this->BitcastV.get(), I->first); + I->second = 5; + } else if (I->second == 3) { + EXPECT_EQ(this->AddV.get(), I->first); + I->second = 6; + } else { + ADD_FAILURE() << "Iterated through an extra value."; + } + } + EXPECT_EQ(2U, size); + EXPECT_EQ(5, VM[this->BitcastV.get()]); + EXPECT_EQ(6, VM[this->AddV.get()]); + + size = 0; + // Cast to const ValueMap to avoid a bug in DenseMap's iterators. + const ValueMap<TypeParam*, int>& CVM = VM; + for (typename ValueMap<TypeParam*, int>::const_iterator I = CVM.begin(), + E = CVM.end(); I != E; ++I) { + ++size; + std::pair<TypeParam*, int> value = *I; (void)value; + CompileAssertHasType<TypeParam*>(I->first); + if (I->second == 5) { + EXPECT_EQ(this->BitcastV.get(), I->first); + } else if (I->second == 6) { + EXPECT_EQ(this->AddV.get(), I->first); + } else { + ADD_FAILURE() << "Iterated through an extra value."; + } + } + EXPECT_EQ(2U, size); +} + +TYPED_TEST(ValueMapTest, DefaultCollisionBehavior) { + // By default, we overwrite the old value with the replaced value. + ValueMap<TypeParam*, int> VM; + VM[this->BitcastV.get()] = 7; + VM[this->AddV.get()] = 9; + this->BitcastV->replaceAllUsesWith(this->AddV.get()); + EXPECT_EQ(0, VM.count(this->BitcastV.get())); + EXPECT_EQ(9, VM.lookup(this->AddV.get())); +} + +TYPED_TEST(ValueMapTest, ConfiguredCollisionBehavior) { + // TODO: Implement this when someone needs it. +} + +template<typename KeyT> +struct LockMutex : ValueMapConfig<KeyT> { + struct ExtraData { + sys::Mutex *M; + bool *CalledRAUW; + bool *CalledDeleted; + }; + static void onRAUW(const ExtraData &Data, KeyT Old, KeyT New) { + *Data.CalledRAUW = true; + EXPECT_FALSE(Data.M->tryacquire()) << "Mutex should already be locked."; + } + static void onDelete(const ExtraData &Data, KeyT Old) { + *Data.CalledDeleted = true; + EXPECT_FALSE(Data.M->tryacquire()) << "Mutex should already be locked."; + } + static sys::Mutex *getMutex(const ExtraData &Data) { return Data.M; } +}; +#if ENABLE_THREADS +TYPED_TEST(ValueMapTest, LocksMutex) { + sys::Mutex M(false); // Not recursive. + bool CalledRAUW = false, CalledDeleted = false; + typename LockMutex<TypeParam*>::ExtraData Data = + {&M, &CalledRAUW, &CalledDeleted}; + ValueMap<TypeParam*, int, LockMutex<TypeParam*> > VM(Data); + VM[this->BitcastV.get()] = 7; + this->BitcastV->replaceAllUsesWith(this->AddV.get()); + this->AddV.reset(); + EXPECT_TRUE(CalledRAUW); + EXPECT_TRUE(CalledDeleted); +} +#endif + +template<typename KeyT> +struct NoFollow : ValueMapConfig<KeyT> { + enum { FollowRAUW = false }; +}; + +TYPED_TEST(ValueMapTest, NoFollowRAUW) { + ValueMap<TypeParam*, int, NoFollow<TypeParam*> > VM; + VM[this->BitcastV.get()] = 7; + EXPECT_EQ(7, VM.lookup(this->BitcastV.get())); + EXPECT_EQ(0, VM.count(this->AddV.get())); + this->BitcastV->replaceAllUsesWith(this->AddV.get()); + EXPECT_EQ(7, VM.lookup(this->BitcastV.get())); + EXPECT_EQ(0, VM.lookup(this->AddV.get())); + this->AddV.reset(); + EXPECT_EQ(7, VM.lookup(this->BitcastV.get())); + EXPECT_EQ(0, VM.lookup(this->AddV.get())); + this->BitcastV.reset(); + EXPECT_EQ(0, VM.lookup(this->BitcastV.get())); + EXPECT_EQ(0, VM.lookup(this->AddV.get())); + EXPECT_EQ(0U, VM.size()); +} + +template<typename KeyT> +struct CountOps : ValueMapConfig<KeyT> { + struct ExtraData { + int *Deletions; + int *RAUWs; + }; + + static void onRAUW(const ExtraData &Data, KeyT Old, KeyT New) { + ++*Data.RAUWs; + } + static void onDelete(const ExtraData &Data, KeyT Old) { + ++*Data.Deletions; + } +}; + +TYPED_TEST(ValueMapTest, CallsConfig) { + int Deletions = 0, RAUWs = 0; + typename CountOps<TypeParam*>::ExtraData Data = {&Deletions, &RAUWs}; + ValueMap<TypeParam*, int, CountOps<TypeParam*> > VM(Data); + VM[this->BitcastV.get()] = 7; + this->BitcastV->replaceAllUsesWith(this->AddV.get()); + EXPECT_EQ(0, Deletions); + EXPECT_EQ(1, RAUWs); + this->AddV.reset(); + EXPECT_EQ(1, Deletions); + EXPECT_EQ(1, RAUWs); + this->BitcastV.reset(); + EXPECT_EQ(1, Deletions); + EXPECT_EQ(1, RAUWs); +} + +template<typename KeyT> +struct ModifyingConfig : ValueMapConfig<KeyT> { + // We'll put a pointer here back to the ValueMap this key is in, so + // that we can modify it (and clobber *this) before the ValueMap + // tries to do the same modification. In previous versions of + // ValueMap, that exploded. + typedef ValueMap<KeyT, int, ModifyingConfig<KeyT> > **ExtraData; + + static void onRAUW(ExtraData Map, KeyT Old, KeyT New) { + (*Map)->erase(Old); + } + static void onDelete(ExtraData Map, KeyT Old) { + (*Map)->erase(Old); + } +}; +TYPED_TEST(ValueMapTest, SurvivesModificationByConfig) { + ValueMap<TypeParam*, int, ModifyingConfig<TypeParam*> > *MapAddress; + ValueMap<TypeParam*, int, ModifyingConfig<TypeParam*> > VM(&MapAddress); + MapAddress = &VM; + // Now the ModifyingConfig can modify the Map inside a callback. + VM[this->BitcastV.get()] = 7; + this->BitcastV->replaceAllUsesWith(this->AddV.get()); + EXPECT_FALSE(VM.count(this->BitcastV.get())); + EXPECT_FALSE(VM.count(this->AddV.get())); + VM[this->AddV.get()] = 7; + this->AddV.reset(); + EXPECT_FALSE(VM.count(this->AddV.get())); +} + +} diff --git a/contrib/llvm/unittests/ADT/ilistTest.cpp b/contrib/llvm/unittests/ADT/ilistTest.cpp new file mode 100644 index 0000000..09a699a --- /dev/null +++ b/contrib/llvm/unittests/ADT/ilistTest.cpp @@ -0,0 +1,44 @@ +//===- llvm/unittest/ADT/APInt.cpp - APInt unit tests ---------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include <ostream> +#include "gtest/gtest.h" +#include "llvm/ADT/ilist.h" +#include "llvm/ADT/ilist_node.h" + +using namespace llvm; + +namespace { + +struct Node : ilist_node<Node> { + int Value; + + Node() {} + Node(int _Value) : Value(_Value) {} +}; + +TEST(ilistTest, Basic) { + ilist<Node> List; + List.push_back(Node(1)); + EXPECT_EQ(1, List.back().Value); + EXPECT_EQ(0, List.back().getPrevNode()); + EXPECT_EQ(0, List.back().getNextNode()); + + List.push_back(Node(2)); + EXPECT_EQ(2, List.back().Value); + EXPECT_EQ(2, List.front().getNextNode()->Value); + EXPECT_EQ(1, List.back().getPrevNode()->Value); + + const ilist<Node> &ConstList = List; + EXPECT_EQ(2, ConstList.back().Value); + EXPECT_EQ(2, ConstList.front().getNextNode()->Value); + EXPECT_EQ(1, ConstList.back().getPrevNode()->Value); +} + +} |
