X-Git-Url: http://plrg.eecs.uci.edu/git/?a=blobdiff_plain;f=folly%2Ftest%2FRangeTest.cpp;h=8a2b2762def14124b57ea0c7b927d48400d3f11d;hb=009082dca9eeaa2f75f839ece82ae44ef8659387;hp=8c98ee48151ced68b49439a774268b362c711f64;hpb=866e9b2f947f32fbcc1688239573355ee788ec8a;p=folly.git diff --git a/folly/test/RangeTest.cpp b/folly/test/RangeTest.cpp index 8c98ee48..8a2b2762 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,6 +19,7 @@ #include +#include #include #include @@ -31,7 +32,6 @@ #include #include #include -#include using namespace folly; using namespace folly::detail; @@ -293,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) { @@ -313,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("")); @@ -360,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("")); @@ -397,6 +418,13 @@ TEST(StringPiece, Suffix) { } } +TEST(StringPiece, Equals) { + StringPiece a("hello"); + + EXPECT_TRUE(a.equals("HELLO", AsciiCaseInsensitive())); + EXPECT_FALSE(a.equals("HELLOX", AsciiCaseInsensitive())); +} + TEST(StringPiece, PrefixEmpty) { StringPiece a; EXPECT_TRUE(a.startsWith("")); @@ -944,17 +972,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)); } } @@ -1096,6 +1124,62 @@ TEST(RangeFunc, CArray) { testRangeFunc(x, 4); } +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]); + constexpr const auto numArrayRangeSize = numArrayRange.size(); + EXPECT_EQ(4, numArrayRangeSize); +} + +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, std::mt19937& gen) { @@ -1228,3 +1312,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', ""); +}