1 // Copyright 2014 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 "mojo/system/raw_shared_buffer.h" 6 7 #include <limits> 8 9 #include "base/macros.h" 10 #include "base/memory/ref_counted.h" 11 #include "base/memory/scoped_ptr.h" 12 #include "testing/gtest/include/gtest/gtest.h" 13 14 namespace mojo { 15 namespace system { 16 namespace { 17 18 TEST(RawSharedBufferTest, Basic) { 19 const size_t kNumInts = 100; 20 const size_t kNumBytes = kNumInts * sizeof(int); 21 // A fudge so that we're not just writing zero bytes 75% of the time. 22 const int kFudge = 1234567890; 23 24 // Make some memory. 25 scoped_refptr<RawSharedBuffer> buffer(RawSharedBuffer::Create(kNumBytes)); 26 ASSERT_TRUE(buffer); 27 28 // Map it all, scribble some stuff, and then unmap it. 29 { 30 EXPECT_TRUE(buffer->IsValidMap(0, kNumBytes)); 31 scoped_ptr<RawSharedBufferMapping> mapping(buffer->Map(0, kNumBytes)); 32 ASSERT_TRUE(mapping); 33 ASSERT_TRUE(mapping->base()); 34 int* stuff = static_cast<int*>(mapping->base()); 35 for (size_t i = 0; i < kNumInts; i++) 36 stuff[i] = static_cast<int>(i) + kFudge; 37 } 38 39 // Map it all again, check that our scribbling is still there, then do a 40 // partial mapping and scribble on that, check that everything is coherent, 41 // unmap the first mapping, scribble on some of the second mapping, and then 42 // unmap it. 43 { 44 ASSERT_TRUE(buffer->IsValidMap(0, kNumBytes)); 45 // Use |MapNoCheck()| this time. 46 scoped_ptr<RawSharedBufferMapping> mapping1( 47 buffer->MapNoCheck(0, kNumBytes)); 48 ASSERT_TRUE(mapping1); 49 ASSERT_TRUE(mapping1->base()); 50 int* stuff1 = static_cast<int*>(mapping1->base()); 51 for (size_t i = 0; i < kNumInts; i++) 52 EXPECT_EQ(static_cast<int>(i) + kFudge, stuff1[i]) << i; 53 54 scoped_ptr<RawSharedBufferMapping> mapping2( 55 buffer->Map((kNumInts / 2) * sizeof(int), 2 * sizeof(int))); 56 ASSERT_TRUE(mapping2); 57 ASSERT_TRUE(mapping2->base()); 58 int* stuff2 = static_cast<int*>(mapping2->base()); 59 EXPECT_EQ(static_cast<int>(kNumInts / 2) + kFudge, stuff2[0]); 60 EXPECT_EQ(static_cast<int>(kNumInts / 2) + 1 + kFudge, stuff2[1]); 61 62 stuff2[0] = 123; 63 stuff2[1] = 456; 64 EXPECT_EQ(123, stuff1[kNumInts / 2]); 65 EXPECT_EQ(456, stuff1[kNumInts / 2 + 1]); 66 67 mapping1.reset(); 68 69 EXPECT_EQ(123, stuff2[0]); 70 EXPECT_EQ(456, stuff2[1]); 71 stuff2[1] = 789; 72 } 73 74 // Do another partial mapping and check that everything is the way we expect 75 // it to be. 76 { 77 EXPECT_TRUE(buffer->IsValidMap(sizeof(int), kNumBytes - sizeof(int))); 78 scoped_ptr<RawSharedBufferMapping> mapping( 79 buffer->Map(sizeof(int), kNumBytes - sizeof(int))); 80 ASSERT_TRUE(mapping); 81 ASSERT_TRUE(mapping->base()); 82 int* stuff = static_cast<int*>(mapping->base()); 83 84 for (size_t j = 0; j < kNumInts - 1; j++) { 85 int i = static_cast<int>(j) + 1; 86 if (i == kNumInts / 2) { 87 EXPECT_EQ(123, stuff[j]); 88 } else if (i == kNumInts / 2 + 1) { 89 EXPECT_EQ(789, stuff[j]); 90 } else { 91 EXPECT_EQ(i + kFudge, stuff[j]) << i; 92 } 93 } 94 } 95 } 96 97 // TODO(vtl): Bigger buffers. 98 99 TEST(RawSharedBufferTest, InvalidMappings) { 100 scoped_refptr<RawSharedBuffer> buffer(RawSharedBuffer::Create(100)); 101 ASSERT_TRUE(buffer); 102 103 // Zero length not allowed. 104 EXPECT_FALSE(buffer->Map(0, 0)); 105 EXPECT_FALSE(buffer->IsValidMap(0, 0)); 106 107 // Okay: 108 EXPECT_TRUE(buffer->Map(0, 100)); 109 EXPECT_TRUE(buffer->IsValidMap(0, 100)); 110 // Offset + length too big. 111 EXPECT_FALSE(buffer->Map(0, 101)); 112 EXPECT_FALSE(buffer->IsValidMap(0, 101)); 113 EXPECT_FALSE(buffer->Map(1, 100)); 114 EXPECT_FALSE(buffer->IsValidMap(1, 100)); 115 116 // Okay: 117 EXPECT_TRUE(buffer->Map(50, 50)); 118 EXPECT_TRUE(buffer->IsValidMap(50, 50)); 119 // Offset + length too big. 120 EXPECT_FALSE(buffer->Map(50, 51)); 121 EXPECT_FALSE(buffer->IsValidMap(50, 51)); 122 EXPECT_FALSE(buffer->Map(51, 50)); 123 EXPECT_FALSE(buffer->IsValidMap(51, 50)); 124 } 125 126 TEST(RawSharedBufferTest, TooBig) { 127 // If |size_t| is 32-bit, it's quite possible/likely that |Create()| succeeds 128 // (since it only involves creating a 4 GB file). 129 const size_t kMaxSizeT = std::numeric_limits<size_t>::max(); 130 scoped_refptr<RawSharedBuffer> buffer(RawSharedBuffer::Create(kMaxSizeT)); 131 // But, assuming |sizeof(size_t) == sizeof(void*)|, mapping all of it should 132 // always fail. 133 if (buffer) 134 EXPECT_FALSE(buffer->Map(0, kMaxSizeT)); 135 } 136 137 // Tests that separate mappings get distinct addresses. 138 // Note: It's not inconceivable that the OS could ref-count identical mappings 139 // and reuse the same address, in which case we'd have to be more careful about 140 // using the address as the key for unmapping. 141 TEST(RawSharedBufferTest, MappingsDistinct) { 142 scoped_refptr<RawSharedBuffer> buffer(RawSharedBuffer::Create(100)); 143 scoped_ptr<RawSharedBufferMapping> mapping1(buffer->Map(0, 100)); 144 scoped_ptr<RawSharedBufferMapping> mapping2(buffer->Map(0, 100)); 145 EXPECT_NE(mapping1->base(), mapping2->base()); 146 } 147 148 TEST(RawSharedBufferTest, BufferZeroInitialized) { 149 static const size_t kSizes[] = { 10, 100, 1000, 10000, 100000 }; 150 for (size_t i = 0; i < arraysize(kSizes); i++) { 151 scoped_refptr<RawSharedBuffer> buffer(RawSharedBuffer::Create(kSizes[i])); 152 scoped_ptr<RawSharedBufferMapping> mapping(buffer->Map(0, kSizes[i])); 153 for (size_t j = 0; j < kSizes[i]; j++) { 154 // "Assert" instead of "expect" so we don't spam the output with thousands 155 // of failures if we fail. 156 ASSERT_EQ('\0', static_cast<char*>(mapping->base())[j]) 157 << "size " << kSizes[i] << ", offset " << j; 158 } 159 } 160 } 161 162 TEST(RawSharedBufferTest, MappingsOutliveBuffer) { 163 scoped_ptr<RawSharedBufferMapping> mapping1; 164 scoped_ptr<RawSharedBufferMapping> mapping2; 165 166 { 167 scoped_refptr<RawSharedBuffer> buffer(RawSharedBuffer::Create(100)); 168 mapping1 = buffer->Map(0, 100).Pass(); 169 mapping2 = buffer->Map(50, 50).Pass(); 170 static_cast<char*>(mapping1->base())[50] = 'x'; 171 } 172 173 EXPECT_EQ('x', static_cast<char*>(mapping2->base())[0]); 174 175 static_cast<char*>(mapping2->base())[1] = 'y'; 176 EXPECT_EQ('y', static_cast<char*>(mapping1->base())[51]); 177 } 178 179 } // namespace 180 } // namespace system 181 } // namespace mojo 182
