1 // Copyright 2019 Google Inc.
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 // http://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 ///////////////////////////////////////////////////////////////////////////////
16
17 #include "tink/util/buffer.h"
18
19 #include <cstring>
20 #include <utility>
21
22 #include "gtest/gtest.h"
23 #include "absl/memory/memory.h"
24 #include "absl/status/status.h"
25 #include "absl/strings/str_cat.h"
26 #include "tink/subtle/random.h"
27 #include "tink/util/status.h"
28 #include "tink/util/test_matchers.h"
29
30 namespace crypto {
31 namespace tink {
32 namespace util {
33 namespace {
34
35 using ::crypto::tink::test::IsOk;
36 using ::crypto::tink::test::StatusIs;
37 using testing::HasSubstr;
38
TEST(BufferTest,ExternalMemoryBlock)39 TEST(BufferTest, ExternalMemoryBlock) {
40 for (auto buf_size : {1, 10, 100, 1000, 10000, 100000, 1000000}) {
41 SCOPED_TRACE(absl::StrCat("buf_size = ", buf_size));
42 auto mem_block = absl::make_unique<char[]>(buf_size);
43 auto buf_result = Buffer::NewNonOwning(mem_block.get(), buf_size);
44 ASSERT_THAT(buf_result, IsOk());
45 auto buf = std::move(buf_result.value());
46 EXPECT_EQ(buf_size, buf->size());
47 EXPECT_EQ(buf_size, buf->allocated_size());
48 EXPECT_EQ(mem_block.get(), buf->get_mem_block());
49 for (auto new_size : {0, 1, buf_size/2, buf_size}) {
50 SCOPED_TRACE(absl::StrCat("new_size = ", buf_size));
51 ASSERT_THAT(buf->set_size(new_size), IsOk());
52 EXPECT_EQ(new_size, buf->size());
53 EXPECT_EQ(buf_size, buf->allocated_size());
54 EXPECT_EQ(mem_block.get(), buf->get_mem_block());
55 auto data = subtle::Random::GetRandomBytes(new_size);
56 std::memcpy(buf->get_mem_block(), data.data(), new_size);
57 EXPECT_EQ(0, std::memcmp(data.data(), buf->get_mem_block(), new_size));
58 }
59 }
60 }
61
TEST(BufferTest,InternalMemoryBlock)62 TEST(BufferTest, InternalMemoryBlock) {
63 for (auto buf_size : {1, 10, 100, 1000, 10000, 100000, 1000000}) {
64 SCOPED_TRACE(absl::StrCat("buf_size = ", buf_size));
65 auto buf_result = Buffer::New(buf_size);
66 ASSERT_THAT(buf_result, IsOk());
67 auto buf = std::move(buf_result.value());
68 EXPECT_EQ(buf_size, buf->size());
69 EXPECT_EQ(buf_size, buf->allocated_size());
70 for (auto new_size : {0, 1, buf_size/2, buf_size}) {
71 SCOPED_TRACE(absl::StrCat("new_size = ", buf_size));
72 ASSERT_THAT(buf->set_size(new_size), IsOk());
73 EXPECT_EQ(new_size, buf->size());
74 EXPECT_EQ(buf_size, buf->allocated_size());
75 auto data = subtle::Random::GetRandomBytes(new_size);
76 std::memcpy(buf->get_mem_block(), data.data(), new_size);
77 EXPECT_EQ(0, std::memcmp(data.data(), buf->get_mem_block(), new_size));
78 }
79 }
80 }
81
TEST(BufferTest,NullMemoryBlock)82 TEST(BufferTest, NullMemoryBlock) {
83 auto buf_result = Buffer::NewNonOwning(nullptr, 42);
84 EXPECT_THAT(buf_result.status(), StatusIs(absl::StatusCode::kInvalidArgument,
85 HasSubstr("non-null")));
86 }
87
TEST(BufferTest,BadAllocatedSize_ExternalMemoryBlock)88 TEST(BufferTest, BadAllocatedSize_ExternalMemoryBlock) {
89 for (auto allocated_size : {-10, -1, 0}) {
90 SCOPED_TRACE(absl::StrCat("allocated_size = ", allocated_size));
91 auto mem_block = absl::make_unique<char[]>(42);
92 auto buf_result = Buffer::NewNonOwning(mem_block.get(), allocated_size);
93 EXPECT_THAT(buf_result.status(),
94 StatusIs(absl::StatusCode::kInvalidArgument,
95 HasSubstr("allocated_size")));
96 }
97 }
98
TEST(BufferTest,BadAllocatedSize_InternalMemoryBlock)99 TEST(BufferTest, BadAllocatedSize_InternalMemoryBlock) {
100 for (auto allocated_size : {-10, -1, 0}) {
101 SCOPED_TRACE(absl::StrCat("allocated_size = ", allocated_size));
102 auto buf_result = Buffer::New(allocated_size);
103 EXPECT_THAT(buf_result.status(),
104 StatusIs(absl::StatusCode::kInvalidArgument,
105 HasSubstr("allocated_size")));
106 }
107 }
108
TEST(BufferTest,BadNewSize_ExternalMemoryBlock)109 TEST(BufferTest, BadNewSize_ExternalMemoryBlock) {
110 for (auto buf_size : {1, 10, 100, 1000, 10000}) {
111 SCOPED_TRACE(absl::StrCat("buf_size = ", buf_size));
112 auto buf = std::move(Buffer::New(buf_size).value());
113 for (auto new_size : {-10, -1, buf_size + 1, 2 * buf_size}) {
114 SCOPED_TRACE(absl::StrCat("new_size = ", buf_size));
115 EXPECT_THAT(buf->set_size(new_size),
116 StatusIs(absl::StatusCode::kInvalidArgument,
117 HasSubstr("new_size must satisfy")));
118 }
119 }
120 }
121
TEST(BufferTest,BadNewSize_InternalMemoryBlock)122 TEST(BufferTest, BadNewSize_InternalMemoryBlock) {
123 for (auto buf_size : {1, 10, 100, 1000, 10000}) {
124 SCOPED_TRACE(absl::StrCat("buf_size = ", buf_size));
125 auto mem_block = absl::make_unique<char[]>(buf_size);
126 auto buf =
127 std::move(Buffer::NewNonOwning(mem_block.get(), buf_size).value());
128 for (auto new_size : {-10, -1, buf_size + 1, 2 * buf_size}) {
129 SCOPED_TRACE(absl::StrCat("new_size = ", buf_size));
130 EXPECT_THAT(buf->set_size(new_size),
131 StatusIs(absl::StatusCode::kInvalidArgument,
132 HasSubstr("new_size must satisfy")));
133 }
134 }
135 }
136
137 } // namespace
138 } // namespace util
139 } // namespace tink
140 } // namespace crypto
141