src/mojo/public/tests/system_core_unittest.cc

   1 // Copyright 2013 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/public/system/core.h"
   6
   7 #include <string.h>
   8
   9 #include "mojo/public/tests/test_support.h"
  10 #include "testing/gtest/include/gtest/gtest.h"
  11
  12 namespace mojo {
  13 namespace {
  14
  15 class SystemTest : public test::TestBase {
  16 };
  17
  18 TEST_F(SystemTest, Basic) {
  19   Handle h_0;
  20   MojoWaitFlags wf;
  21   char buffer[10] = { 0 };
  22   uint32_t buffer_size;
  23
  24   // The only handle that's guaranteed to be invalid is |kInvalidHandle|.
  25   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, Close(kInvalidHandle));
  26   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
  27             Wait(kInvalidHandle, MOJO_WAIT_FLAG_EVERYTHING, 1000000));
  28   h_0 = kInvalidHandle;
  29   wf = MOJO_WAIT_FLAG_EVERYTHING;
  30   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
  31             WaitMany(&h_0, &wf, 1, MOJO_DEADLINE_INDEFINITE));
  32   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
  33             WriteMessage(h_0,
  34                          buffer, 3,
  35                          NULL, 0,
  36                          MOJO_WRITE_MESSAGE_FLAG_NONE));
  37   buffer_size = static_cast<uint32_t>(sizeof(buffer));
  38   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
  39             ReadMessage(h_0,
  40                         buffer, &buffer_size,
  41                         NULL, NULL,
  42                         MOJO_READ_MESSAGE_FLAG_NONE));
  43
  44   Handle h_1;
  45   EXPECT_EQ(MOJO_RESULT_OK, CreateMessagePipe(&h_0, &h_1));
  46
  47   // Shouldn't be readable.
  48   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED,
  49             Wait(h_0, MOJO_WAIT_FLAG_READABLE, 0));
  50
  51   // Should be writable.
  52   EXPECT_EQ(MOJO_RESULT_OK,
  53             Wait(h_0, MOJO_WAIT_FLAG_WRITABLE, 0));
  54
  55   // Try to read.
  56   EXPECT_EQ(MOJO_RESULT_NOT_FOUND,
  57             ReadMessage(h_0,
  58                         buffer, &buffer_size,
  59                         NULL, NULL,
  60                         MOJO_READ_MESSAGE_FLAG_NONE));
  61
  62   // Write to |h_1|.
  63   static const char hello[] = "hello";
  64   memcpy(buffer, hello, sizeof(hello));
  65   buffer_size = static_cast<uint32_t>(sizeof(hello));
  66   EXPECT_EQ(MOJO_RESULT_OK,
  67             WriteMessage(h_1,
  68                          hello, buffer_size,
  69                          NULL, 0,
  70                          MOJO_WRITE_MESSAGE_FLAG_NONE));
  71
  72   // |h_0| should be readable.
  73   wf = MOJO_WAIT_FLAG_READABLE;
  74   EXPECT_EQ(MOJO_RESULT_OK,
  75             WaitMany(&h_0, &wf, 1, MOJO_DEADLINE_INDEFINITE));
  76
  77   // Read from |h_0|.
  78   memset(buffer, 0, sizeof(buffer));
  79   buffer_size = static_cast<uint32_t>(sizeof(buffer));
  80   EXPECT_EQ(MOJO_RESULT_OK,
  81             ReadMessage(h_0,
  82                         buffer, &buffer_size,
  83                         NULL, NULL,
  84                         MOJO_READ_MESSAGE_FLAG_NONE));
  85   EXPECT_EQ(static_cast<uint32_t>(sizeof(hello)), buffer_size);
  86   EXPECT_EQ(0, memcmp(hello, buffer, sizeof(hello)));
  87
  88   // |h_0| should no longer be readable.
  89   EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED,
  90             Wait(h_0, MOJO_WAIT_FLAG_READABLE, 10));
  91
  92   // Close |h_0|.
  93   EXPECT_EQ(MOJO_RESULT_OK, Close(h_0));
  94
  95   // |h_1| should no longer be readable or writable.
  96   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
  97             Wait(h_1, MOJO_WAIT_FLAG_READABLE | MOJO_WAIT_FLAG_WRITABLE, 1000));
  98
  99   EXPECT_EQ(MOJO_RESULT_OK, Close(h_1));
 100 }
 101
 102 // TODO(vtl): Add multi-threaded tests.
 103
 104 }  // namespace
 105 }  // namespace mojo