src/mojo/system/shared_buffer_dispatcher_unittest.cc

   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/shared_buffer_dispatcher.h"
   6
   7 #include <limits>
   8
   9 #include "base/memory/ref_counted.h"
  10 #include "mojo/system/dispatcher.h"
  11 #include "mojo/system/raw_shared_buffer.h"
  12 #include "testing/gtest/include/gtest/gtest.h"
  13
  14 namespace mojo {
  15 namespace system {
  16 namespace {
  17
  18 // NOTE(vtl): There's currently not much to test for in
  19 // |SharedBufferDispatcher::ValidateOptions()|, but the tests should be expanded
  20 // if/when options are added, so I've kept the general form of the tests from
  21 // data_pipe_unittest.cc.
  22
  23 const uint32_t kSizeOfOptions =
  24     static_cast<uint32_t>(sizeof(MojoCreateSharedBufferOptions));
  25
  26 // Does a cursory sanity check of |validated_options|. Calls |ValidateOptions()|
  27 // on already-validated options. The validated options should be valid, and the
  28 // revalidated copy should be the same.
  29 void RevalidateOptions(const MojoCreateSharedBufferOptions& validated_options) {
  30   EXPECT_EQ(kSizeOfOptions, validated_options.struct_size);
  31   // Nothing to check for flags.
  32
  33   MojoCreateSharedBufferOptions revalidated_options = { 0 };
  34   EXPECT_EQ(MOJO_RESULT_OK,
  35             SharedBufferDispatcher::ValidateOptions(&validated_options,
  36                                                     &revalidated_options));
  37   EXPECT_EQ(validated_options.struct_size, revalidated_options.struct_size);
  38   EXPECT_EQ(validated_options.flags, revalidated_options.flags);
  39 }
  40
  41 // Tests valid inputs to |ValidateOptions()|.
  42 TEST(SharedBufferDispatcherTest, ValidateOptionsValidInputs) {
  43   // Default options.
  44   {
  45     MojoCreateSharedBufferOptions validated_options = { 0 };
  46     EXPECT_EQ(MOJO_RESULT_OK,
  47               SharedBufferDispatcher::ValidateOptions(NULL,
  48                                                       &validated_options));
  49     RevalidateOptions(validated_options);
  50   }
  51
  52   // Different flags.
  53   MojoCreateSharedBufferOptionsFlags flags_values[] = {
  54     MOJO_CREATE_SHARED_BUFFER_OPTIONS_FLAG_NONE
  55   };
  56   for (size_t i = 0; i < arraysize(flags_values); i++) {
  57     const MojoCreateSharedBufferOptionsFlags flags = flags_values[i];
  58
  59     // Different capacities (size 1).
  60     for (uint32_t capacity = 1; capacity <= 100 * 1000 * 1000; capacity *= 10) {
  61       MojoCreateSharedBufferOptions options = {
  62         kSizeOfOptions,  // |struct_size|.
  63         flags  // |flags|.
  64       };
  65       MojoCreateSharedBufferOptions validated_options = { 0 };
  66       EXPECT_EQ(MOJO_RESULT_OK,
  67                 SharedBufferDispatcher::ValidateOptions(&options,
  68                                                         &validated_options))
  69           << capacity;
  70       RevalidateOptions(validated_options);
  71     }
  72   }
  73 }
  74
  75 TEST(SharedBufferDispatcherTest, ValidateOptionsInvalidInputs) {
  76   // Invalid |struct_size|.
  77   // Note: If/when we extend |MojoCreateSharedBufferOptions|, this will have to
  78   // be updated.
  79   for (uint32_t struct_size = 0; struct_size < kSizeOfOptions; struct_size++) {
  80     MojoCreateSharedBufferOptions options = {
  81       struct_size,  // |struct_size|.
  82       MOJO_CREATE_SHARED_BUFFER_OPTIONS_FLAG_NONE  // |flags|.
  83     };
  84     MojoCreateSharedBufferOptions unused = { 0 };
  85     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
  86               SharedBufferDispatcher::ValidateOptions(&options, &unused));
  87   }
  88 }
  89
  90 TEST(SharedBufferDispatcherTest, CreateAndMapBuffer) {
  91   MojoCreateSharedBufferOptions validated_options = { 0 };
  92   EXPECT_EQ(MOJO_RESULT_OK,
  93             SharedBufferDispatcher::ValidateOptions(NULL,
  94                                                     &validated_options));
  95
  96   scoped_refptr<SharedBufferDispatcher> dispatcher;
  97   EXPECT_EQ(MOJO_RESULT_OK,
  98             SharedBufferDispatcher::Create(validated_options, 100,
  99                                            &dispatcher));
 100   ASSERT_TRUE(dispatcher);
 101   EXPECT_EQ(Dispatcher::kTypeSharedBuffer, dispatcher->GetType());
 102
 103   // Make a couple of mappings.
 104   scoped_ptr<RawSharedBufferMapping> mapping1;
 105   EXPECT_EQ(MOJO_RESULT_OK,
 106             dispatcher->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE,
 107                                   &mapping1));
 108   ASSERT_TRUE(mapping1);
 109   ASSERT_TRUE(mapping1->base());
 110   EXPECT_EQ(100u, mapping1->length());
 111   // Write something.
 112   static_cast<char*>(mapping1->base())[50] = 'x';
 113
 114   scoped_ptr<RawSharedBufferMapping> mapping2;
 115   EXPECT_EQ(MOJO_RESULT_OK,
 116             dispatcher->MapBuffer(50, 50, MOJO_MAP_BUFFER_FLAG_NONE,
 117                                   &mapping2));
 118   ASSERT_TRUE(mapping2);
 119   ASSERT_TRUE(mapping2->base());
 120   EXPECT_EQ(50u, mapping2->length());
 121   EXPECT_EQ('x', static_cast<char*>(mapping2->base())[0]);
 122
 123   EXPECT_EQ(MOJO_RESULT_OK, dispatcher->Close());
 124
 125   // Check that we can still read/write to mappings after the dispatcher has
 126   // gone away.
 127   static_cast<char*>(mapping2->base())[1] = 'y';
 128   EXPECT_EQ('y', static_cast<char*>(mapping1->base())[51]);
 129 }
 130
 131 TEST(SharedBufferDispatcher, DuplicateBufferHandle) {
 132   MojoCreateSharedBufferOptions validated_options = { 0 };
 133   EXPECT_EQ(MOJO_RESULT_OK,
 134             SharedBufferDispatcher::ValidateOptions(NULL,
 135                                                     &validated_options));
 136
 137   scoped_refptr<SharedBufferDispatcher> dispatcher1;
 138   EXPECT_EQ(MOJO_RESULT_OK,
 139             SharedBufferDispatcher::Create(validated_options, 100,
 140                                            &dispatcher1));
 141
 142   // Map and write something.
 143   scoped_ptr<RawSharedBufferMapping> mapping;
 144   EXPECT_EQ(MOJO_RESULT_OK,
 145             dispatcher1->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE,
 146                                    &mapping));
 147   static_cast<char*>(mapping->base())[0] = 'x';
 148   mapping.reset();
 149
 150   // Duplicate |dispatcher1| and then close it.
 151   scoped_refptr<Dispatcher> dispatcher2;
 152   EXPECT_EQ(MOJO_RESULT_OK,
 153             dispatcher1->DuplicateBufferHandle(NULL, &dispatcher2));
 154   ASSERT_TRUE(dispatcher2);
 155   EXPECT_EQ(Dispatcher::kTypeSharedBuffer, dispatcher2->GetType());
 156
 157   EXPECT_EQ(MOJO_RESULT_OK, dispatcher1->Close());
 158
 159   // Map |dispatcher2| and read something.
 160   EXPECT_EQ(MOJO_RESULT_OK,
 161             dispatcher2->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE,
 162                                    &mapping));
 163   EXPECT_EQ('x', static_cast<char*>(mapping->base())[0]);
 164
 165   EXPECT_EQ(MOJO_RESULT_OK, dispatcher2->Close());
 166 }
 167
 168 // TODO(vtl): Test |DuplicateBufferHandle()| with non-null (valid) |options|.
 169
 170 TEST(SharedBufferDispatcherTest, CreateInvalidNumBytes) {
 171   MojoCreateSharedBufferOptions validated_options = { 0 };
 172   EXPECT_EQ(MOJO_RESULT_OK,
 173             SharedBufferDispatcher::ValidateOptions(NULL,
 174                                                     &validated_options));
 175
 176   // Size too big.
 177   scoped_refptr<SharedBufferDispatcher> dispatcher;
 178   EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
 179             SharedBufferDispatcher::Create(validated_options,
 180                                            std::numeric_limits<uint64_t>::max(),
 181                                            &dispatcher));
 182   EXPECT_FALSE(dispatcher);
 183
 184   // Zero size.
 185   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 186             SharedBufferDispatcher::Create(validated_options, 0, &dispatcher));
 187   EXPECT_FALSE(dispatcher);
 188 }
 189
 190 TEST(SharedBufferDispatcherTest, MapBufferInvalidArguments) {
 191   MojoCreateSharedBufferOptions validated_options = { 0 };
 192   EXPECT_EQ(MOJO_RESULT_OK,
 193             SharedBufferDispatcher::ValidateOptions(NULL,
 194                                                     &validated_options));
 195
 196   scoped_refptr<SharedBufferDispatcher> dispatcher;
 197   EXPECT_EQ(MOJO_RESULT_OK,
 198             SharedBufferDispatcher::Create(validated_options, 100,
 199                                            &dispatcher));
 200
 201   scoped_ptr<RawSharedBufferMapping> mapping;
 202   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 203             dispatcher->MapBuffer(0, 101, MOJO_MAP_BUFFER_FLAG_NONE, &mapping));
 204   EXPECT_FALSE(mapping);
 205
 206   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 207             dispatcher->MapBuffer(1, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping));
 208   EXPECT_FALSE(mapping);
 209
 210   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
 211             dispatcher->MapBuffer(0, 0, MOJO_MAP_BUFFER_FLAG_NONE, &mapping));
 212   EXPECT_FALSE(mapping);
 213
 214   EXPECT_EQ(MOJO_RESULT_OK, dispatcher->Close());
 215 }
 216
 217 // TODO(vtl): Test |DuplicateBufferHandle()| with invalid |options|.
 218
 219 }  // namespace
 220 }  // namespace system
 221 }  // namespace mojo
 222