diff options
Diffstat (limited to 'unittests/Support')
| -rw-r--r-- | unittests/Support/AlignOfTest.cpp | 234 | ||||
| -rw-r--r-- | unittests/Support/CMakeLists.txt | 1 | ||||
| -rw-r--r-- | unittests/Support/Casting.cpp | 8 | ||||
| -rw-r--r-- | unittests/Support/CommandLineTest.cpp | 11 | ||||
| -rw-r--r-- | unittests/Support/DataExtractorTest.cpp | 9 | ||||
| -rw-r--r-- | unittests/Support/FileOutputBufferTest.cpp | 137 | ||||
| -rw-r--r-- | unittests/Support/Path.cpp | 59 | ||||
| -rw-r--r-- | unittests/Support/YAMLParserTest.cpp | 6 |
8 files changed, 319 insertions, 146 deletions
diff --git a/unittests/Support/AlignOfTest.cpp b/unittests/Support/AlignOfTest.cpp index c45db2c..6f57668 100644 --- a/unittests/Support/AlignOfTest.cpp +++ b/unittests/Support/AlignOfTest.cpp @@ -178,150 +178,150 @@ TEST(AlignOfTest, BasicAlignedArray) { // types because of the bugs mentioned above where GCC and Clang both // disregard the arbitrary alignment specifier until the type is used to // declare a member of a struct. - EXPECT_LE(1u, alignOf<AlignedCharArray<SA1>::union_type>()); - EXPECT_LE(2u, alignOf<AlignedCharArray<SA2>::union_type>()); - EXPECT_LE(4u, alignOf<AlignedCharArray<SA4>::union_type>()); - EXPECT_LE(8u, alignOf<AlignedCharArray<SA8>::union_type>()); + EXPECT_LE(1u, alignOf<AlignedCharArrayUnion<SA1> >()); + EXPECT_LE(2u, alignOf<AlignedCharArrayUnion<SA2> >()); + EXPECT_LE(4u, alignOf<AlignedCharArrayUnion<SA4> >()); + EXPECT_LE(8u, alignOf<AlignedCharArrayUnion<SA8> >()); - EXPECT_LE(1u, sizeof(AlignedCharArray<SA1>::union_type)); - EXPECT_LE(2u, sizeof(AlignedCharArray<SA2>::union_type)); - EXPECT_LE(4u, sizeof(AlignedCharArray<SA4>::union_type)); - EXPECT_LE(8u, sizeof(AlignedCharArray<SA8>::union_type)); + EXPECT_LE(1u, sizeof(AlignedCharArrayUnion<SA1>)); + EXPECT_LE(2u, sizeof(AlignedCharArrayUnion<SA2>)); + EXPECT_LE(4u, sizeof(AlignedCharArrayUnion<SA4>)); + EXPECT_LE(8u, sizeof(AlignedCharArrayUnion<SA8>)); - EXPECT_EQ(1u, (alignOf<AlignedCharArray<SA1>::union_type>())); - EXPECT_EQ(2u, (alignOf<AlignedCharArray<SA1, SA2>::union_type>())); - EXPECT_EQ(4u, (alignOf<AlignedCharArray<SA1, SA2, SA4>::union_type>())); - EXPECT_EQ(8u, (alignOf<AlignedCharArray<SA1, SA2, SA4, SA8>::union_type>())); + EXPECT_EQ(1u, (alignOf<AlignedCharArrayUnion<SA1> >())); + EXPECT_EQ(2u, (alignOf<AlignedCharArrayUnion<SA1, SA2> >())); + EXPECT_EQ(4u, (alignOf<AlignedCharArrayUnion<SA1, SA2, SA4> >())); + EXPECT_EQ(8u, (alignOf<AlignedCharArrayUnion<SA1, SA2, SA4, SA8> >())); - EXPECT_EQ(1u, sizeof(AlignedCharArray<SA1>::union_type)); - EXPECT_EQ(2u, sizeof(AlignedCharArray<SA1, SA2>::union_type)); - EXPECT_EQ(4u, sizeof(AlignedCharArray<SA1, SA2, SA4>::union_type)); - EXPECT_EQ(8u, sizeof(AlignedCharArray<SA1, SA2, SA4, SA8>::union_type)); + EXPECT_EQ(1u, sizeof(AlignedCharArrayUnion<SA1>)); + EXPECT_EQ(2u, sizeof(AlignedCharArrayUnion<SA1, SA2>)); + EXPECT_EQ(4u, sizeof(AlignedCharArrayUnion<SA1, SA2, SA4>)); + EXPECT_EQ(8u, sizeof(AlignedCharArrayUnion<SA1, SA2, SA4, SA8>)); - EXPECT_EQ(1u, (alignOf<AlignedCharArray<SA1[1]>::union_type>())); - EXPECT_EQ(2u, (alignOf<AlignedCharArray<SA1[2], SA2[1]>::union_type>())); - EXPECT_EQ(4u, (alignOf<AlignedCharArray<SA1[42], SA2[55], - SA4[13]>::union_type>())); - EXPECT_EQ(8u, (alignOf<AlignedCharArray<SA1[2], SA2[1], - SA4, SA8>::union_type>())); + EXPECT_EQ(1u, (alignOf<AlignedCharArrayUnion<SA1[1]> >())); + EXPECT_EQ(2u, (alignOf<AlignedCharArrayUnion<SA1[2], SA2[1]> >())); + EXPECT_EQ(4u, (alignOf<AlignedCharArrayUnion<SA1[42], SA2[55], + SA4[13]> >())); + EXPECT_EQ(8u, (alignOf<AlignedCharArrayUnion<SA1[2], SA2[1], + SA4, SA8> >())); - EXPECT_EQ(1u, sizeof(AlignedCharArray<SA1[1]>::union_type)); - EXPECT_EQ(2u, sizeof(AlignedCharArray<SA1[2], SA2[1]>::union_type)); - EXPECT_EQ(4u, sizeof(AlignedCharArray<SA1[3], SA2[2], SA4>::union_type)); - EXPECT_EQ(16u, sizeof(AlignedCharArray<SA1, SA2[3], - SA4[3], SA8>::union_type)); + EXPECT_EQ(1u, sizeof(AlignedCharArrayUnion<SA1[1]>)); + EXPECT_EQ(2u, sizeof(AlignedCharArrayUnion<SA1[2], SA2[1]>)); + EXPECT_EQ(4u, sizeof(AlignedCharArrayUnion<SA1[3], SA2[2], SA4>)); + EXPECT_EQ(16u, sizeof(AlignedCharArrayUnion<SA1, SA2[3], + SA4[3], SA8>)); // For other tests we simply assert that the alignment of the union mathes // that of the fundamental type and hope that we have any weird type // productions that would trigger bugs. - EXPECT_EQ(alignOf<char>(), alignOf<AlignedCharArray<char>::union_type>()); - EXPECT_EQ(alignOf<short>(), alignOf<AlignedCharArray<short>::union_type>()); - EXPECT_EQ(alignOf<int>(), alignOf<AlignedCharArray<int>::union_type>()); - EXPECT_EQ(alignOf<long>(), alignOf<AlignedCharArray<long>::union_type>()); + EXPECT_EQ(alignOf<char>(), alignOf<AlignedCharArrayUnion<char> >()); + EXPECT_EQ(alignOf<short>(), alignOf<AlignedCharArrayUnion<short> >()); + EXPECT_EQ(alignOf<int>(), alignOf<AlignedCharArrayUnion<int> >()); + EXPECT_EQ(alignOf<long>(), alignOf<AlignedCharArrayUnion<long> >()); EXPECT_EQ(alignOf<long long>(), - alignOf<AlignedCharArray<long long>::union_type>()); - EXPECT_EQ(alignOf<float>(), alignOf<AlignedCharArray<float>::union_type>()); - EXPECT_EQ(alignOf<double>(), alignOf<AlignedCharArray<double>::union_type>()); + alignOf<AlignedCharArrayUnion<long long> >()); + EXPECT_EQ(alignOf<float>(), alignOf<AlignedCharArrayUnion<float> >()); + EXPECT_EQ(alignOf<double>(), alignOf<AlignedCharArrayUnion<double> >()); EXPECT_EQ(alignOf<long double>(), - alignOf<AlignedCharArray<long double>::union_type>()); - EXPECT_EQ(alignOf<void *>(), alignOf<AlignedCharArray<void *>::union_type>()); - EXPECT_EQ(alignOf<int *>(), alignOf<AlignedCharArray<int *>::union_type>()); + alignOf<AlignedCharArrayUnion<long double> >()); + EXPECT_EQ(alignOf<void *>(), alignOf<AlignedCharArrayUnion<void *> >()); + EXPECT_EQ(alignOf<int *>(), alignOf<AlignedCharArrayUnion<int *> >()); EXPECT_EQ(alignOf<double (*)(double)>(), - alignOf<AlignedCharArray<double (*)(double)>::union_type>()); + alignOf<AlignedCharArrayUnion<double (*)(double)> >()); EXPECT_EQ(alignOf<double (S6::*)()>(), - alignOf<AlignedCharArray<double (S6::*)()>::union_type>()); - EXPECT_EQ(alignOf<S1>(), alignOf<AlignedCharArray<S1>::union_type>()); - EXPECT_EQ(alignOf<S2>(), alignOf<AlignedCharArray<S2>::union_type>()); - EXPECT_EQ(alignOf<S3>(), alignOf<AlignedCharArray<S3>::union_type>()); - EXPECT_EQ(alignOf<S4>(), alignOf<AlignedCharArray<S4>::union_type>()); - EXPECT_EQ(alignOf<S5>(), alignOf<AlignedCharArray<S5>::union_type>()); - EXPECT_EQ(alignOf<S6>(), alignOf<AlignedCharArray<S6>::union_type>()); - EXPECT_EQ(alignOf<D1>(), alignOf<AlignedCharArray<D1>::union_type>()); - EXPECT_EQ(alignOf<D2>(), alignOf<AlignedCharArray<D2>::union_type>()); - EXPECT_EQ(alignOf<D3>(), alignOf<AlignedCharArray<D3>::union_type>()); - EXPECT_EQ(alignOf<D4>(), alignOf<AlignedCharArray<D4>::union_type>()); - EXPECT_EQ(alignOf<D5>(), alignOf<AlignedCharArray<D5>::union_type>()); - EXPECT_EQ(alignOf<D6>(), alignOf<AlignedCharArray<D6>::union_type>()); - EXPECT_EQ(alignOf<D7>(), alignOf<AlignedCharArray<D7>::union_type>()); - EXPECT_EQ(alignOf<D8>(), alignOf<AlignedCharArray<D8>::union_type>()); - EXPECT_EQ(alignOf<D9>(), alignOf<AlignedCharArray<D9>::union_type>()); - EXPECT_EQ(alignOf<V1>(), alignOf<AlignedCharArray<V1>::union_type>()); - EXPECT_EQ(alignOf<V2>(), alignOf<AlignedCharArray<V2>::union_type>()); - EXPECT_EQ(alignOf<V3>(), alignOf<AlignedCharArray<V3>::union_type>()); - EXPECT_EQ(alignOf<V4>(), alignOf<AlignedCharArray<V4>::union_type>()); - EXPECT_EQ(alignOf<V5>(), alignOf<AlignedCharArray<V5>::union_type>()); - EXPECT_EQ(alignOf<V6>(), alignOf<AlignedCharArray<V6>::union_type>()); - EXPECT_EQ(alignOf<V7>(), alignOf<AlignedCharArray<V7>::union_type>()); + alignOf<AlignedCharArrayUnion<double (S6::*)()> >()); + EXPECT_EQ(alignOf<S1>(), alignOf<AlignedCharArrayUnion<S1> >()); + EXPECT_EQ(alignOf<S2>(), alignOf<AlignedCharArrayUnion<S2> >()); + EXPECT_EQ(alignOf<S3>(), alignOf<AlignedCharArrayUnion<S3> >()); + EXPECT_EQ(alignOf<S4>(), alignOf<AlignedCharArrayUnion<S4> >()); + EXPECT_EQ(alignOf<S5>(), alignOf<AlignedCharArrayUnion<S5> >()); + EXPECT_EQ(alignOf<S6>(), alignOf<AlignedCharArrayUnion<S6> >()); + EXPECT_EQ(alignOf<D1>(), alignOf<AlignedCharArrayUnion<D1> >()); + EXPECT_EQ(alignOf<D2>(), alignOf<AlignedCharArrayUnion<D2> >()); + EXPECT_EQ(alignOf<D3>(), alignOf<AlignedCharArrayUnion<D3> >()); + EXPECT_EQ(alignOf<D4>(), alignOf<AlignedCharArrayUnion<D4> >()); + EXPECT_EQ(alignOf<D5>(), alignOf<AlignedCharArrayUnion<D5> >()); + EXPECT_EQ(alignOf<D6>(), alignOf<AlignedCharArrayUnion<D6> >()); + EXPECT_EQ(alignOf<D7>(), alignOf<AlignedCharArrayUnion<D7> >()); + EXPECT_EQ(alignOf<D8>(), alignOf<AlignedCharArrayUnion<D8> >()); + EXPECT_EQ(alignOf<D9>(), alignOf<AlignedCharArrayUnion<D9> >()); + EXPECT_EQ(alignOf<V1>(), alignOf<AlignedCharArrayUnion<V1> >()); + EXPECT_EQ(alignOf<V2>(), alignOf<AlignedCharArrayUnion<V2> >()); + EXPECT_EQ(alignOf<V3>(), alignOf<AlignedCharArrayUnion<V3> >()); + EXPECT_EQ(alignOf<V4>(), alignOf<AlignedCharArrayUnion<V4> >()); + EXPECT_EQ(alignOf<V5>(), alignOf<AlignedCharArrayUnion<V5> >()); + EXPECT_EQ(alignOf<V6>(), alignOf<AlignedCharArrayUnion<V6> >()); + EXPECT_EQ(alignOf<V7>(), alignOf<AlignedCharArrayUnion<V7> >()); // Some versions of MSVC get this wrong somewhat disturbingly. The failure // appears to be benign: alignOf<V8>() produces a preposterous value: 12 #ifndef _MSC_VER - EXPECT_EQ(alignOf<V8>(), alignOf<AlignedCharArray<V8>::union_type>()); + EXPECT_EQ(alignOf<V8>(), alignOf<AlignedCharArrayUnion<V8> >()); #endif - EXPECT_EQ(sizeof(char), sizeof(AlignedCharArray<char>::union_type)); - EXPECT_EQ(sizeof(char[1]), sizeof(AlignedCharArray<char[1]>::union_type)); - EXPECT_EQ(sizeof(char[2]), sizeof(AlignedCharArray<char[2]>::union_type)); - EXPECT_EQ(sizeof(char[3]), sizeof(AlignedCharArray<char[3]>::union_type)); - EXPECT_EQ(sizeof(char[4]), sizeof(AlignedCharArray<char[4]>::union_type)); - EXPECT_EQ(sizeof(char[5]), sizeof(AlignedCharArray<char[5]>::union_type)); - EXPECT_EQ(sizeof(char[8]), sizeof(AlignedCharArray<char[8]>::union_type)); - EXPECT_EQ(sizeof(char[13]), sizeof(AlignedCharArray<char[13]>::union_type)); - EXPECT_EQ(sizeof(char[16]), sizeof(AlignedCharArray<char[16]>::union_type)); - EXPECT_EQ(sizeof(char[21]), sizeof(AlignedCharArray<char[21]>::union_type)); - EXPECT_EQ(sizeof(char[32]), sizeof(AlignedCharArray<char[32]>::union_type)); - EXPECT_EQ(sizeof(short), sizeof(AlignedCharArray<short>::union_type)); - EXPECT_EQ(sizeof(int), sizeof(AlignedCharArray<int>::union_type)); - EXPECT_EQ(sizeof(long), sizeof(AlignedCharArray<long>::union_type)); + EXPECT_EQ(sizeof(char), sizeof(AlignedCharArrayUnion<char>)); + EXPECT_EQ(sizeof(char[1]), sizeof(AlignedCharArrayUnion<char[1]>)); + EXPECT_EQ(sizeof(char[2]), sizeof(AlignedCharArrayUnion<char[2]>)); + EXPECT_EQ(sizeof(char[3]), sizeof(AlignedCharArrayUnion<char[3]>)); + EXPECT_EQ(sizeof(char[4]), sizeof(AlignedCharArrayUnion<char[4]>)); + EXPECT_EQ(sizeof(char[5]), sizeof(AlignedCharArrayUnion<char[5]>)); + EXPECT_EQ(sizeof(char[8]), sizeof(AlignedCharArrayUnion<char[8]>)); + EXPECT_EQ(sizeof(char[13]), sizeof(AlignedCharArrayUnion<char[13]>)); + EXPECT_EQ(sizeof(char[16]), sizeof(AlignedCharArrayUnion<char[16]>)); + EXPECT_EQ(sizeof(char[21]), sizeof(AlignedCharArrayUnion<char[21]>)); + EXPECT_EQ(sizeof(char[32]), sizeof(AlignedCharArrayUnion<char[32]>)); + EXPECT_EQ(sizeof(short), sizeof(AlignedCharArrayUnion<short>)); + EXPECT_EQ(sizeof(int), sizeof(AlignedCharArrayUnion<int>)); + EXPECT_EQ(sizeof(long), sizeof(AlignedCharArrayUnion<long>)); EXPECT_EQ(sizeof(long long), - sizeof(AlignedCharArray<long long>::union_type)); - EXPECT_EQ(sizeof(float), sizeof(AlignedCharArray<float>::union_type)); - EXPECT_EQ(sizeof(double), sizeof(AlignedCharArray<double>::union_type)); + sizeof(AlignedCharArrayUnion<long long>)); + EXPECT_EQ(sizeof(float), sizeof(AlignedCharArrayUnion<float>)); + EXPECT_EQ(sizeof(double), sizeof(AlignedCharArrayUnion<double>)); EXPECT_EQ(sizeof(long double), - sizeof(AlignedCharArray<long double>::union_type)); - EXPECT_EQ(sizeof(void *), sizeof(AlignedCharArray<void *>::union_type)); - EXPECT_EQ(sizeof(int *), sizeof(AlignedCharArray<int *>::union_type)); + sizeof(AlignedCharArrayUnion<long double>)); + EXPECT_EQ(sizeof(void *), sizeof(AlignedCharArrayUnion<void *>)); + EXPECT_EQ(sizeof(int *), sizeof(AlignedCharArrayUnion<int *>)); EXPECT_EQ(sizeof(double (*)(double)), - sizeof(AlignedCharArray<double (*)(double)>::union_type)); + sizeof(AlignedCharArrayUnion<double (*)(double)>)); EXPECT_EQ(sizeof(double (S6::*)()), - sizeof(AlignedCharArray<double (S6::*)()>::union_type)); - EXPECT_EQ(sizeof(S1), sizeof(AlignedCharArray<S1>::union_type)); - EXPECT_EQ(sizeof(S2), sizeof(AlignedCharArray<S2>::union_type)); - EXPECT_EQ(sizeof(S3), sizeof(AlignedCharArray<S3>::union_type)); - EXPECT_EQ(sizeof(S4), sizeof(AlignedCharArray<S4>::union_type)); - EXPECT_EQ(sizeof(S5), sizeof(AlignedCharArray<S5>::union_type)); - EXPECT_EQ(sizeof(S6), sizeof(AlignedCharArray<S6>::union_type)); - EXPECT_EQ(sizeof(D1), sizeof(AlignedCharArray<D1>::union_type)); - EXPECT_EQ(sizeof(D2), sizeof(AlignedCharArray<D2>::union_type)); - EXPECT_EQ(sizeof(D3), sizeof(AlignedCharArray<D3>::union_type)); - EXPECT_EQ(sizeof(D4), sizeof(AlignedCharArray<D4>::union_type)); - EXPECT_EQ(sizeof(D5), sizeof(AlignedCharArray<D5>::union_type)); - EXPECT_EQ(sizeof(D6), sizeof(AlignedCharArray<D6>::union_type)); - EXPECT_EQ(sizeof(D7), sizeof(AlignedCharArray<D7>::union_type)); - EXPECT_EQ(sizeof(D8), sizeof(AlignedCharArray<D8>::union_type)); - EXPECT_EQ(sizeof(D9), sizeof(AlignedCharArray<D9>::union_type)); - EXPECT_EQ(sizeof(D9[1]), sizeof(AlignedCharArray<D9[1]>::union_type)); - EXPECT_EQ(sizeof(D9[2]), sizeof(AlignedCharArray<D9[2]>::union_type)); - EXPECT_EQ(sizeof(D9[3]), sizeof(AlignedCharArray<D9[3]>::union_type)); - EXPECT_EQ(sizeof(D9[4]), sizeof(AlignedCharArray<D9[4]>::union_type)); - EXPECT_EQ(sizeof(D9[5]), sizeof(AlignedCharArray<D9[5]>::union_type)); - EXPECT_EQ(sizeof(D9[8]), sizeof(AlignedCharArray<D9[8]>::union_type)); - EXPECT_EQ(sizeof(D9[13]), sizeof(AlignedCharArray<D9[13]>::union_type)); - EXPECT_EQ(sizeof(D9[16]), sizeof(AlignedCharArray<D9[16]>::union_type)); - EXPECT_EQ(sizeof(D9[21]), sizeof(AlignedCharArray<D9[21]>::union_type)); - EXPECT_EQ(sizeof(D9[32]), sizeof(AlignedCharArray<D9[32]>::union_type)); - EXPECT_EQ(sizeof(V1), sizeof(AlignedCharArray<V1>::union_type)); - EXPECT_EQ(sizeof(V2), sizeof(AlignedCharArray<V2>::union_type)); - EXPECT_EQ(sizeof(V3), sizeof(AlignedCharArray<V3>::union_type)); - EXPECT_EQ(sizeof(V4), sizeof(AlignedCharArray<V4>::union_type)); - EXPECT_EQ(sizeof(V5), sizeof(AlignedCharArray<V5>::union_type)); - EXPECT_EQ(sizeof(V6), sizeof(AlignedCharArray<V6>::union_type)); - EXPECT_EQ(sizeof(V7), sizeof(AlignedCharArray<V7>::union_type)); + sizeof(AlignedCharArrayUnion<double (S6::*)()>)); + EXPECT_EQ(sizeof(S1), sizeof(AlignedCharArrayUnion<S1>)); + EXPECT_EQ(sizeof(S2), sizeof(AlignedCharArrayUnion<S2>)); + EXPECT_EQ(sizeof(S3), sizeof(AlignedCharArrayUnion<S3>)); + EXPECT_EQ(sizeof(S4), sizeof(AlignedCharArrayUnion<S4>)); + EXPECT_EQ(sizeof(S5), sizeof(AlignedCharArrayUnion<S5>)); + EXPECT_EQ(sizeof(S6), sizeof(AlignedCharArrayUnion<S6>)); + EXPECT_EQ(sizeof(D1), sizeof(AlignedCharArrayUnion<D1>)); + EXPECT_EQ(sizeof(D2), sizeof(AlignedCharArrayUnion<D2>)); + EXPECT_EQ(sizeof(D3), sizeof(AlignedCharArrayUnion<D3>)); + EXPECT_EQ(sizeof(D4), sizeof(AlignedCharArrayUnion<D4>)); + EXPECT_EQ(sizeof(D5), sizeof(AlignedCharArrayUnion<D5>)); + EXPECT_EQ(sizeof(D6), sizeof(AlignedCharArrayUnion<D6>)); + EXPECT_EQ(sizeof(D7), sizeof(AlignedCharArrayUnion<D7>)); + EXPECT_EQ(sizeof(D8), sizeof(AlignedCharArrayUnion<D8>)); + EXPECT_EQ(sizeof(D9), sizeof(AlignedCharArrayUnion<D9>)); + EXPECT_EQ(sizeof(D9[1]), sizeof(AlignedCharArrayUnion<D9[1]>)); + EXPECT_EQ(sizeof(D9[2]), sizeof(AlignedCharArrayUnion<D9[2]>)); + EXPECT_EQ(sizeof(D9[3]), sizeof(AlignedCharArrayUnion<D9[3]>)); + EXPECT_EQ(sizeof(D9[4]), sizeof(AlignedCharArrayUnion<D9[4]>)); + EXPECT_EQ(sizeof(D9[5]), sizeof(AlignedCharArrayUnion<D9[5]>)); + EXPECT_EQ(sizeof(D9[8]), sizeof(AlignedCharArrayUnion<D9[8]>)); + EXPECT_EQ(sizeof(D9[13]), sizeof(AlignedCharArrayUnion<D9[13]>)); + EXPECT_EQ(sizeof(D9[16]), sizeof(AlignedCharArrayUnion<D9[16]>)); + EXPECT_EQ(sizeof(D9[21]), sizeof(AlignedCharArrayUnion<D9[21]>)); + EXPECT_EQ(sizeof(D9[32]), sizeof(AlignedCharArrayUnion<D9[32]>)); + EXPECT_EQ(sizeof(V1), sizeof(AlignedCharArrayUnion<V1>)); + EXPECT_EQ(sizeof(V2), sizeof(AlignedCharArrayUnion<V2>)); + EXPECT_EQ(sizeof(V3), sizeof(AlignedCharArrayUnion<V3>)); + EXPECT_EQ(sizeof(V4), sizeof(AlignedCharArrayUnion<V4>)); + EXPECT_EQ(sizeof(V5), sizeof(AlignedCharArrayUnion<V5>)); + EXPECT_EQ(sizeof(V6), sizeof(AlignedCharArrayUnion<V6>)); + EXPECT_EQ(sizeof(V7), sizeof(AlignedCharArrayUnion<V7>)); // Some versions of MSVC also get this wrong. The failure again appears to be // benign: sizeof(V8) is only 52 bytes, but our array reserves 56. #ifndef _MSC_VER - EXPECT_EQ(sizeof(V8), sizeof(AlignedCharArray<V8>::union_type)); + EXPECT_EQ(sizeof(V8), sizeof(AlignedCharArrayUnion<V8>)); #endif } diff --git a/unittests/Support/CMakeLists.txt b/unittests/Support/CMakeLists.txt index 8859678..3b9bf84 100644 --- a/unittests/Support/CMakeLists.txt +++ b/unittests/Support/CMakeLists.txt @@ -12,6 +12,7 @@ add_llvm_unittest(SupportTests ConstantRangeTest.cpp DataExtractorTest.cpp EndianTest.cpp + FileOutputBufferTest.cpp IntegersSubsetTest.cpp LeakDetectorTest.cpp ManagedStatic.cpp diff --git a/unittests/Support/Casting.cpp b/unittests/Support/Casting.cpp index ca0b40b..dc0205f 100644 --- a/unittests/Support/Casting.cpp +++ b/unittests/Support/Casting.cpp @@ -95,8 +95,9 @@ TEST(CastingTest, cast) { EXPECT_NE(&F5, null_foo); const foo *F6 = cast<foo>(B4); EXPECT_NE(F6, null_foo); - foo *F7 = cast<foo>(fub()); - EXPECT_EQ(F7, null_foo); + // Can't pass null pointer to cast<>. + // foo *F7 = cast<foo>(fub()); + // EXPECT_EQ(F7, null_foo); foo *F8 = B1.baz(); EXPECT_NE(F8, null_foo); } @@ -121,7 +122,8 @@ TEST(CastingTest, dyn_cast) { EXPECT_NE(F2, null_foo); const foo *F3 = dyn_cast<foo>(B4); EXPECT_NE(F3, null_foo); - // foo *F4 = dyn_cast<foo>(fub()); // not permittible + // Can't pass null pointer to dyn_cast<>. + // foo *F4 = dyn_cast<foo>(fub()); // EXPECT_EQ(F4, null_foo); foo *F5 = B1.daz(); EXPECT_NE(F5, null_foo); diff --git a/unittests/Support/CommandLineTest.cpp b/unittests/Support/CommandLineTest.cpp index 72fa24a..13e9038 100644 --- a/unittests/Support/CommandLineTest.cpp +++ b/unittests/Support/CommandLineTest.cpp @@ -55,6 +55,17 @@ TEST(CommandLineTest, ParseEnvironment) { EXPECT_EQ("hello", EnvironmentTestOption); } +// This test used to make valgrind complain +// ("Conditional jump or move depends on uninitialised value(s)") +TEST(CommandLineTest, ParseEnvironmentToLocalVar) { + // Put cl::opt on stack to check for proper initialization of fields. + cl::opt<std::string> EnvironmentTestOptionLocal("env-test-opt-local"); + TempEnvVar TEV(test_env_var, "-env-test-opt-local=hello-local"); + EXPECT_EQ("", EnvironmentTestOptionLocal); + cl::ParseEnvironmentOptions("CommandLineTest", test_env_var); + EXPECT_EQ("hello-local", EnvironmentTestOptionLocal); +} + #endif // SKIP_ENVIRONMENT_TESTS } // anonymous namespace diff --git a/unittests/Support/DataExtractorTest.cpp b/unittests/Support/DataExtractorTest.cpp index 9813e46..ec8bd3d 100644 --- a/unittests/Support/DataExtractorTest.cpp +++ b/unittests/Support/DataExtractorTest.cpp @@ -16,6 +16,7 @@ namespace { const char numberData[] = "\x80\x90\xFF\xFF\x80\x00\x00\x00"; const char stringData[] = "hellohello\0hello"; const char leb128data[] = "\xA6\x49"; +const char bigleb128data[] = "\xAA\xA9\xFF\xAA\xFF\xAA\xFF\x4A"; TEST(DataExtractorTest, OffsetOverflow) { DataExtractor DE(StringRef(numberData, sizeof(numberData)-1), false, 8); @@ -106,6 +107,14 @@ TEST(DataExtractorTest, LEB128) { offset = 0; EXPECT_EQ(-7002LL, DE.getSLEB128(&offset)); EXPECT_EQ(2U, offset); + + DataExtractor BDE(StringRef(bigleb128data, sizeof(bigleb128data)-1), false,8); + offset = 0; + EXPECT_EQ(42218325750568106ULL, BDE.getULEB128(&offset)); + EXPECT_EQ(8U, offset); + offset = 0; + EXPECT_EQ(-29839268287359830LL, BDE.getSLEB128(&offset)); + EXPECT_EQ(8U, offset); } } diff --git a/unittests/Support/FileOutputBufferTest.cpp b/unittests/Support/FileOutputBufferTest.cpp new file mode 100644 index 0000000..edd350a --- /dev/null +++ b/unittests/Support/FileOutputBufferTest.cpp @@ -0,0 +1,137 @@ +//===- llvm/unittest/Support/FileOutputBuffer.cpp - unit 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/OwningPtr.h" +#include "llvm/Support/ErrorHandling.h" +#include "llvm/Support/FileOutputBuffer.h" +#include "llvm/Support/FileSystem.h" +#include "llvm/Support/PathV2.h" +#include "llvm/Support/raw_ostream.h" + +#include "gtest/gtest.h" + +using namespace llvm; +using namespace llvm::sys; + +#define ASSERT_NO_ERROR(x) \ + if (error_code ASSERT_NO_ERROR_ec = x) { \ + errs() << #x ": did not return errc::success.\n" \ + << "error number: " << ASSERT_NO_ERROR_ec.value() << "\n" \ + << "error message: " << ASSERT_NO_ERROR_ec.message() << "\n"; \ + } else {} + +namespace { + + +// NOTE: Temporarily run this test on unix only. Once the file mapping +// routines are ported to Windows, this conditional can be removed. +#if LLVM_ON_UNIX + + +TEST(FileOutputBuffer, Test) { + // Create unique temporary directory for these tests + SmallString<128> TestDirectory; + { + int fd; + ASSERT_NO_ERROR( + fs::unique_file("FileOutputBuffer-test-%%-%%-%%-%%/dir", fd, + TestDirectory)); + ::close(fd); + TestDirectory = path::parent_path(TestDirectory); + } + + // TEST 1: Verify commit case. + SmallString<128> File1(TestDirectory); + File1.append("/file1"); + { + OwningPtr<FileOutputBuffer> Buffer; + ASSERT_NO_ERROR(FileOutputBuffer::create(File1, 8192, Buffer)); + // Start buffer with special header. + memcpy(Buffer->getBufferStart(), "AABBCCDDEEFFGGHHIIJJ", 20); + // Write to end of buffer to verify it is writable. + memcpy(Buffer->getBufferEnd() - 20, "AABBCCDDEEFFGGHHIIJJ", 20); + // Commit buffer. + ASSERT_NO_ERROR(Buffer->commit()); + } + // Verify file exists and starts with special header. + bool MagicMatches = false; + ASSERT_NO_ERROR(fs::has_magic(Twine(File1), Twine("AABBCCDDEEFFGGHHIIJJ"), + MagicMatches)); + EXPECT_TRUE(MagicMatches); + // Verify file is correct size. + uint64_t File1Size; + ASSERT_NO_ERROR(fs::file_size(Twine(File1), File1Size)); + ASSERT_EQ(File1Size, 8192ULL); + + // TEST 2: Verify abort case. + SmallString<128> File2(TestDirectory); + File2.append("/file2"); + { + OwningPtr<FileOutputBuffer> Buffer2; + ASSERT_NO_ERROR(FileOutputBuffer::create(File2, 8192, Buffer2)); + // Fill buffer with special header. + memcpy(Buffer2->getBufferStart(), "AABBCCDDEEFFGGHHIIJJ", 20); + // Do *not* commit buffer. + } + // Verify file does not exist (because buffer not commited). + bool Exists = false; + ASSERT_NO_ERROR(fs::exists(Twine(File2), Exists)); + EXPECT_FALSE(Exists); + + + // TEST 3: Verify sizing down case. + SmallString<128> File3(TestDirectory); + File3.append("/file3"); + { + OwningPtr<FileOutputBuffer> Buffer; + ASSERT_NO_ERROR(FileOutputBuffer::create(File3, 8192000, Buffer)); + // Start buffer with special header. + memcpy(Buffer->getBufferStart(), "AABBCCDDEEFFGGHHIIJJ", 20); + // Write to end of buffer to verify it is writable. + memcpy(Buffer->getBufferEnd() - 20, "AABBCCDDEEFFGGHHIIJJ", 20); + // Commit buffer, but size down to smaller size + ASSERT_NO_ERROR(Buffer->commit(5000)); + } + // Verify file exists and starts with special header. + bool MagicMatches3 = false; + ASSERT_NO_ERROR(fs::has_magic(Twine(File3), Twine("AABBCCDDEEFFGGHHIIJJ"), + MagicMatches3)); + EXPECT_TRUE(MagicMatches3); + // Verify file is correct size. + uint64_t File3Size; + ASSERT_NO_ERROR(fs::file_size(Twine(File3), File3Size)); + ASSERT_EQ(File3Size, 5000ULL); + + + // TEST 4: Verify file can be made executable. + SmallString<128> File4(TestDirectory); + File4.append("/file4"); + { + OwningPtr<FileOutputBuffer> Buffer; + ASSERT_NO_ERROR(FileOutputBuffer::create(File4, 8192, Buffer, + FileOutputBuffer::F_executable)); + // Start buffer with special header. + memcpy(Buffer->getBufferStart(), "AABBCCDDEEFFGGHHIIJJ", 20); + // Commit buffer. + ASSERT_NO_ERROR(Buffer->commit()); + } + // Verify file exists and is executable. + fs::file_status Status; + ASSERT_NO_ERROR(fs::status(Twine(File4), Status)); + bool IsExecutable = (Status.permissions() & fs::owner_exe); + EXPECT_TRUE(IsExecutable); + + // Clean up. + uint32_t RemovedCount; + ASSERT_NO_ERROR(fs::remove_all(TestDirectory.str(), RemovedCount)); +} + +#endif // LLVM_ON_UNIX + +} // anonymous namespace diff --git a/unittests/Support/Path.cpp b/unittests/Support/Path.cpp index a071a5a..63c9ae0 100644 --- a/unittests/Support/Path.cpp +++ b/unittests/Support/Path.cpp @@ -340,44 +340,51 @@ TEST_F(FileSystemTest, Permissions) { } #endif -#if !defined(_WIN32) // FIXME: temporary suppressed. TEST_F(FileSystemTest, FileMapping) { // Create a temp file. int FileDescriptor; SmallString<64> TempPath; ASSERT_NO_ERROR( fs::unique_file("%%-%%-%%-%%.temp", FileDescriptor, TempPath)); - - // Grow temp file to be 4096 bytes - ASSERT_NO_ERROR(sys::fs::resize_file(Twine(TempPath), 4096)); - // Map in temp file and add some content - void* MappedMemory; - ASSERT_NO_ERROR(fs::map_file_pages(Twine(TempPath), 0, 4096, - true /*writable*/, MappedMemory)); - char* Memory = reinterpret_cast<char*>(MappedMemory); - strcpy(Memory, "hello there"); - - // Unmap temp file - ASSERT_NO_ERROR(fs::unmap_file_pages(MappedMemory, 4096)); - MappedMemory = NULL; - Memory = NULL; + error_code EC; + StringRef Val("hello there"); + { + fs::mapped_file_region mfr(FileDescriptor, + fs::mapped_file_region::readwrite, + 4096, + 0, + EC); + ASSERT_NO_ERROR(EC); + std::copy(Val.begin(), Val.end(), mfr.data()); + // Explicitly add a 0. + mfr.data()[Val.size()] = 0; + // Unmap temp file + } // Map it back in read-only - ASSERT_NO_ERROR(fs::map_file_pages(Twine(TempPath), 0, 4096, - false /*read-only*/, MappedMemory)); + fs::mapped_file_region mfr(Twine(TempPath), + fs::mapped_file_region::readonly, + 0, + 0, + EC); + ASSERT_NO_ERROR(EC); // Verify content - Memory = reinterpret_cast<char*>(MappedMemory); - bool SAME = (strcmp(Memory, "hello there") == 0); - EXPECT_TRUE(SAME); + EXPECT_EQ(StringRef(mfr.const_data()), Val); // Unmap temp file - ASSERT_NO_ERROR(fs::unmap_file_pages(MappedMemory, 4096)); - MappedMemory = NULL; - Memory = NULL; -} -#endif - +#if LLVM_USE_RVALUE_REFERENCES + fs::mapped_file_region m(Twine(TempPath), + fs::mapped_file_region::readonly, + 0, + 0, + EC); + ASSERT_NO_ERROR(EC); + const char *Data = m.const_data(); + fs::mapped_file_region mfrrv(llvm_move(m)); + EXPECT_EQ(mfrrv.const_data(), Data); +#endif +} } // anonymous namespace diff --git a/unittests/Support/YAMLParserTest.cpp b/unittests/Support/YAMLParserTest.cpp index e88427a..480a573 100644 --- a/unittests/Support/YAMLParserTest.cpp +++ b/unittests/Support/YAMLParserTest.cpp @@ -16,11 +16,17 @@ namespace llvm { +static void SuppressDiagnosticsOutput(const SMDiagnostic &, void *) { + // Prevent SourceMgr from writing errors to stderr + // to reduce noise in unit test runs. +} + // Checks that the given input gives a parse error. Makes sure that an error // text is available and the parse fails. static void ExpectParseError(StringRef Message, StringRef Input) { SourceMgr SM; yaml::Stream Stream(Input, SM); + SM.setDiagHandler(SuppressDiagnosticsOutput); EXPECT_FALSE(Stream.validate()) << Message << ": " << Input; EXPECT_TRUE(Stream.failed()) << Message << ": " << Input; } |