X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=folly%2Ftest%2FRangeTest.cpp;h=791df2a051887cdadd8dcfe436126f90651e5654;hb=acbd8f4fd827e188dfb4209e35998fbe7ce9162a;hp=aed47dc2ef13a05dce1c461cee99edf9e0013da8;hpb=b99ed996050cdce752b71ab17461d9291aa083e6;p=folly.git diff --git a/folly/test/RangeTest.cpp b/folly/test/RangeTest.cpp index aed47dc2..791df2a0 100644 --- a/folly/test/RangeTest.cpp +++ b/folly/test/RangeTest.cpp @@ -1,5 +1,5 @@ /* - * Copyright 2016 Facebook, Inc. + * Copyright 2017 Facebook, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -19,9 +19,10 @@ #include -#include +#include +#include +#include -#include #include #include #include @@ -31,9 +32,9 @@ #include #include #include -#include using namespace folly; +using namespace folly::detail; using namespace std; static_assert(std::is_literal_type::value, ""); @@ -292,14 +293,16 @@ TEST(StringPiece, InvalidRange) { EXPECT_THROW(a.subpiece(6), std::out_of_range); } -constexpr char helloArray[] = "hello"; - TEST(StringPiece, Constexpr) { + constexpr const char* helloArray = "hello"; + constexpr StringPiece hello1("hello"); EXPECT_EQ("hello", hello1); + static_assert(hello1.size() == 5, "hello size should be 5 at compile time"); constexpr StringPiece hello2(helloArray); EXPECT_EQ("hello", hello2); + static_assert(hello2.size() == 5, "hello size should be 5 at compile time"); } TEST(StringPiece, Prefix) { @@ -312,6 +315,15 @@ TEST(StringPiece, Prefix) { EXPECT_FALSE(a.startsWith('x')); EXPECT_FALSE(a.startsWith("x")); + EXPECT_TRUE(a.startsWith("", folly::AsciiCaseInsensitive())); + EXPECT_TRUE(a.startsWith("hello", folly::AsciiCaseInsensitive())); + EXPECT_TRUE(a.startsWith("hellO", folly::AsciiCaseInsensitive())); + EXPECT_TRUE(a.startsWith("HELL", folly::AsciiCaseInsensitive())); + EXPECT_TRUE(a.startsWith("H", folly::AsciiCaseInsensitive())); + EXPECT_FALSE(a.startsWith("HELLOX", folly::AsciiCaseInsensitive())); + EXPECT_FALSE(a.startsWith("x", folly::AsciiCaseInsensitive())); + EXPECT_FALSE(a.startsWith("X", folly::AsciiCaseInsensitive())); + { auto b = a; EXPECT_TRUE(b.removePrefix("")); @@ -359,6 +371,16 @@ TEST(StringPiece, Suffix) { EXPECT_FALSE(a.endsWith("x")); EXPECT_FALSE(a.endsWith('x')); + EXPECT_TRUE(a.endsWith("", folly::AsciiCaseInsensitive())); + EXPECT_TRUE(a.endsWith("o", folly::AsciiCaseInsensitive())); + EXPECT_TRUE(a.endsWith("O", folly::AsciiCaseInsensitive())); + EXPECT_TRUE(a.endsWith("hello", folly::AsciiCaseInsensitive())); + EXPECT_TRUE(a.endsWith("hellO", folly::AsciiCaseInsensitive())); + EXPECT_FALSE(a.endsWith("xhello", folly::AsciiCaseInsensitive())); + EXPECT_FALSE(a.endsWith("Xhello", folly::AsciiCaseInsensitive())); + EXPECT_FALSE(a.endsWith("x", folly::AsciiCaseInsensitive())); + EXPECT_FALSE(a.endsWith("X", folly::AsciiCaseInsensitive())); + { auto b = a; EXPECT_TRUE(b.removeSuffix("")); @@ -943,17 +965,17 @@ TYPED_TEST(NeedleFinderTest, Needles256) { const auto maxValue = std::numeric_limits::max(); // make the size ~big to avoid any edge-case branches for tiny haystacks const int haystackSize = 50; - for (size_t i = minValue; i <= maxValue; i++) { // <= + for (int i = minValue; i <= maxValue; i++) { // <= needles.push_back(i); } EXPECT_EQ(StringPiece::npos, this->find_first_byte_of("", needles)); - for (size_t i = minValue; i <= maxValue; i++) { + for (int i = minValue; i <= maxValue; i++) { EXPECT_EQ(0, this->find_first_byte_of(string(haystackSize, i), needles)); } needles.append("these are redundant characters"); EXPECT_EQ(StringPiece::npos, this->find_first_byte_of("", needles)); - for (size_t i = minValue; i <= maxValue; i++) { + for (int i = minValue; i <= maxValue; i++) { EXPECT_EQ(0, this->find_first_byte_of(string(haystackSize, i), needles)); } } @@ -977,18 +999,22 @@ const size_t kPageSize = 4096; void createProtectedBuf(StringPiece& contents, char** buf) { ASSERT_LE(contents.size(), kPageSize); const size_t kSuccess = 0; - if (kSuccess != posix_memalign((void**)buf, kPageSize, 4 * kPageSize)) { + char* pageAlignedBuf = (char*)aligned_malloc(2 * kPageSize, kPageSize); + if (pageAlignedBuf == nullptr) { ASSERT_FALSE(true); } - mprotect(*buf + kPageSize, kPageSize, PROT_NONE); + // Protect the page after the first full page-aligned region of the + // malloc'ed buffer + mprotect(pageAlignedBuf + kPageSize, kPageSize, PROT_NONE); size_t newBegin = kPageSize - contents.size(); - memcpy(*buf + newBegin, contents.data(), contents.size()); - contents.reset(*buf + newBegin, contents.size()); + memcpy(pageAlignedBuf + newBegin, contents.data(), contents.size()); + contents.reset(pageAlignedBuf + newBegin, contents.size()); + *buf = pageAlignedBuf; } void freeProtectedBuf(char* buf) { mprotect(buf + kPageSize, kPageSize, PROT_READ | PROT_WRITE); - free(buf); + aligned_free(buf); } TYPED_TEST(NeedleFinderTest, NoSegFault) { @@ -1044,6 +1070,19 @@ TEST(NonConstTest, StringPiece) { } } +// Similar to the begin() template functions, but instread of returing +// an iterator, return a pointer to data. +template +typename Container::value_type* dataPtr(Container& cont) { + // NOTE: &cont[0] is undefined if cont is empty (it creates a + // reference to nullptr - which is not dereferenced, but still UBSAN). + return cont.data(); +} +template +constexpr T* dataPtr(T (&arr)[N]) noexcept { + return &arr[0]; +} + template void testRangeFunc(C&& x, size_t n) { const auto& cx = x; @@ -1052,8 +1091,8 @@ void testRangeFunc(C&& x, size_t n) { Range r2 = range(std::forward(x)); Range r3 = range(cx); Range r5 = range(std::move(cx)); - EXPECT_EQ(r1.begin(), &x[0]); - EXPECT_EQ(r1.end(), &x[n]); + EXPECT_EQ(r1.begin(), dataPtr(x)); + EXPECT_EQ(r1.end(), dataPtr(x) + n); EXPECT_EQ(n, r1.size()); EXPECT_EQ(n, r2.size()); EXPECT_EQ(n, r3.size()); @@ -1073,10 +1112,77 @@ TEST(RangeFunc, Array) { testRangeFunc(x, 3); } +// MSVC doesn't like it when you try to std::move C arrays: +// https://developercommunity.visualstudio.com/content/problem/2441/ +#ifndef _MSC_VER TEST(RangeFunc, CArray) { int x[] {1, 2, 3, 4}; testRangeFunc(x, 4); } +#endif + +TEST(RangeFunc, ConstexprCArray) { + static constexpr const int numArray[4] = {3, 17, 1, 9}; + constexpr const auto numArrayRange = range(numArray); + EXPECT_EQ(17, numArrayRange[1]); + constexpr const auto numArrayRangeSize = numArrayRange.size(); + EXPECT_EQ(4, numArrayRangeSize); +} + +TEST(RangeFunc, ConstexprStdArray) { + static constexpr const std::array numArray = {{3, 17, 1, 9}}; + constexpr const auto numArrayRange = range(numArray); + EXPECT_EQ(17, numArrayRange[1]); + // MSVC 2017 RC and earlier have an issue that causes the beginning and + // end of numArrayRange to point to different copies of numArray, causing + // this attempt to calculate the size to error at compile time because + // they don't point to parts of the same array :( + // https://developercommunity.visualstudio.com/content/problem/3216/ +#if !defined(_MSC_VER) || _MSC_VER > 191024629 + constexpr const auto numArrayRangeSize = numArrayRange.size(); + EXPECT_EQ(4, numArrayRangeSize); +#endif +} + +TEST(RangeFunc, ConstexprStdArrayZero) { + static constexpr const std::array numArray = {}; + constexpr const auto numArrayRange = range(numArray); + constexpr const auto numArrayRangeSize = numArrayRange.size(); + EXPECT_EQ(0, numArrayRangeSize); +} + +TEST(RangeFunc, ConstexprIteratorPair) { + static constexpr const int numArray[4] = {3, 17, 1, 9}; + constexpr const auto numPtr = static_cast(numArray); + constexpr const auto numIterRange = range(numPtr + 1, numPtr + 3); + EXPECT_EQ(1, numIterRange[1]); + constexpr const auto numIterRangeSize = numIterRange.size(); + EXPECT_EQ(2, numIterRangeSize); +} + +TEST(RangeFunc, ConstexprCollection) { + class IntCollection { + public: + constexpr IntCollection(const int* d, size_t s) : data_(d), size_(s) {} + constexpr const int* data() const { + return data_; + } + constexpr size_t size() const { + return size_; + } + + private: + const int* data_; + size_t size_; + }; + static constexpr const int numArray[4] = {3, 17, 1, 9}; + constexpr const auto numPtr = static_cast(numArray); + constexpr const auto numColl = IntCollection(numPtr + 1, 2); + constexpr const auto numCollRange = range(numColl); + EXPECT_EQ(1, numCollRange[1]); + constexpr const auto numCollRangeSize = numCollRange.size(); + EXPECT_EQ(2, numCollRangeSize); +} std::string get_rand_str(size_t size, std::uniform_int_distribution<>& dist, @@ -1210,3 +1316,49 @@ TEST(Range, Constructors) { EXPECT_EQ(subpiece1.begin(), subpiece2.begin()); EXPECT_EQ(subpiece1.end(), subpiece2.end()); } + +TEST(Range, ArrayConstructors) { + auto charArray = std::array{{'t', 'e', 's', 't'}}; + auto constCharArray = std::array{{'f', 'o', 'o', 'b', 'a', 'r'}}; + auto emptyArray = std::array{}; + + auto sp1 = StringPiece{charArray}; + EXPECT_EQ(4, sp1.size()); + EXPECT_EQ(charArray.data(), sp1.data()); + + auto sp2 = StringPiece(constCharArray); + EXPECT_EQ(6, sp2.size()); + EXPECT_EQ(constCharArray.data(), sp2.data()); + + auto msp = MutableStringPiece(charArray); + EXPECT_EQ(4, msp.size()); + EXPECT_EQ(charArray.data(), msp.data()); + + auto esp = StringPiece(emptyArray); + EXPECT_EQ(0, esp.size()); + EXPECT_EQ(nullptr, esp.data()); + + auto emsp = MutableStringPiece(emptyArray); + EXPECT_EQ(0, emsp.size()); + EXPECT_EQ(nullptr, emsp.data()); + + static constexpr std::array numArray = {{3, 17, 1, 9}}; + constexpr auto numRange = Range{numArray}; + EXPECT_EQ(17, numRange[1]); + + static constexpr std::array emptyNumArray{}; + constexpr auto emptyNumRange = Range{emptyNumArray}; + EXPECT_EQ(0, emptyNumRange.size()); +} + +TEST(Range, ConstexprAccessors) { + constexpr StringPiece piece = range("hello"); + static_assert(piece.size() == 6u, ""); + static_assert(piece.end() - piece.begin() == 6u, ""); + static_assert(piece.data() == piece.begin(), ""); + static_assert(piece.start() == piece.begin(), ""); + static_assert(piece.cbegin() == piece.begin(), ""); + static_assert(piece.cend() == piece.end(), ""); + static_assert(*piece.begin() == 'h', ""); + static_assert(*(piece.end() - 1) == '\0', ""); +}