1 // Copyright 2019 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 "platform/impl/tls_write_buffer.h"
6
7 #include <algorithm>
8
9 #include "gmock/gmock.h"
10 #include "gtest/gtest.h"
11
12 namespace openscreen {
13 namespace {
14
TEST(TlsWriteBufferTest,CheckBasicFunctionality)15 TEST(TlsWriteBufferTest, CheckBasicFunctionality) {
16 TlsWriteBuffer buffer;
17 constexpr size_t write_size = TlsWriteBuffer::kBufferSizeBytes / 2;
18 uint8_t write_buffer[write_size];
19 std::fill_n(write_buffer, write_size, uint8_t{1});
20
21 EXPECT_TRUE(buffer.Push(write_buffer, write_size));
22
23 absl::Span<const uint8_t> readable_data = buffer.GetReadableRegion();
24 ASSERT_EQ(readable_data.size(), write_size);
25 for (size_t i = 0; i < readable_data.size(); i++) {
26 EXPECT_EQ(readable_data[i], 1);
27 }
28
29 buffer.Consume(write_size / 2);
30
31 readable_data = buffer.GetReadableRegion();
32 ASSERT_EQ(readable_data.size(), write_size / 2);
33 for (size_t i = 0; i < readable_data.size(); i++) {
34 EXPECT_EQ(readable_data[i], 1);
35 }
36
37 buffer.Consume(write_size / 2);
38
39 readable_data = buffer.GetReadableRegion();
40 ASSERT_EQ(readable_data.size(), size_t{0});
41
42 // Test that the entire buffer can be used.
43 EXPECT_TRUE(buffer.Push(write_buffer, write_size));
44 EXPECT_TRUE(buffer.Push(write_buffer, write_size));
45 // The buffer should be 100% full at this point. Confirm that no more can be
46 // written.
47 EXPECT_FALSE(buffer.Push(write_buffer, write_size));
48 EXPECT_FALSE(buffer.Push(write_buffer, 1));
49 }
50
TEST(TlsWriteBufferTest,TestWrapAround)51 TEST(TlsWriteBufferTest, TestWrapAround) {
52 TlsWriteBuffer buffer;
53 constexpr size_t buffer_size = TlsWriteBuffer::kBufferSizeBytes;
54 uint8_t write_buffer[buffer_size];
55 std::fill_n(write_buffer, buffer_size, uint8_t{1});
56
57 constexpr size_t partial_buffer_size = buffer_size * 3 / 4;
58 EXPECT_TRUE(buffer.Push(write_buffer, partial_buffer_size));
59 // Buffer contents should now be: |111111111111····|
60 auto region = buffer.GetReadableRegion();
61 auto* const buffer_begin = region.data();
62 ASSERT_TRUE(buffer_begin);
63 EXPECT_EQ(region.size(), partial_buffer_size);
64 EXPECT_TRUE(std::all_of(region.begin(), region.end(),
65 [](uint8_t byte) { return byte == 1; }));
66
67 buffer.Consume(buffer_size / 2);
68 // Buffer contents should now be: |········1111····|
69 region = buffer.GetReadableRegion();
70 EXPECT_EQ(region.data(), buffer_begin + buffer_size / 2);
71 EXPECT_EQ(region.size(), buffer_size / 4);
72 EXPECT_TRUE(std::all_of(region.begin(), region.end(),
73 [](uint8_t byte) { return byte == 1; }));
74
75 std::fill_n(write_buffer, buffer_size, uint8_t{2});
76 EXPECT_TRUE(buffer.Push(write_buffer, buffer_size / 2));
77 // Buffer contents should now be: |2222····11112222|
78 // Readable region should just be the end part.
79 region = buffer.GetReadableRegion();
80 EXPECT_EQ(region.data(), buffer_begin + buffer_size / 2);
81 EXPECT_EQ(region.size(), buffer_size / 2);
82 EXPECT_TRUE(std::all_of(region.begin(), region.begin() + buffer_size / 4,
83 [](uint8_t byte) { return byte == 1; }));
84 EXPECT_TRUE(std::all_of(region.begin() + buffer_size / 4, region.end(),
85 [](uint8_t byte) { return byte == 2; }));
86
87 buffer.Consume(buffer_size / 2);
88 // Buffer contents should now be: |2222············|
89 region = buffer.GetReadableRegion();
90 EXPECT_EQ(region.data(), buffer_begin);
91 EXPECT_EQ(region.size(), buffer_size / 4);
92 EXPECT_TRUE(std::all_of(region.begin(), region.end(),
93 [](uint8_t byte) { return byte == 2; }));
94
95 std::fill_n(write_buffer, buffer_size, uint8_t{3});
96 // The following Push() fails (not enough room).
97 EXPECT_FALSE(buffer.Push(write_buffer, buffer_size));
98 // Buffer contents should still be: |2222············|
99 EXPECT_TRUE(buffer.Push(write_buffer, buffer_size * 3 / 4));
100 // Buffer contents should now be: |2222333333333333|
101 EXPECT_FALSE(buffer.Push(write_buffer, buffer_size)); // Not enough room.
102 EXPECT_FALSE(buffer.Push(write_buffer, 1)); // Not enough room.
103 region = buffer.GetReadableRegion();
104 EXPECT_EQ(region.data(), buffer_begin);
105 EXPECT_EQ(region.size(), buffer_size);
106 EXPECT_TRUE(std::all_of(region.begin(), region.begin() + buffer_size / 4,
107 [](uint8_t byte) { return byte == 2; }));
108 EXPECT_TRUE(std::all_of(region.begin() + buffer_size / 4, region.end(),
109 [](uint8_t byte) { return byte == 3; }));
110
111 buffer.Consume(buffer_size);
112 // Buffer contents should now be: |················|
113 EXPECT_TRUE(buffer.GetReadableRegion().empty());
114 }
115
116 } // namespace
117 } // namespace openscreen
118