1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
|
//===-- adt_test.cpp ------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file is a part of the ORC runtime.
//
//===----------------------------------------------------------------------===//
#include "adt.h"
#include "gtest/gtest.h"
#include <sstream>
#include <string>
using namespace __orc_rt;
TEST(ADTTest, SpanDefaultConstruction) {
span<int> S;
EXPECT_TRUE(S.empty()) << "Default constructed span not empty";
EXPECT_EQ(S.size(), 0U) << "Default constructed span size not zero";
EXPECT_EQ(S.begin(), S.end()) << "Default constructed span begin != end";
}
TEST(ADTTest, SpanConstructFromFixedArray) {
int A[] = {1, 2, 3, 4, 5};
span<int> S(A);
EXPECT_FALSE(S.empty()) << "Span should be non-empty";
EXPECT_EQ(S.size(), 5U) << "Span has unexpected size";
EXPECT_EQ(std::distance(S.begin(), S.end()), 5U)
<< "Unexpected iterator range size";
EXPECT_EQ(S.data(), &A[0]) << "Span data has unexpected value";
for (unsigned I = 0; I != S.size(); ++I)
EXPECT_EQ(S[I], A[I]) << "Unexpected span element value";
}
TEST(ADTTest, SpanConstructFromIteratorAndSize) {
int A[] = {1, 2, 3, 4, 5};
span<int> S(&A[0], 5);
EXPECT_FALSE(S.empty()) << "Span should be non-empty";
EXPECT_EQ(S.size(), 5U) << "Span has unexpected size";
EXPECT_EQ(std::distance(S.begin(), S.end()), 5U)
<< "Unexpected iterator range size";
EXPECT_EQ(S.data(), &A[0]) << "Span data has unexpected value";
for (unsigned I = 0; I != S.size(); ++I)
EXPECT_EQ(S[I], A[I]) << "Unexpected span element value";
}
TEST(ADTTest, StringViewDefaultConstruction) {
string_view S;
EXPECT_TRUE(S.empty()) << "Default constructed span not empty";
EXPECT_EQ(S.size(), 0U) << "Default constructed span size not zero";
EXPECT_EQ(S.begin(), S.end()) << "Default constructed span begin != end";
}
TEST(ADTTest, StringViewConstructFromCharPtrAndSize) {
const char *Str = "abcdefg";
string_view S(Str, 5);
EXPECT_FALSE(S.empty()) << "string_view should be non-empty";
EXPECT_EQ(S.size(), 5U) << "string_view has unexpected size";
EXPECT_EQ(std::distance(S.begin(), S.end()), 5U)
<< "Unexpected iterator range size";
EXPECT_EQ(S.data(), &Str[0]) << "string_view data has unexpected value";
for (unsigned I = 0; I != S.size(); ++I)
EXPECT_EQ(S[I], Str[I]) << "Unexpected string_view element value";
}
TEST(ADTTest, StringViewConstructFromCharPtr) {
const char *Str = "abcdefg";
size_t StrLen = strlen(Str);
string_view S(Str);
EXPECT_FALSE(S.empty()) << "string_view should be non-empty";
EXPECT_EQ(S.size(), StrLen) << "string_view has unexpected size";
EXPECT_EQ(static_cast<size_t>(std::distance(S.begin(), S.end())), StrLen)
<< "Unexpected iterator range size";
EXPECT_EQ(S.data(), &Str[0]) << "string_view data has unexpected value";
for (unsigned I = 0; I != S.size(); ++I)
EXPECT_EQ(S[I], Str[I]) << "Unexpected string_view element value";
}
TEST(ADTTest, StringViewConstructFromStdString) {
std::string Str("abcdefg");
string_view S(Str);
EXPECT_FALSE(S.empty()) << "string_view should be non-empty";
EXPECT_EQ(S.size(), Str.size()) << "string_view has unexpected size";
EXPECT_EQ(static_cast<size_t>(std::distance(S.begin(), S.end())), Str.size())
<< "Unexpected iterator range size";
EXPECT_EQ(S.data(), &Str[0]) << "string_view data has unexpected value";
for (unsigned I = 0; I != S.size(); ++I)
EXPECT_EQ(S[I], Str[I]) << "Unexpected string_view element value";
}
TEST(ADTTest, StringViewCopyConstructionAndAssignment) {
// Check that string_views are copy-constructible and copy-assignable.
std::string Str("abcdefg");
string_view Orig(Str);
string_view CopyConstructed(Orig);
string_view CopyAssigned = Orig;
EXPECT_EQ(Orig, CopyConstructed);
EXPECT_EQ(Orig, CopyAssigned);
}
TEST(ADTTest, StringViewEquality) {
EXPECT_EQ("", string_view());
EXPECT_FALSE(string_view("aab") == string_view("aac"));
EXPECT_FALSE(string_view("aab") != string_view("aab"));
EXPECT_NE(string_view("aab"), string_view("aac"));
}
TEST(ADTTest, StringViewOStreamOperator) {
std::string Str("abcdefg");
string_view S(Str);
std::ostringstream OSS;
OSS << S;
EXPECT_EQ(OSS.str(), Str);
}
TEST(ADTTest, StringViewHashable) {
std::string Str("abcdefg");
string_view S(Str);
EXPECT_EQ(std::hash<std::string>()(Str), std::hash<string_view>()(S));
}
|
