1 // Copyright 2021 The Abseil Authors
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 //     https://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14 
15 #include <cstdint>
16 #include <string>
17 
18 #include "gmock/gmock.h"
19 #include "gtest/gtest.h"
20 #include "absl/base/config.h"
21 #include "absl/base/internal/raw_logging.h"
22 #include "absl/base/macros.h"
23 #include "absl/strings/cord.h"
24 #include "absl/strings/cord_test_helpers.h"
25 #include "absl/strings/cordz_test_helpers.h"
26 #include "absl/strings/internal/cordz_functions.h"
27 #include "absl/strings/internal/cordz_info.h"
28 #include "absl/strings/internal/cordz_sample_token.h"
29 #include "absl/strings/internal/cordz_statistics.h"
30 #include "absl/strings/internal/cordz_update_tracker.h"
31 #include "absl/strings/str_cat.h"
32 #include "absl/strings/string_view.h"
33 
34 #ifdef ABSL_INTERNAL_CORDZ_ENABLED
35 
36 using testing::Eq;
37 using testing::AnyOf;
38 
39 namespace absl {
40 ABSL_NAMESPACE_BEGIN
41 
42 using cord_internal::CordzInfo;
43 using cord_internal::CordzSampleToken;
44 using cord_internal::CordzStatistics;
45 using cord_internal::CordzUpdateTracker;
46 using Method = CordzUpdateTracker::MethodIdentifier;
47 
48 // Do not print cord contents, we only care about 'size' perhaps.
49 // Note that this method must be inside the named namespace.
PrintTo(const Cord & cord,std::ostream * s)50 inline void PrintTo(const Cord& cord, std::ostream* s) {
51   if (s) *s << "Cord[" << cord.size() << "]";
52 }
53 
54 namespace {
55 
56 auto constexpr kMaxInline = cord_internal::kMaxInline;
57 
58 // Returns a string_view value of the specified length
59 // We do this to avoid 'consuming' large strings in Cord by default.
MakeString(size_t size)60 absl::string_view MakeString(size_t size) {
61   thread_local std::string str;
62   str = std::string(size, '.');
63   return str;
64 }
65 
MakeString(TestCordSize size)66 absl::string_view MakeString(TestCordSize size) {
67   return MakeString(Length(size));
68 }
69 
70 // Returns a cord with a sampled method of kAppendString.
MakeAppendStringCord(TestCordSize size)71 absl::Cord MakeAppendStringCord(TestCordSize size) {
72   CordzSamplingIntervalHelper always(1);
73   absl::Cord cord;
74   cord.Append(MakeString(size));
75   return cord;
76 }
77 
TestParamToString(::testing::TestParamInfo<TestCordSize> size)78 std::string TestParamToString(::testing::TestParamInfo<TestCordSize> size) {
79   return absl::StrCat("On", ToString(size.param), "Cord");
80 }
81 
82 class CordzUpdateTest : public testing::TestWithParam<TestCordSize> {
83  public:
cord()84   Cord& cord() { return cord_; }
85 
InitialOr(Method method) const86   Method InitialOr(Method method) const {
87     return (GetParam() > TestCordSize::kInlined) ? Method::kConstructorString
88                                                  : method;
89   }
90 
91  private:
92   CordzSamplingIntervalHelper sample_every_{1};
93   Cord cord_{MakeString(GetParam())};
94 };
95 
96 template <typename T>
ParamToString(::testing::TestParamInfo<T> param)97 std::string ParamToString(::testing::TestParamInfo<T> param) {
98   return std::string(ToString(param.param));
99 }
100 
101 INSTANTIATE_TEST_SUITE_P(WithParam, CordzUpdateTest,
102                          testing::Values(TestCordSize::kEmpty,
103                                          TestCordSize::kInlined,
104                                          TestCordSize::kLarge),
105                          TestParamToString);
106 
107 class CordzStringTest : public testing::TestWithParam<TestCordSize> {
108  private:
109   CordzSamplingIntervalHelper sample_every_{1};
110 };
111 
112 INSTANTIATE_TEST_SUITE_P(WithParam, CordzStringTest,
113                          testing::Values(TestCordSize::kInlined,
114                                          TestCordSize::kStringSso1,
115                                          TestCordSize::kStringSso2,
116                                          TestCordSize::kSmall,
117                                          TestCordSize::kLarge),
118                          ParamToString<TestCordSize>);
119 
TEST(CordzTest,ConstructSmallArray)120 TEST(CordzTest, ConstructSmallArray) {
121   CordzSamplingIntervalHelper sample_every{1};
122   Cord cord(MakeString(TestCordSize::kSmall));
123   EXPECT_THAT(cord, HasValidCordzInfoOf(Method::kConstructorString));
124 }
125 
TEST(CordzTest,ConstructLargeArray)126 TEST(CordzTest, ConstructLargeArray) {
127   CordzSamplingIntervalHelper sample_every{1};
128   Cord cord(MakeString(TestCordSize::kLarge));
129   EXPECT_THAT(cord, HasValidCordzInfoOf(Method::kConstructorString));
130 }
131 
TEST_P(CordzStringTest,ConstructString)132 TEST_P(CordzStringTest, ConstructString) {
133   CordzSamplingIntervalHelper sample_every{1};
134   Cord cord(std::string(Length(GetParam()), '.'));
135   if (Length(GetParam()) > kMaxInline) {
136     EXPECT_THAT(cord, HasValidCordzInfoOf(Method::kConstructorString));
137   }
138 }
139 
TEST(CordzTest,CopyConstructFromUnsampled)140 TEST(CordzTest, CopyConstructFromUnsampled) {
141   CordzSamplingIntervalHelper sample_every{1};
142   Cord src = UnsampledCord(MakeString(TestCordSize::kLarge));
143   Cord cord(src);
144   EXPECT_THAT(GetCordzInfoForTesting(cord), Eq(nullptr));
145 }
146 
TEST(CordzTest,CopyConstructFromSampled)147 TEST(CordzTest, CopyConstructFromSampled) {
148   CordzSamplingIntervalHelper sample_never{99999};
149   Cord src = MakeAppendStringCord(TestCordSize::kLarge);
150   Cord cord(src);
151   ASSERT_THAT(cord, HasValidCordzInfoOf(Method::kConstructorCord));
152   CordzStatistics stats = GetCordzInfoForTesting(cord)->GetCordzStatistics();
153   EXPECT_THAT(stats.parent_method, Eq(Method::kAppendString));
154   EXPECT_THAT(stats.update_tracker.Value(Method::kAppendString), Eq(1));
155 }
156 
TEST(CordzTest,MoveConstruct)157 TEST(CordzTest, MoveConstruct) {
158   CordzSamplingIntervalHelper sample_every{1};
159   Cord src(MakeString(TestCordSize::kLarge));
160   Cord cord(std::move(src));
161   EXPECT_THAT(cord, HasValidCordzInfoOf(Method::kConstructorString));
162 }
163 
TEST_P(CordzUpdateTest,AssignUnsampledCord)164 TEST_P(CordzUpdateTest, AssignUnsampledCord) {
165   Cord src = UnsampledCord(MakeString(TestCordSize::kLarge));
166   const CordzInfo* info = GetCordzInfoForTesting(cord());
167   cord() = src;
168   EXPECT_THAT(GetCordzInfoForTesting(cord()), Eq(nullptr));
169   EXPECT_FALSE(CordzInfoIsListed(info));
170 }
171 
TEST_P(CordzUpdateTest,AssignSampledCord)172 TEST_P(CordzUpdateTest, AssignSampledCord) {
173   Cord src = MakeAppendStringCord(TestCordSize::kLarge);
174   cord() = src;
175   ASSERT_THAT(cord(), HasValidCordzInfoOf(Method::kAssignCord));
176   CordzStatistics stats = GetCordzInfoForTesting(cord())->GetCordzStatistics();
177   EXPECT_THAT(stats.parent_method, Eq(Method::kAppendString));
178   EXPECT_THAT(stats.update_tracker.Value(Method::kAppendString), Eq(1));
179   EXPECT_THAT(stats.update_tracker.Value(Method::kConstructorString), Eq(0));
180 }
181 
TEST(CordzUpdateTest,AssignSampledCordToInlined)182 TEST(CordzUpdateTest, AssignSampledCordToInlined) {
183   CordzSamplingIntervalHelper sample_never{99999};
184   Cord cord;
185   Cord src = MakeAppendStringCord(TestCordSize::kLarge);
186   cord = src;
187   ASSERT_THAT(cord, HasValidCordzInfoOf(Method::kAssignCord));
188   CordzStatistics stats = GetCordzInfoForTesting(cord)->GetCordzStatistics();
189   EXPECT_THAT(stats.parent_method, Eq(Method::kAppendString));
190   EXPECT_THAT(stats.update_tracker.Value(Method::kAppendString), Eq(1));
191   EXPECT_THAT(stats.update_tracker.Value(Method::kConstructorString), Eq(0));
192 }
193 
TEST(CordzUpdateTest,AssignSampledCordToUnsampledCord)194 TEST(CordzUpdateTest, AssignSampledCordToUnsampledCord) {
195   CordzSamplingIntervalHelper sample_never{99999};
196   Cord cord = UnsampledCord(MakeString(TestCordSize::kLarge));
197   Cord src = MakeAppendStringCord(TestCordSize::kLarge);
198   cord = src;
199   ASSERT_THAT(cord, HasValidCordzInfoOf(Method::kAssignCord));
200   CordzStatistics stats = GetCordzInfoForTesting(cord)->GetCordzStatistics();
201   EXPECT_THAT(stats.parent_method, Eq(Method::kAppendString));
202   EXPECT_THAT(stats.update_tracker.Value(Method::kAppendString), Eq(1));
203   EXPECT_THAT(stats.update_tracker.Value(Method::kConstructorString), Eq(0));
204 }
205 
TEST(CordzUpdateTest,AssignUnsampledCordToSampledCordWithoutSampling)206 TEST(CordzUpdateTest, AssignUnsampledCordToSampledCordWithoutSampling) {
207   CordzSamplingIntervalHelper sample_never{99999};
208   Cord cord = MakeAppendStringCord(TestCordSize::kLarge);
209   const CordzInfo* info = GetCordzInfoForTesting(cord);
210   Cord src = UnsampledCord(MakeString(TestCordSize::kLarge));
211   cord = src;
212   EXPECT_THAT(GetCordzInfoForTesting(cord), Eq(nullptr));
213   EXPECT_FALSE(CordzInfoIsListed(info));
214 }
215 
TEST(CordzUpdateTest,AssignUnsampledCordToSampledCordWithSampling)216 TEST(CordzUpdateTest, AssignUnsampledCordToSampledCordWithSampling) {
217   CordzSamplingIntervalHelper sample_every{1};
218   Cord cord = MakeAppendStringCord(TestCordSize::kLarge);
219   const CordzInfo* info = GetCordzInfoForTesting(cord);
220   Cord src = UnsampledCord(MakeString(TestCordSize::kLarge));
221   cord = src;
222   EXPECT_THAT(GetCordzInfoForTesting(cord), Eq(nullptr));
223   EXPECT_FALSE(CordzInfoIsListed(info));
224 }
225 
TEST(CordzUpdateTest,AssignSampledCordToSampledCord)226 TEST(CordzUpdateTest, AssignSampledCordToSampledCord) {
227   CordzSamplingIntervalHelper sample_every{1};
228   Cord src = MakeAppendStringCord(TestCordSize::kLarge);
229   Cord cord(MakeString(TestCordSize::kLarge));
230   cord = src;
231   ASSERT_THAT(cord, HasValidCordzInfoOf(Method::kAssignCord));
232   CordzStatistics stats = GetCordzInfoForTesting(cord)->GetCordzStatistics();
233   EXPECT_THAT(stats.parent_method, Eq(Method::kAppendString));
234   EXPECT_THAT(stats.update_tracker.Value(Method::kAppendString), Eq(1));
235   EXPECT_THAT(stats.update_tracker.Value(Method::kConstructorString), Eq(0));
236 }
237 
TEST(CordzUpdateTest,AssignUnsampledCordToSampledCord)238 TEST(CordzUpdateTest, AssignUnsampledCordToSampledCord) {
239   CordzSamplingIntervalHelper sample_every{1};
240   Cord src = MakeAppendStringCord(TestCordSize::kLarge);
241   Cord cord(MakeString(TestCordSize::kLarge));
242   cord = src;
243   ASSERT_THAT(cord, HasValidCordzInfoOf(Method::kAssignCord));
244   CordzStatistics stats = GetCordzInfoForTesting(cord)->GetCordzStatistics();
245   EXPECT_THAT(stats.parent_method, Eq(Method::kAppendString));
246   EXPECT_THAT(stats.update_tracker.Value(Method::kAppendString), Eq(1));
247   EXPECT_THAT(stats.update_tracker.Value(Method::kConstructorString), Eq(0));
248 }
249 
TEST(CordzTest,AssignInlinedCordToSampledCord)250 TEST(CordzTest, AssignInlinedCordToSampledCord) {
251   CordzSampleToken token;
252   CordzSamplingIntervalHelper sample_every{1};
253   Cord cord(MakeString(TestCordSize::kLarge));
254   const CordzInfo* info = GetCordzInfoForTesting(cord);
255   Cord src = UnsampledCord(MakeString(TestCordSize::kInlined));
256   cord = src;
257   EXPECT_THAT(GetCordzInfoForTesting(cord), Eq(nullptr));
258   EXPECT_FALSE(CordzInfoIsListed(info));
259 }
260 
TEST(CordzUpdateTest,MoveAssignCord)261 TEST(CordzUpdateTest, MoveAssignCord) {
262   CordzSamplingIntervalHelper sample_every{1};
263   Cord cord;
264   Cord src(MakeString(TestCordSize::kLarge));
265   cord = std::move(src);
266   EXPECT_THAT(cord, HasValidCordzInfoOf(Method::kConstructorString));
267 }
268 
TEST_P(CordzUpdateTest,AssignLargeArray)269 TEST_P(CordzUpdateTest, AssignLargeArray) {
270   cord() = MakeString(TestCordSize::kSmall);
271   EXPECT_THAT(cord(), HasValidCordzInfoOf(Method::kAssignString));
272 }
273 
TEST_P(CordzUpdateTest,AssignSmallArray)274 TEST_P(CordzUpdateTest, AssignSmallArray) {
275   cord() = MakeString(TestCordSize::kSmall);
276   EXPECT_THAT(cord(), HasValidCordzInfoOf(Method::kAssignString));
277 }
278 
TEST_P(CordzUpdateTest,AssignInlinedArray)279 TEST_P(CordzUpdateTest, AssignInlinedArray) {
280   cord() = MakeString(TestCordSize::kInlined);
281   EXPECT_THAT(GetCordzInfoForTesting(cord()), Eq(nullptr));
282 }
283 
TEST_P(CordzStringTest,AssignStringToInlined)284 TEST_P(CordzStringTest, AssignStringToInlined) {
285   Cord cord;
286   cord = std::string(Length(GetParam()), '.');
287   if (Length(GetParam()) > kMaxInline) {
288     EXPECT_THAT(cord, HasValidCordzInfoOf(Method::kAssignString));
289   }
290 }
291 
TEST_P(CordzStringTest,AssignStringToCord)292 TEST_P(CordzStringTest, AssignStringToCord) {
293   Cord cord(MakeString(TestCordSize::kLarge));
294   cord = std::string(Length(GetParam()), '.');
295   if (Length(GetParam()) > kMaxInline) {
296     EXPECT_THAT(cord, HasValidCordzInfoOf(Method::kConstructorString));
297     EXPECT_THAT(cord, CordzMethodCountEq(Method::kAssignString, 1));
298   }
299 }
300 
TEST_P(CordzUpdateTest,AssignInlinedString)301 TEST_P(CordzUpdateTest, AssignInlinedString) {
302   cord() = std::string(Length(TestCordSize::kInlined), '.');
303   EXPECT_THAT(GetCordzInfoForTesting(cord()), Eq(nullptr));
304 }
305 
TEST_P(CordzUpdateTest,AppendCord)306 TEST_P(CordzUpdateTest, AppendCord) {
307   Cord src = UnsampledCord(MakeString(TestCordSize::kLarge));
308   cord().Append(src);
309   EXPECT_THAT(cord(), HasValidCordzInfoOf(InitialOr(Method::kAppendCord)));
310 }
311 
TEST_P(CordzUpdateTest,MoveAppendCord)312 TEST_P(CordzUpdateTest, MoveAppendCord) {
313   cord().Append(UnsampledCord(MakeString(TestCordSize::kLarge)));
314   EXPECT_THAT(cord(), HasValidCordzInfoOf(InitialOr(Method::kAppendCord)));
315 }
316 
TEST_P(CordzUpdateTest,AppendSmallArray)317 TEST_P(CordzUpdateTest, AppendSmallArray) {
318   cord().Append(MakeString(TestCordSize::kSmall));
319   EXPECT_THAT(cord(), HasValidCordzInfoOf(InitialOr(Method::kAppendString)));
320 }
321 
TEST_P(CordzUpdateTest,AppendLargeArray)322 TEST_P(CordzUpdateTest, AppendLargeArray) {
323   cord().Append(MakeString(TestCordSize::kLarge));
324   EXPECT_THAT(cord(), HasValidCordzInfoOf(InitialOr(Method::kAppendString)));
325 }
326 
TEST_P(CordzStringTest,AppendStringToEmpty)327 TEST_P(CordzStringTest, AppendStringToEmpty) {
328   Cord cord;
329   cord.Append(std::string(Length(GetParam()), '.'));
330   if (Length(GetParam()) > kMaxInline) {
331     EXPECT_THAT(cord, HasValidCordzInfoOf(Method::kAppendString));
332   }
333 }
334 
TEST_P(CordzStringTest,AppendStringToInlined)335 TEST_P(CordzStringTest, AppendStringToInlined) {
336   Cord cord(MakeString(TestCordSize::kInlined));
337   cord.Append(std::string(Length(GetParam()), '.'));
338   if (Length(TestCordSize::kInlined) + Length(GetParam()) > kMaxInline) {
339     EXPECT_THAT(cord, HasValidCordzInfoOf(Method::kAppendString));
340   }
341 }
342 
TEST_P(CordzStringTest,AppendStringToCord)343 TEST_P(CordzStringTest, AppendStringToCord) {
344   Cord cord(MakeString(TestCordSize::kLarge));
345   cord.Append(std::string(Length(GetParam()), '.'));
346   EXPECT_THAT(cord, HasValidCordzInfoOf(Method::kConstructorString));
347   EXPECT_THAT(cord, CordzMethodCountEq(Method::kAppendString, 1));
348 }
349 
TEST(CordzTest,MakeCordFromExternal)350 TEST(CordzTest, MakeCordFromExternal) {
351   CordzSamplingIntervalHelper sample_every{1};
352   Cord cord = MakeCordFromExternal("Hello world", [](absl::string_view) {});
353   EXPECT_THAT(cord, HasValidCordzInfoOf(Method::kMakeCordFromExternal));
354 }
355 
TEST(CordzTest,MakeCordFromEmptyExternal)356 TEST(CordzTest, MakeCordFromEmptyExternal) {
357   CordzSamplingIntervalHelper sample_every{1};
358   Cord cord = MakeCordFromExternal({}, [](absl::string_view) {});
359   EXPECT_THAT(GetCordzInfoForTesting(cord), Eq(nullptr));
360 }
361 
TEST_P(CordzUpdateTest,PrependCord)362 TEST_P(CordzUpdateTest, PrependCord) {
363   Cord src = UnsampledCord(MakeString(TestCordSize::kLarge));
364   cord().Prepend(src);
365   EXPECT_THAT(cord(), HasValidCordzInfoOf(InitialOr(Method::kPrependCord)));
366 }
367 
TEST_P(CordzUpdateTest,PrependSmallArray)368 TEST_P(CordzUpdateTest, PrependSmallArray) {
369   cord().Prepend(MakeString(TestCordSize::kSmall));
370   EXPECT_THAT(cord(), HasValidCordzInfoOf(InitialOr(Method::kPrependString)));
371 }
372 
TEST_P(CordzUpdateTest,PrependLargeArray)373 TEST_P(CordzUpdateTest, PrependLargeArray) {
374   cord().Prepend(MakeString(TestCordSize::kLarge));
375   EXPECT_THAT(cord(), HasValidCordzInfoOf(InitialOr(Method::kPrependString)));
376 }
377 
TEST_P(CordzStringTest,PrependStringToEmpty)378 TEST_P(CordzStringTest, PrependStringToEmpty) {
379   Cord cord;
380   cord.Prepend(std::string(Length(GetParam()), '.'));
381   if (Length(GetParam()) > kMaxInline) {
382     EXPECT_THAT(cord, HasValidCordzInfoOf(Method::kPrependString));
383   }
384 }
385 
TEST_P(CordzStringTest,PrependStringToInlined)386 TEST_P(CordzStringTest, PrependStringToInlined) {
387   Cord cord(MakeString(TestCordSize::kInlined));
388   cord.Prepend(std::string(Length(GetParam()), '.'));
389   if (Length(TestCordSize::kInlined) + Length(GetParam()) > kMaxInline) {
390     EXPECT_THAT(cord, HasValidCordzInfoOf(Method::kPrependString));
391   }
392 }
393 
TEST_P(CordzStringTest,PrependStringToCord)394 TEST_P(CordzStringTest, PrependStringToCord) {
395   Cord cord(MakeString(TestCordSize::kLarge));
396   cord.Prepend(std::string(Length(GetParam()), '.'));
397   EXPECT_THAT(cord, HasValidCordzInfoOf(Method::kConstructorString));
398   EXPECT_THAT(cord, CordzMethodCountEq(Method::kPrependString, 1));
399 }
400 
TEST(CordzTest,RemovePrefix)401 TEST(CordzTest, RemovePrefix) {
402   CordzSamplingIntervalHelper sample_every(1);
403   Cord cord(MakeString(TestCordSize::kLarge));
404 
405   // Half the cord
406   cord.RemovePrefix(cord.size() / 2);
407   EXPECT_THAT(cord, HasValidCordzInfoOf(Method::kConstructorString));
408   EXPECT_THAT(cord, CordzMethodCountEq(Method::kRemovePrefix, 1));
409 
410   // TODO(mvels): RemovePrefix does not reset to inlined, except if empty?
411   cord.RemovePrefix(cord.size() - kMaxInline);
412   EXPECT_THAT(cord, HasValidCordzInfoOf(Method::kConstructorString));
413   EXPECT_THAT(cord, CordzMethodCountEq(Method::kRemovePrefix, 2));
414 
415   cord.RemovePrefix(cord.size());
416   EXPECT_THAT(GetCordzInfoForTesting(cord), Eq(nullptr));
417 }
418 
TEST(CordzTest,RemoveSuffix)419 TEST(CordzTest, RemoveSuffix) {
420   CordzSamplingIntervalHelper sample_every(1);
421   Cord cord(MakeString(TestCordSize::kLarge));
422 
423   // Half the cord
424   cord.RemoveSuffix(cord.size() / 2);
425   EXPECT_THAT(cord, HasValidCordzInfoOf(Method::kConstructorString));
426   EXPECT_THAT(cord, CordzMethodCountEq(Method::kRemoveSuffix, 1));
427 
428   // TODO(mvels): RemoveSuffix does not reset to inlined, except if empty?
429   cord.RemoveSuffix(cord.size() - kMaxInline);
430   EXPECT_THAT(cord, HasValidCordzInfoOf(Method::kConstructorString));
431   EXPECT_THAT(cord, CordzMethodCountEq(Method::kRemoveSuffix, 2));
432 
433   cord.RemoveSuffix(cord.size());
434   EXPECT_THAT(GetCordzInfoForTesting(cord), Eq(nullptr));
435 }
436 
TEST(CordzTest,SubCordFromUnsampledCord)437 TEST(CordzTest, SubCordFromUnsampledCord) {
438   CordzSamplingIntervalHelper sample_every{1};
439   Cord src = UnsampledCord(MakeString(TestCordSize::kLarge));
440   Cord cord = src.Subcord(10, src.size() / 2);
441   EXPECT_THAT(GetCordzInfoForTesting(cord), Eq(nullptr));
442 }
443 
TEST(CordzTest,SubCordFromSampledCord)444 TEST(CordzTest, SubCordFromSampledCord) {
445   CordzSamplingIntervalHelper sample_never{99999};
446   Cord src = MakeAppendStringCord(TestCordSize::kLarge);
447   Cord cord = src.Subcord(10, src.size() / 2);
448   ASSERT_THAT(cord, HasValidCordzInfoOf(Method::kSubCord));
449   CordzStatistics stats = GetCordzInfoForTesting(cord)->GetCordzStatistics();
450   EXPECT_THAT(stats.parent_method, Eq(Method::kAppendString));
451   EXPECT_THAT(stats.update_tracker.Value(Method::kAppendString), Eq(1));
452 }
453 
TEST(CordzTest,SmallSubCord)454 TEST(CordzTest, SmallSubCord) {
455   CordzSamplingIntervalHelper sample_never{99999};
456   Cord src = MakeAppendStringCord(TestCordSize::kLarge);
457   Cord cord = src.Subcord(10, kMaxInline + 1);
458   EXPECT_THAT(cord, HasValidCordzInfoOf(Method::kSubCord));
459 }
460 
461 }  // namespace
462 
463 ABSL_NAMESPACE_END
464 }  // namespace absl
465 
466 #endif  // ABSL_INTERNAL_CORDZ_ENABLED
467