1 // Copyright 2017 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "quiche/common/platform/api/quiche_mem_slice.h"
6
7 #include <cstring>
8 #include <memory>
9
10 #include "absl/strings/string_view.h"
11 #include "quiche/common/platform/api/quiche_test.h"
12 #include "quiche/common/quiche_buffer_allocator.h"
13 #include "quiche/common/quiche_callbacks.h"
14 #include "quiche/common/simple_buffer_allocator.h"
15
16 namespace quiche {
17 namespace test {
18 namespace {
19
20 class QuicheMemSliceTest : public QuicheTest {
21 public:
QuicheMemSliceTest()22 QuicheMemSliceTest() {
23 size_t length = 1024;
24 slice_ = QuicheMemSlice(QuicheBuffer(&allocator_, length));
25 orig_data_ = slice_.data();
26 orig_length_ = slice_.length();
27 }
28
29 SimpleBufferAllocator allocator_;
30 QuicheMemSlice slice_;
31 const char* orig_data_;
32 size_t orig_length_;
33 };
34
TEST_F(QuicheMemSliceTest,MoveConstruct)35 TEST_F(QuicheMemSliceTest, MoveConstruct) {
36 QuicheMemSlice moved(std::move(slice_));
37 EXPECT_EQ(moved.data(), orig_data_);
38 EXPECT_EQ(moved.length(), orig_length_);
39 EXPECT_EQ(nullptr, slice_.data());
40 EXPECT_EQ(0u, slice_.length());
41 EXPECT_TRUE(slice_.empty());
42 }
43
TEST_F(QuicheMemSliceTest,MoveAssign)44 TEST_F(QuicheMemSliceTest, MoveAssign) {
45 QuicheMemSlice moved;
46 moved = std::move(slice_);
47 EXPECT_EQ(moved.data(), orig_data_);
48 EXPECT_EQ(moved.length(), orig_length_);
49 EXPECT_EQ(nullptr, slice_.data());
50 EXPECT_EQ(0u, slice_.length());
51 EXPECT_TRUE(slice_.empty());
52 }
53
TEST_F(QuicheMemSliceTest,MoveAssignNonEmpty)54 TEST_F(QuicheMemSliceTest, MoveAssignNonEmpty) {
55 const absl::string_view data("foo");
56 auto buffer = std::make_unique<char[]>(data.length());
57 std::memcpy(buffer.get(), data.data(), data.length());
58
59 QuicheMemSlice moved(std::move(buffer), data.length());
60 EXPECT_EQ(data, moved.AsStringView());
61
62 moved = std::move(slice_);
63 EXPECT_EQ(moved.data(), orig_data_);
64 EXPECT_EQ(moved.length(), orig_length_);
65 EXPECT_EQ(nullptr, slice_.data());
66 EXPECT_EQ(0u, slice_.length());
67 EXPECT_TRUE(slice_.empty());
68 }
69
TEST_F(QuicheMemSliceTest,SliceCustomDoneCallback)70 TEST_F(QuicheMemSliceTest, SliceCustomDoneCallback) {
71 const absl::string_view data("foo");
72 bool deleted = false;
73
74 char* buffer = new char[data.length()];
75 std::memcpy(buffer, data.data(), data.length());
76
77 {
78 QuicheMemSlice slice(buffer, data.length(), [&deleted](const char* data) {
79 deleted = true;
80 delete[] data;
81 });
82 EXPECT_EQ(data, slice.AsStringView());
83 }
84 EXPECT_TRUE(deleted);
85 }
86
TEST_F(QuicheMemSliceTest,Reset)87 TEST_F(QuicheMemSliceTest, Reset) {
88 EXPECT_EQ(slice_.data(), orig_data_);
89 EXPECT_EQ(slice_.length(), orig_length_);
90 EXPECT_FALSE(slice_.empty());
91
92 slice_.Reset();
93
94 EXPECT_EQ(slice_.length(), 0u);
95 EXPECT_TRUE(slice_.empty());
96 }
97
TEST_F(QuicheMemSliceTest,SliceAllocatedOnHeap)98 TEST_F(QuicheMemSliceTest, SliceAllocatedOnHeap) {
99 auto buffer = std::make_unique<char[]>(128);
100 char* orig_data = buffer.get();
101 size_t used_length = 105;
102 QuicheMemSlice slice = QuicheMemSlice(std::move(buffer), used_length);
103 QuicheMemSlice moved = std::move(slice);
104 EXPECT_EQ(moved.data(), orig_data);
105 EXPECT_EQ(moved.length(), used_length);
106 }
107
TEST_F(QuicheMemSliceTest,SliceFromBuffer)108 TEST_F(QuicheMemSliceTest, SliceFromBuffer) {
109 const absl::string_view kTestString =
110 "RFC 9000 Release Celebration Memorial Test String";
111 auto buffer = QuicheBuffer::Copy(&allocator_, kTestString);
112 QuicheMemSlice slice(std::move(buffer));
113
114 EXPECT_EQ(buffer.data(), nullptr); // NOLINT(bugprone-use-after-move)
115 EXPECT_EQ(buffer.size(), 0u);
116 EXPECT_EQ(slice.AsStringView(), kTestString);
117 EXPECT_EQ(slice.length(), kTestString.length());
118 }
119
120 } // namespace
121 } // namespace test
122 } // namespace quiche
123