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