From b64793999546ed8adebaeebd9d8345d18db8927d Mon Sep 17 00:00:00 2001 From: patrick Date: Mon, 3 Aug 2020 15:06:44 +0000 Subject: Remove LLVM 8.0.1 files. --- gnu/llvm/unittests/ADT/ArrayRefTest.cpp | 252 -------------------------------- 1 file changed, 252 deletions(-) delete mode 100644 gnu/llvm/unittests/ADT/ArrayRefTest.cpp (limited to 'gnu/llvm/unittests/ADT/ArrayRefTest.cpp') diff --git a/gnu/llvm/unittests/ADT/ArrayRefTest.cpp b/gnu/llvm/unittests/ADT/ArrayRefTest.cpp deleted file mode 100644 index e01d212f218..00000000000 --- a/gnu/llvm/unittests/ADT/ArrayRefTest.cpp +++ /dev/null @@ -1,252 +0,0 @@ -//===- llvm/unittest/ADT/ArrayRefTest.cpp - ArrayRef 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/ArrayRef.h" -#include "llvm/Support/Allocator.h" -#include "llvm/Support/raw_ostream.h" -#include "gtest/gtest.h" -#include -#include -using namespace llvm; - -// Check that the ArrayRef-of-pointer converting constructor only allows adding -// cv qualifiers (not removing them, or otherwise changing the type) -static_assert( - std::is_convertible, ArrayRef>::value, - "Adding const"); -static_assert( - std::is_convertible, ArrayRef>::value, - "Adding volatile"); -static_assert(!std::is_convertible, ArrayRef>::value, - "Changing pointer of one type to a pointer of another"); -static_assert( - !std::is_convertible, ArrayRef>::value, - "Removing const"); -static_assert( - !std::is_convertible, ArrayRef>::value, - "Removing volatile"); - -// Check that we can't accidentally assign a temporary location to an ArrayRef. -// (Unfortunately we can't make use of the same thing with constructors.) -// -// Disable this check under MSVC; even MSVC 2015 isn't inconsistent between -// std::is_assignable and actually writing such an assignment. -#if !defined(_MSC_VER) -static_assert( - !std::is_assignable&, int *>::value, - "Assigning from single prvalue element"); -static_assert( - !std::is_assignable&, int * &&>::value, - "Assigning from single xvalue element"); -static_assert( - std::is_assignable&, int * &>::value, - "Assigning from single lvalue element"); -static_assert( - !std::is_assignable&, std::initializer_list>::value, - "Assigning from an initializer list"); -#endif - -namespace { - -TEST(ArrayRefTest, AllocatorCopy) { - BumpPtrAllocator Alloc; - static const uint16_t Words1[] = { 1, 4, 200, 37 }; - ArrayRef Array1 = makeArrayRef(Words1, 4); - static const uint16_t Words2[] = { 11, 4003, 67, 64000, 13 }; - ArrayRef Array2 = makeArrayRef(Words2, 5); - ArrayRef Array1c = Array1.copy(Alloc); - ArrayRef Array2c = Array2.copy(Alloc); - EXPECT_TRUE(Array1.equals(Array1c)); - EXPECT_NE(Array1.data(), Array1c.data()); - EXPECT_TRUE(Array2.equals(Array2c)); - EXPECT_NE(Array2.data(), Array2c.data()); - - // Check that copy can cope with uninitialized memory. - struct NonAssignable { - const char *Ptr; - - NonAssignable(const char *Ptr) : Ptr(Ptr) {} - NonAssignable(const NonAssignable &RHS) = default; - void operator=(const NonAssignable &RHS) { assert(RHS.Ptr != nullptr); } - bool operator==(const NonAssignable &RHS) const { return Ptr == RHS.Ptr; } - } Array3Src[] = {"hello", "world"}; - ArrayRef Array3Copy = makeArrayRef(Array3Src).copy(Alloc); - EXPECT_EQ(makeArrayRef(Array3Src), Array3Copy); - EXPECT_NE(makeArrayRef(Array3Src).data(), Array3Copy.data()); -} - -TEST(ArrayRefTest, SizeTSizedOperations) { - ArrayRef AR(nullptr, std::numeric_limits::max()); - - // Check that drop_back accepts size_t-sized numbers. - EXPECT_EQ(1U, AR.drop_back(AR.size() - 1).size()); - - // Check that drop_front accepts size_t-sized numbers. - EXPECT_EQ(1U, AR.drop_front(AR.size() - 1).size()); - - // Check that slice accepts size_t-sized numbers. - EXPECT_EQ(1U, AR.slice(AR.size() - 1).size()); - EXPECT_EQ(AR.size() - 1, AR.slice(1, AR.size() - 1).size()); -} - -TEST(ArrayRefTest, DropBack) { - static const int TheNumbers[] = {4, 8, 15, 16, 23, 42}; - ArrayRef AR1(TheNumbers); - ArrayRef AR2(TheNumbers, AR1.size() - 1); - EXPECT_TRUE(AR1.drop_back().equals(AR2)); -} - -TEST(ArrayRefTest, DropFront) { - static const int TheNumbers[] = {4, 8, 15, 16, 23, 42}; - ArrayRef AR1(TheNumbers); - ArrayRef AR2(&TheNumbers[2], AR1.size() - 2); - EXPECT_TRUE(AR1.drop_front(2).equals(AR2)); -} - -TEST(ArrayRefTest, DropWhile) { - static const int TheNumbers[] = {1, 3, 5, 8, 10, 11}; - ArrayRef AR1(TheNumbers); - ArrayRef Expected = AR1.drop_front(3); - EXPECT_EQ(Expected, AR1.drop_while([](const int &N) { return N % 2 == 1; })); - - EXPECT_EQ(AR1, AR1.drop_while([](const int &N) { return N < 0; })); - EXPECT_EQ(ArrayRef(), - AR1.drop_while([](const int &N) { return N > 0; })); -} - -TEST(ArrayRefTest, DropUntil) { - static const int TheNumbers[] = {1, 3, 5, 8, 10, 11}; - ArrayRef AR1(TheNumbers); - ArrayRef Expected = AR1.drop_front(3); - EXPECT_EQ(Expected, AR1.drop_until([](const int &N) { return N % 2 == 0; })); - - EXPECT_EQ(ArrayRef(), - AR1.drop_until([](const int &N) { return N < 0; })); - EXPECT_EQ(AR1, AR1.drop_until([](const int &N) { return N > 0; })); -} - -TEST(ArrayRefTest, TakeBack) { - static const int TheNumbers[] = {4, 8, 15, 16, 23, 42}; - ArrayRef AR1(TheNumbers); - ArrayRef AR2(AR1.end() - 1, 1); - EXPECT_TRUE(AR1.take_back().equals(AR2)); -} - -TEST(ArrayRefTest, TakeFront) { - static const int TheNumbers[] = {4, 8, 15, 16, 23, 42}; - ArrayRef AR1(TheNumbers); - ArrayRef AR2(AR1.data(), 2); - EXPECT_TRUE(AR1.take_front(2).equals(AR2)); -} - -TEST(ArrayRefTest, TakeWhile) { - static const int TheNumbers[] = {1, 3, 5, 8, 10, 11}; - ArrayRef AR1(TheNumbers); - ArrayRef Expected = AR1.take_front(3); - EXPECT_EQ(Expected, AR1.take_while([](const int &N) { return N % 2 == 1; })); - - EXPECT_EQ(ArrayRef(), - AR1.take_while([](const int &N) { return N < 0; })); - EXPECT_EQ(AR1, AR1.take_while([](const int &N) { return N > 0; })); -} - -TEST(ArrayRefTest, TakeUntil) { - static const int TheNumbers[] = {1, 3, 5, 8, 10, 11}; - ArrayRef AR1(TheNumbers); - ArrayRef Expected = AR1.take_front(3); - EXPECT_EQ(Expected, AR1.take_until([](const int &N) { return N % 2 == 0; })); - - EXPECT_EQ(AR1, AR1.take_until([](const int &N) { return N < 0; })); - EXPECT_EQ(ArrayRef(), - AR1.take_until([](const int &N) { return N > 0; })); -} - -TEST(ArrayRefTest, Equals) { - static const int A1[] = {1, 2, 3, 4, 5, 6, 7, 8}; - ArrayRef AR1(A1); - EXPECT_TRUE(AR1.equals({1, 2, 3, 4, 5, 6, 7, 8})); - EXPECT_FALSE(AR1.equals({8, 1, 2, 4, 5, 6, 6, 7})); - EXPECT_FALSE(AR1.equals({2, 4, 5, 6, 6, 7, 8, 1})); - EXPECT_FALSE(AR1.equals({0, 1, 2, 4, 5, 6, 6, 7})); - EXPECT_FALSE(AR1.equals({1, 2, 42, 4, 5, 6, 7, 8})); - EXPECT_FALSE(AR1.equals({42, 2, 3, 4, 5, 6, 7, 8})); - EXPECT_FALSE(AR1.equals({1, 2, 3, 4, 5, 6, 7, 42})); - EXPECT_FALSE(AR1.equals({1, 2, 3, 4, 5, 6, 7})); - EXPECT_FALSE(AR1.equals({1, 2, 3, 4, 5, 6, 7, 8, 9})); - - ArrayRef AR1a = AR1.drop_back(); - EXPECT_TRUE(AR1a.equals({1, 2, 3, 4, 5, 6, 7})); - EXPECT_FALSE(AR1a.equals({1, 2, 3, 4, 5, 6, 7, 8})); - - ArrayRef AR1b = AR1a.slice(2, 4); - EXPECT_TRUE(AR1b.equals({3, 4, 5, 6})); - EXPECT_FALSE(AR1b.equals({2, 3, 4, 5, 6})); - EXPECT_FALSE(AR1b.equals({3, 4, 5, 6, 7})); -} - -TEST(ArrayRefTest, EmptyEquals) { - EXPECT_TRUE(ArrayRef() == ArrayRef()); -} - -TEST(ArrayRefTest, ConstConvert) { - int buf[4]; - for (int i = 0; i < 4; ++i) - buf[i] = i; - - static int *A[] = {&buf[0], &buf[1], &buf[2], &buf[3]}; - ArrayRef a((ArrayRef(A))); - a = ArrayRef(A); -} - -static std::vector ReturnTest12() { return {1, 2}; } -static void ArgTest12(ArrayRef A) { - EXPECT_EQ(2U, A.size()); - EXPECT_EQ(1, A[0]); - EXPECT_EQ(2, A[1]); -} - -TEST(ArrayRefTest, InitializerList) { - std::initializer_list init_list = { 0, 1, 2, 3, 4 }; - ArrayRef A = init_list; - for (int i = 0; i < 5; ++i) - EXPECT_EQ(i, A[i]); - - std::vector B = ReturnTest12(); - A = B; - EXPECT_EQ(1, A[0]); - EXPECT_EQ(2, A[1]); - - ArgTest12({1, 2}); -} - -TEST(ArrayRefTest, EmptyInitializerList) { - ArrayRef A = {}; - EXPECT_TRUE(A.empty()); - - A = {}; - EXPECT_TRUE(A.empty()); -} - -// Test that makeArrayRef works on ArrayRef (no-op) -TEST(ArrayRefTest, makeArrayRef) { - static const int A1[] = {1, 2, 3, 4, 5, 6, 7, 8}; - - // No copy expected for non-const ArrayRef (true no-op) - ArrayRef AR1(A1); - ArrayRef &AR1Ref = makeArrayRef(AR1); - EXPECT_EQ(&AR1, &AR1Ref); - - // A copy is expected for non-const ArrayRef (thin copy) - const ArrayRef AR2(A1); - const ArrayRef &AR2Ref = makeArrayRef(AR2); - EXPECT_NE(&AR2Ref, &AR2); - EXPECT_TRUE(AR2.equals(AR2Ref)); -} - -} // end anonymous namespace -- cgit v1.2.3-59-g8ed1b