mojo/edk/system/platform_handle_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/edk/system/platform_handle_dispatcher.h"
   6
   7 #include <stdio.h>
   8
   9 #include "base/files/file_path.h"
  10 #include "base/files/file_util.h"
  11 #include "base/files/scoped_file.h"
  12 #include "base/files/scoped_temp_dir.h"
  13 #include "base/memory/ref_counted.h"
  14 #include "mojo/edk/test/test_utils.h"
  15 #include "testing/gtest/include/gtest/gtest.h"
  16
  17 namespace mojo {
  18 namespace system {
  19 namespace {
  20
  21 TEST(PlatformHandleDispatcherTest, Basic) {
  22   base::ScopedTempDir temp_dir;
  23   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  24
  25   static const char kHelloWorld[] = "hello world";
  26
  27   base::FilePath unused;
  28   base::ScopedFILE fp(
  29       CreateAndOpenTemporaryFileInDir(temp_dir.path(), &unused));
  30   ASSERT_TRUE(fp);
  31   EXPECT_EQ(sizeof(kHelloWorld),
  32             fwrite(kHelloWorld, 1, sizeof(kHelloWorld), fp.get()));
  33
  34   embedder::ScopedPlatformHandle h(
  35       mojo::test::PlatformHandleFromFILE(fp.Pass()));
  36   EXPECT_FALSE(fp);
  37   ASSERT_TRUE(h.is_valid());
  38
  39   scoped_refptr<PlatformHandleDispatcher> dispatcher(
  40       new PlatformHandleDispatcher(h.Pass()));
  41   EXPECT_FALSE(h.is_valid());
  42   EXPECT_EQ(Dispatcher::kTypePlatformHandle, dispatcher->GetType());
  43
  44   h = dispatcher->PassPlatformHandle().Pass();
  45   EXPECT_TRUE(h.is_valid());
  46
  47   fp = mojo::test::FILEFromPlatformHandle(h.Pass(), "rb").Pass();
  48   EXPECT_FALSE(h.is_valid());
  49   EXPECT_TRUE(fp);
  50
  51   rewind(fp.get());
  52   char read_buffer[1000] = {};
  53   EXPECT_EQ(sizeof(kHelloWorld),
  54             fread(read_buffer, 1, sizeof(read_buffer), fp.get()));
  55   EXPECT_STREQ(kHelloWorld, read_buffer);
  56
  57   // Try getting the handle again. (It should fail cleanly.)
  58   h = dispatcher->PassPlatformHandle().Pass();
  59   EXPECT_FALSE(h.is_valid());
  60
  61   EXPECT_EQ(MOJO_RESULT_OK, dispatcher->Close());
  62 }
  63
  64 TEST(PlatformHandleDispatcherTest, CreateEquivalentDispatcherAndClose) {
  65   base::ScopedTempDir temp_dir;
  66   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
  67
  68   static const char kFooBar[] = "foo bar";
  69
  70   base::FilePath unused;
  71   base::ScopedFILE fp(
  72       CreateAndOpenTemporaryFileInDir(temp_dir.path(), &unused));
  73   EXPECT_EQ(sizeof(kFooBar), fwrite(kFooBar, 1, sizeof(kFooBar), fp.get()));
  74
  75   scoped_refptr<PlatformHandleDispatcher> dispatcher(
  76       new PlatformHandleDispatcher(
  77           mojo::test::PlatformHandleFromFILE(fp.Pass())));
  78
  79   DispatcherTransport transport(
  80       test::DispatcherTryStartTransport(dispatcher.get()));
  81   EXPECT_TRUE(transport.is_valid());
  82   EXPECT_EQ(Dispatcher::kTypePlatformHandle, transport.GetType());
  83   EXPECT_FALSE(transport.IsBusy());
  84
  85   scoped_refptr<Dispatcher> generic_dispatcher =
  86       transport.CreateEquivalentDispatcherAndClose();
  87   ASSERT_TRUE(generic_dispatcher);
  88
  89   transport.End();
  90   EXPECT_TRUE(dispatcher->HasOneRef());
  91   dispatcher = nullptr;
  92
  93   ASSERT_EQ(Dispatcher::kTypePlatformHandle, generic_dispatcher->GetType());
  94   dispatcher = static_cast<PlatformHandleDispatcher*>(generic_dispatcher.get());
  95
  96   fp = mojo::test::FILEFromPlatformHandle(dispatcher->PassPlatformHandle(),
  97                                           "rb").Pass();
  98   EXPECT_TRUE(fp);
  99
 100   rewind(fp.get());
 101   char read_buffer[1000] = {};
 102   EXPECT_EQ(sizeof(kFooBar),
 103             fread(read_buffer, 1, sizeof(read_buffer), fp.get()));
 104   EXPECT_STREQ(kFooBar, read_buffer);
 105
 106   EXPECT_EQ(MOJO_RESULT_OK, dispatcher->Close());
 107 }
 108
 109 }  // namespace
 110 }  // namespace system
 111 }  // namespace mojo