test/core/gprpp/string_view_test.cc

   1 /*
   2  *
   3  * Copyright 2017 gRPC authors.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the "License");
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  *
  17  */
  18
  19 #include <grpc/slice.h>
  20
  21 #include "src/core/lib/gprpp/string_view.h"
  22
  23 #include <gtest/gtest.h>
  24 #include "src/core/lib/gprpp/memory.h"
  25 #include "test/core/util/test_config.h"
  26
  27 namespace grpc_core {
  28 namespace testing {
  29
  30 TEST(StringViewTest, Empty) {
  31   grpc_core::StringView empty;
  32   EXPECT_TRUE(empty.empty());
  33   EXPECT_EQ(empty.size(), 0lu);
  34
  35   grpc_core::StringView empty_buf("");
  36   EXPECT_TRUE(empty_buf.empty());
  37   EXPECT_EQ(empty_buf.size(), 0lu);
  38
  39   grpc_core::StringView empty_trimmed("foo", 0);
  40   EXPECT_TRUE(empty_trimmed.empty());
  41   EXPECT_EQ(empty_trimmed.size(), 0lu);
  42
  43   grpc_core::StringView empty_slice(
  44       grpc_core::StringViewFromSlice(grpc_empty_slice()));
  45   EXPECT_TRUE(empty_slice.empty());
  46   EXPECT_EQ(empty_slice.size(), 0lu);
  47 }
  48
  49 TEST(StringViewTest, Size) {
  50   constexpr char kStr[] = "foo";
  51   grpc_core::StringView str1(kStr);
  52   EXPECT_EQ(str1.size(), strlen(kStr));
  53   grpc_core::StringView str2(kStr, 2);
  54   EXPECT_EQ(str2.size(), 2lu);
  55 }
  56
  57 TEST(StringViewTest, Data) {
  58   constexpr char kStr[] = "foo-bar";
  59   grpc_core::StringView str(kStr);
  60   EXPECT_EQ(str.size(), strlen(kStr));
  61   for (size_t i = 0; i < strlen(kStr); ++i) {
  62     EXPECT_EQ(str[i], kStr[i]);
  63   }
  64 }
  65
  66 TEST(StringViewTest, Slice) {
  67   constexpr char kStr[] = "foo";
  68   grpc_core::StringView slice(
  69       grpc_core::StringViewFromSlice(grpc_slice_from_static_string(kStr)));
  70   EXPECT_EQ(slice.size(), strlen(kStr));
  71 }
  72
  73 TEST(StringViewTest, Dup) {
  74   constexpr char kStr[] = "foo";
  75   grpc_core::StringView slice(
  76       grpc_core::StringViewFromSlice(grpc_slice_from_static_string(kStr)));
  77   grpc_core::UniquePtr<char> dup = grpc_core::StringViewToCString(slice);
  78   EXPECT_EQ(0, strcmp(kStr, dup.get()));
  79   EXPECT_EQ(slice.size(), strlen(kStr));
  80 }
  81
  82 TEST(StringViewTest, Eq) {
  83   constexpr char kStr1[] = "foo";
  84   constexpr char kStr2[] = "bar";
  85   grpc_core::StringView str1(kStr1);
  86   EXPECT_EQ(kStr1, str1);
  87   EXPECT_EQ(str1, kStr1);
  88   grpc_core::StringView slice1(
  89       grpc_core::StringViewFromSlice(grpc_slice_from_static_string(kStr1)));
  90   EXPECT_EQ(slice1, str1);
  91   EXPECT_EQ(str1, slice1);
  92   EXPECT_NE(slice1, kStr2);
  93   EXPECT_NE(kStr2, slice1);
  94   grpc_core::StringView slice2(
  95       grpc_core::StringViewFromSlice(grpc_slice_from_static_string(kStr2)));
  96   EXPECT_NE(slice2, str1);
  97   EXPECT_NE(str1, slice2);
  98 }
  99
 100 TEST(StringViewTest, Cmp) {
 101   constexpr char kStr1[] = "abc";
 102   constexpr char kStr2[] = "abd";
 103   constexpr char kStr3[] = "abcd";
 104   grpc_core::StringView str1(kStr1);
 105   grpc_core::StringView str2(kStr2);
 106   grpc_core::StringView str3(kStr3);
 107   EXPECT_EQ(str1.compare(str1), 0);
 108   EXPECT_LT(str1.compare(str2), 0);
 109   EXPECT_LT(str1.compare(str3), 0);
 110   EXPECT_EQ(str2.compare(str2), 0);
 111   EXPECT_GT(str2.compare(str1), 0);
 112   EXPECT_GT(str2.compare(str3), 0);
 113   EXPECT_EQ(str3.compare(str3), 0);
 114   EXPECT_GT(str3.compare(str1), 0);
 115   EXPECT_LT(str3.compare(str2), 0);
 116 }
 117
 118 TEST(StringViewTest, RemovePrefix) {
 119   constexpr char kStr[] = "abcd";
 120   grpc_core::StringView str(kStr);
 121   str.remove_prefix(1);
 122   EXPECT_EQ("bcd", str);
 123   str.remove_prefix(2);
 124   EXPECT_EQ("d", str);
 125   str.remove_prefix(1);
 126   EXPECT_EQ("", str);
 127 }
 128
 129 TEST(StringViewTest, RemoveSuffix) {
 130   constexpr char kStr[] = "abcd";
 131   grpc_core::StringView str(kStr);
 132   str.remove_suffix(1);
 133   EXPECT_EQ("abc", str);
 134   str.remove_suffix(2);
 135   EXPECT_EQ("a", str);
 136   str.remove_suffix(1);
 137   EXPECT_EQ("", str);
 138 }
 139
 140 TEST(StringViewTest, Substring) {
 141   constexpr char kStr[] = "abcd";
 142   grpc_core::StringView str(kStr);
 143   EXPECT_EQ("bcd", str.substr(1));
 144   EXPECT_EQ("bc", str.substr(1, 2));
 145 }
 146
 147 TEST(StringViewTest, Find) {
 148   // Passing StringView::npos directly to GTEST macros result in link errors.
 149   // Store the value in a local variable and use it in the test.
 150   const size_t npos = grpc_core::StringView::npos;
 151   constexpr char kStr[] = "abacad";
 152   grpc_core::StringView str(kStr);
 153   EXPECT_EQ(0ul, str.find('a'));
 154   EXPECT_EQ(2ul, str.find('a', 1));
 155   EXPECT_EQ(4ul, str.find('a', 3));
 156   EXPECT_EQ(1ul, str.find('b'));
 157   EXPECT_EQ(npos, str.find('b', 2));
 158   EXPECT_EQ(npos, str.find('z'));
 159 }
 160
 161 }  // namespace testing
 162 }  // namespace grpc_core
 163
 164 int main(int argc, char** argv) {
 165   grpc::testing::TestEnvironment env(argc, argv);
 166   ::testing::InitGoogleTest(&argc, argv);
 167   return RUN_ALL_TESTS();
 168 }