294 lines
8.6 KiB
C++
294 lines
8.6 KiB
C++
//===--- span_test.cpp - Tests for the span class -------------------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "span.h"
|
|
|
|
#include "gmock/gmock.h"
|
|
#include "gtest/gtest.h"
|
|
|
|
#include <array>
|
|
#include <vector>
|
|
|
|
namespace {
|
|
|
|
template <typename T, size_t N> size_t arraySize(T (&)[N]) { return N; }
|
|
|
|
TEST(Span, NullConstruction) {
|
|
acxxel::Span<int> Span0;
|
|
EXPECT_EQ(nullptr, Span0.data());
|
|
EXPECT_EQ(0, Span0.size());
|
|
|
|
acxxel::Span<int> Span1(nullptr);
|
|
EXPECT_EQ(nullptr, Span1.data());
|
|
EXPECT_EQ(0, Span1.size());
|
|
}
|
|
|
|
TEST(Span, PtrSizeConstruction) {
|
|
int ZeroSize = 0;
|
|
acxxel::Span<int> Span0(nullptr, ZeroSize);
|
|
EXPECT_EQ(Span0.data(), nullptr);
|
|
EXPECT_EQ(Span0.size(), 0);
|
|
|
|
int Values[] = {0, 1, 2};
|
|
acxxel::Span<int> Span1(Values, arraySize(Values));
|
|
EXPECT_EQ(Span1.data(), Values);
|
|
EXPECT_EQ(static_cast<size_t>(Span1.size()), arraySize(Values));
|
|
|
|
acxxel::Span<int> Span2(Values, ZeroSize);
|
|
EXPECT_EQ(Span2.data(), Values);
|
|
EXPECT_EQ(Span2.size(), 0);
|
|
}
|
|
|
|
TEST(Span, PtrSizeConstruction_NegativeCount) {
|
|
int Values[] = {0, 1, 2};
|
|
EXPECT_DEATH(acxxel::Span<int> Span0(Values, -1), "terminate");
|
|
}
|
|
|
|
TEST(Span, PtrSizeConstruction_NullptrNonzeroSize) {
|
|
EXPECT_DEATH(acxxel::Span<int> Span0(nullptr, 1), "terminate");
|
|
}
|
|
|
|
TEST(Span, FirstLastConstruction) {
|
|
int Values[] = {0, 1, 2};
|
|
|
|
acxxel::Span<int> Span0(Values, Values);
|
|
EXPECT_EQ(Span0.data(), Values);
|
|
EXPECT_EQ(Span0.size(), 0);
|
|
|
|
acxxel::Span<int> Span(Values, Values + 2);
|
|
EXPECT_EQ(Span.data(), Values);
|
|
EXPECT_EQ(Span.size(), 2);
|
|
}
|
|
|
|
TEST(Span, FirstLastConstruction_LastBeforeFirst) {
|
|
int Values[] = {0, 1, 2};
|
|
EXPECT_DEATH(acxxel::Span<int> Span(Values + 2, Values), "terminate");
|
|
}
|
|
|
|
TEST(Span, ArrayConstruction) {
|
|
int Array[] = {0, 1, 2};
|
|
acxxel::Span<int> Span(Array);
|
|
EXPECT_EQ(Span.data(), Array);
|
|
EXPECT_EQ(Span.size(), 3);
|
|
}
|
|
|
|
TEST(Span, StdArrayConstruction) {
|
|
std::array<int, 3> Array{{0, 1, 2}};
|
|
acxxel::Span<int> Span(Array);
|
|
EXPECT_EQ(Span.data(), Array.data());
|
|
EXPECT_EQ(static_cast<size_t>(Span.size()), Array.size());
|
|
|
|
std::array<const int, 3> ConstArray{{0, 1, 2}};
|
|
acxxel::Span<const int> ConstSpan(ConstArray);
|
|
EXPECT_EQ(ConstSpan.data(), ConstArray.data());
|
|
EXPECT_EQ(static_cast<size_t>(ConstSpan.size()), ConstArray.size());
|
|
}
|
|
|
|
TEST(Span, ContainerConstruction) {
|
|
std::vector<int> Vector = {0, 1, 2};
|
|
acxxel::Span<int> Span(Vector);
|
|
EXPECT_EQ(Span.data(), &Vector[0]);
|
|
EXPECT_EQ(static_cast<size_t>(Span.size()), Vector.size());
|
|
}
|
|
|
|
TEST(Span, CopyConstruction) {
|
|
int Values[] = {0, 1, 2};
|
|
acxxel::Span<int> Span0(Values);
|
|
acxxel::Span<int> Span1(Span0);
|
|
EXPECT_EQ(Span1.data(), Values);
|
|
EXPECT_EQ(static_cast<size_t>(Span1.size()), arraySize(Values));
|
|
}
|
|
|
|
TEST(Span, CopyAssignment) {
|
|
int Values[] = {0, 1, 2};
|
|
acxxel::Span<int> Span0(Values);
|
|
acxxel::Span<int> Span1;
|
|
Span1 = Span0;
|
|
EXPECT_EQ(Span1.data(), Values);
|
|
EXPECT_EQ(static_cast<size_t>(Span1.size()), arraySize(Values));
|
|
}
|
|
|
|
TEST(Span, CopyConstFromNonConst) {
|
|
int Values[] = {0, 1, 2};
|
|
acxxel::Span<int> Span0(Values);
|
|
acxxel::Span<const int> Span1(Span0);
|
|
EXPECT_EQ(Span1.data(), Values);
|
|
EXPECT_EQ(static_cast<size_t>(Span1.size()), arraySize(Values));
|
|
}
|
|
|
|
TEST(Span, FirstMethod) {
|
|
int Values[] = {0, 1, 2};
|
|
acxxel::Span<int> Span(Values);
|
|
acxxel::Span<int> Span0 = Span.first(0);
|
|
acxxel::Span<int> Span1 = Span.first(1);
|
|
acxxel::Span<int> Span2 = Span.first(2);
|
|
acxxel::Span<int> Span3 = Span.first(3);
|
|
|
|
EXPECT_EQ(Span0.data(), Values);
|
|
EXPECT_EQ(Span1.data(), Values);
|
|
EXPECT_EQ(Span2.data(), Values);
|
|
EXPECT_EQ(Span3.data(), Values);
|
|
|
|
EXPECT_TRUE(Span0.empty());
|
|
|
|
EXPECT_THAT(Span1, ::testing::ElementsAre(0));
|
|
EXPECT_THAT(Span2, ::testing::ElementsAre(0, 1));
|
|
EXPECT_THAT(Span3, ::testing::ElementsAre(0, 1, 2));
|
|
}
|
|
|
|
TEST(Span, FirstMethod_IllegalArguments) {
|
|
int Values[] = {0, 1, 2};
|
|
acxxel::Span<int> Span(Values);
|
|
|
|
EXPECT_DEATH(Span.first(-1), "terminate");
|
|
EXPECT_DEATH(Span.first(4), "terminate");
|
|
}
|
|
|
|
TEST(Span, LastMethod) {
|
|
int Values[] = {0, 1, 2};
|
|
acxxel::Span<int> Span(Values);
|
|
acxxel::Span<int> Span0 = Span.last(0);
|
|
acxxel::Span<int> Span1 = Span.last(1);
|
|
acxxel::Span<int> Span2 = Span.last(2);
|
|
acxxel::Span<int> Span3 = Span.last(3);
|
|
|
|
EXPECT_EQ(Span0.data(), Values);
|
|
EXPECT_EQ(Span1.data(), Values + 2);
|
|
EXPECT_EQ(Span2.data(), Values + 1);
|
|
EXPECT_EQ(Span3.data(), Values);
|
|
|
|
EXPECT_TRUE(Span0.empty());
|
|
|
|
EXPECT_THAT(Span1, ::testing::ElementsAre(2));
|
|
EXPECT_THAT(Span2, ::testing::ElementsAre(1, 2));
|
|
EXPECT_THAT(Span3, ::testing::ElementsAre(0, 1, 2));
|
|
}
|
|
|
|
TEST(Span, LastMethod_IllegalArguments) {
|
|
int Values[] = {0, 1, 2};
|
|
acxxel::Span<int> Span(Values);
|
|
|
|
EXPECT_DEATH(Span.last(-1), "terminate");
|
|
EXPECT_DEATH(Span.last(4), "terminate");
|
|
}
|
|
|
|
TEST(Span, SubspanMethod) {
|
|
int Values[] = {0, 1, 2};
|
|
acxxel::Span<int> Span(Values);
|
|
|
|
acxxel::Span<int> Span0 = Span.subspan(0);
|
|
acxxel::Span<int> Span0e = Span.subspan(0, acxxel::dynamic_extent);
|
|
acxxel::Span<int> Span00 = Span.subspan(0, 0);
|
|
acxxel::Span<int> Span01 = Span.subspan(0, 1);
|
|
acxxel::Span<int> Span02 = Span.subspan(0, 2);
|
|
acxxel::Span<int> Span03 = Span.subspan(0, 3);
|
|
|
|
acxxel::Span<int> Span1 = Span.subspan(1);
|
|
acxxel::Span<int> Span1e = Span.subspan(1, acxxel::dynamic_extent);
|
|
acxxel::Span<int> Span10 = Span.subspan(1, 0);
|
|
acxxel::Span<int> Span11 = Span.subspan(1, 1);
|
|
acxxel::Span<int> Span12 = Span.subspan(1, 2);
|
|
|
|
acxxel::Span<int> Span2 = Span.subspan(2);
|
|
acxxel::Span<int> Span2e = Span.subspan(2, acxxel::dynamic_extent);
|
|
acxxel::Span<int> Span20 = Span.subspan(2, 0);
|
|
acxxel::Span<int> Span21 = Span.subspan(2, 1);
|
|
|
|
acxxel::Span<int> Span3 = Span.subspan(3);
|
|
acxxel::Span<int> Span3e = Span.subspan(3, acxxel::dynamic_extent);
|
|
acxxel::Span<int> Span30 = Span.subspan(3, 0);
|
|
|
|
EXPECT_EQ(Span0.data(), Values);
|
|
EXPECT_EQ(Span0e.data(), Values);
|
|
EXPECT_EQ(Span00.data(), Values);
|
|
EXPECT_EQ(Span01.data(), Values);
|
|
EXPECT_EQ(Span02.data(), Values);
|
|
EXPECT_EQ(Span03.data(), Values);
|
|
|
|
EXPECT_EQ(Span1.data(), Values + 1);
|
|
EXPECT_EQ(Span1e.data(), Values + 1);
|
|
EXPECT_EQ(Span10.data(), Values + 1);
|
|
EXPECT_EQ(Span11.data(), Values + 1);
|
|
EXPECT_EQ(Span12.data(), Values + 1);
|
|
|
|
EXPECT_EQ(Span2.data(), Values + 2);
|
|
EXPECT_EQ(Span2e.data(), Values + 2);
|
|
EXPECT_EQ(Span20.data(), Values + 2);
|
|
EXPECT_EQ(Span21.data(), Values + 2);
|
|
|
|
EXPECT_EQ(Span3.data(), Values + 3);
|
|
EXPECT_EQ(Span3e.data(), Values + 3);
|
|
EXPECT_EQ(Span30.data(), Values + 3);
|
|
|
|
EXPECT_TRUE(Span00.empty());
|
|
EXPECT_TRUE(Span10.empty());
|
|
EXPECT_TRUE(Span20.empty());
|
|
EXPECT_TRUE(Span30.empty());
|
|
|
|
EXPECT_THAT(Span0, ::testing::ElementsAre(0, 1, 2));
|
|
EXPECT_THAT(Span0e, ::testing::ElementsAre(0, 1, 2));
|
|
EXPECT_THAT(Span01, ::testing::ElementsAre(0));
|
|
EXPECT_THAT(Span02, ::testing::ElementsAre(0, 1));
|
|
EXPECT_THAT(Span03, ::testing::ElementsAre(0, 1, 2));
|
|
|
|
EXPECT_THAT(Span1, ::testing::ElementsAre(1, 2));
|
|
EXPECT_THAT(Span1e, ::testing::ElementsAre(1, 2));
|
|
EXPECT_THAT(Span11, ::testing::ElementsAre(1));
|
|
EXPECT_THAT(Span12, ::testing::ElementsAre(1, 2));
|
|
|
|
EXPECT_THAT(Span2, ::testing::ElementsAre(2));
|
|
EXPECT_THAT(Span2e, ::testing::ElementsAre(2));
|
|
EXPECT_THAT(Span21, ::testing::ElementsAre(2));
|
|
|
|
EXPECT_TRUE(Span3.empty());
|
|
EXPECT_TRUE(Span3e.empty());
|
|
}
|
|
|
|
TEST(Span, SubspanMethod_IllegalArguments) {
|
|
int Values[] = {0, 1, 2};
|
|
acxxel::Span<int> Span(Values);
|
|
EXPECT_DEATH(Span.subspan(-1, 0), "terminate");
|
|
EXPECT_DEATH(Span.subspan(0, -2), "terminate");
|
|
EXPECT_DEATH(Span.subspan(0, 4), "terminate");
|
|
EXPECT_DEATH(Span.subspan(1, 3), "terminate");
|
|
EXPECT_DEATH(Span.subspan(2, 2), "terminate");
|
|
EXPECT_DEATH(Span.subspan(3, 1), "terminate");
|
|
EXPECT_DEATH(Span.subspan(4, 0), "terminate");
|
|
}
|
|
|
|
TEST(Span, ElementAccess) {
|
|
int Values[] = {0, 1, 2};
|
|
acxxel::Span<int> Span(Values);
|
|
|
|
EXPECT_EQ(&Span[0], Values);
|
|
EXPECT_EQ(&Span[1], Values + 1);
|
|
EXPECT_EQ(&Span[2], Values + 2);
|
|
EXPECT_EQ(&Span(0), Values);
|
|
EXPECT_EQ(&Span(1), Values + 1);
|
|
EXPECT_EQ(&Span(2), Values + 2);
|
|
|
|
Span[0] = 5;
|
|
EXPECT_EQ(Values[0], 5);
|
|
|
|
Span(0) = 0;
|
|
EXPECT_EQ(Values[0], 0);
|
|
|
|
const int ConstValues[] = {0, 1, 2};
|
|
acxxel::Span<const int> ConstSpan(ConstValues);
|
|
|
|
EXPECT_EQ(&ConstSpan[0], ConstValues);
|
|
EXPECT_EQ(&ConstSpan[1], ConstValues + 1);
|
|
EXPECT_EQ(&ConstSpan[2], ConstValues + 2);
|
|
EXPECT_EQ(&ConstSpan(0), ConstValues);
|
|
EXPECT_EQ(&ConstSpan(1), ConstValues + 1);
|
|
EXPECT_EQ(&ConstSpan(2), ConstValues + 2);
|
|
}
|
|
|
|
} // namespace
|