ipc/ipc_message_attachment_set_posix_unittest.cc

   1 // Copyright (c) 2011 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 // This test is POSIX only.
   6
   7 #include "ipc/ipc_message_attachment_set.h"
   8
   9 #include <fcntl.h>
  10 #include <unistd.h>
  11
  12 #include "base/basictypes.h"
  13 #include "base/posix/eintr_wrapper.h"
  14 #include "ipc/ipc_platform_file_attachment_posix.h"
  15 #include "testing/gtest/include/gtest/gtest.h"
  16
  17 namespace IPC {
  18 namespace {
  19
  20 // Get a safe file descriptor for test purposes.
  21 int GetSafeFd() {
  22   return open("/dev/null", O_RDONLY);
  23 }
  24
  25 // Returns true if fd was already closed.  Closes fd if not closed.
  26 bool VerifyClosed(int fd) {
  27   const int duped = dup(fd);
  28   if (duped != -1) {
  29     EXPECT_NE(IGNORE_EINTR(close(duped)), -1);
  30     EXPECT_NE(IGNORE_EINTR(close(fd)), -1);
  31     return false;
  32   }
  33   return true;
  34 }
  35
  36 // The MessageAttachmentSet will try and close some of the descriptor numbers
  37 // which we given it. This is the base descriptor value. It's great enough such
  38 // that no real descriptor will accidently be closed.
  39 static const int kFDBase = 50000;
  40
  41 TEST(MessageAttachmentSet, BasicAdd) {
  42   scoped_refptr<MessageAttachmentSet> set(new MessageAttachmentSet);
  43
  44   ASSERT_EQ(set->size(), 0u);
  45   ASSERT_TRUE(set->empty());
  46   ASSERT_TRUE(
  47       set->AddAttachment(new internal::PlatformFileAttachment(kFDBase)));
  48   ASSERT_EQ(set->size(), 1u);
  49   ASSERT_TRUE(!set->empty());
  50
  51   // Empties the set and stops a warning about deleting a set with unconsumed
  52   // descriptors
  53   set->CommitAll();
  54 }
  55
  56 TEST(MessageAttachmentSet, BasicAddAndClose) {
  57   scoped_refptr<MessageAttachmentSet> set(new MessageAttachmentSet);
  58
  59   ASSERT_EQ(set->size(), 0u);
  60   ASSERT_TRUE(set->empty());
  61   const int fd = GetSafeFd();
  62   ASSERT_TRUE(set->AddAttachment(
  63       new internal::PlatformFileAttachment(base::ScopedFD(fd))));
  64   ASSERT_EQ(set->size(), 1u);
  65   ASSERT_TRUE(!set->empty());
  66
  67   set->CommitAll();
  68
  69   ASSERT_TRUE(VerifyClosed(fd));
  70 }
  71 TEST(MessageAttachmentSet, MaxSize) {
  72   scoped_refptr<MessageAttachmentSet> set(new MessageAttachmentSet);
  73
  74   for (size_t i = 0; i < MessageAttachmentSet::kMaxDescriptorsPerMessage; ++i)
  75     ASSERT_TRUE(set->AddAttachment(
  76         new internal::PlatformFileAttachment(kFDBase + 1 + i)));
  77
  78   ASSERT_TRUE(
  79       !set->AddAttachment(new internal::PlatformFileAttachment(kFDBase)));
  80
  81   set->CommitAll();
  82 }
  83
  84 TEST(MessageAttachmentSet, SetDescriptors) {
  85   scoped_refptr<MessageAttachmentSet> set(new MessageAttachmentSet);
  86
  87   ASSERT_TRUE(set->empty());
  88   set->AddDescriptorsToOwn(NULL, 0);
  89   ASSERT_TRUE(set->empty());
  90
  91   const int fd = GetSafeFd();
  92   static const int fds[] = {fd};
  93   set->AddDescriptorsToOwn(fds, 1);
  94   ASSERT_TRUE(!set->empty());
  95   ASSERT_EQ(set->size(), 1u);
  96
  97   set->CommitAll();
  98
  99   ASSERT_TRUE(VerifyClosed(fd));
 100 }
 101
 102 TEST(MessageAttachmentSet, PeekDescriptors) {
 103   scoped_refptr<MessageAttachmentSet> set(new MessageAttachmentSet);
 104
 105   set->PeekDescriptors(NULL);
 106   ASSERT_TRUE(
 107       set->AddAttachment(new internal::PlatformFileAttachment(kFDBase)));
 108
 109   int fds[1];
 110   fds[0] = 0;
 111   set->PeekDescriptors(fds);
 112   ASSERT_EQ(fds[0], kFDBase);
 113   set->CommitAll();
 114   ASSERT_TRUE(set->empty());
 115 }
 116
 117 TEST(MessageAttachmentSet, WalkInOrder) {
 118   scoped_refptr<MessageAttachmentSet> set(new MessageAttachmentSet);
 119
 120   // TODO(morrita): This test is wrong. TakeDescriptorAt() shouldn't be
 121   // used to retrieve borrowed descriptors. That never happens in production.
 122   ASSERT_TRUE(
 123       set->AddAttachment(new internal::PlatformFileAttachment(kFDBase)));
 124   ASSERT_TRUE(
 125       set->AddAttachment(new internal::PlatformFileAttachment(kFDBase + 1)));
 126   ASSERT_TRUE(
 127       set->AddAttachment(new internal::PlatformFileAttachment(kFDBase + 2)));
 128
 129   ASSERT_EQ(set->GetAttachmentAt(0)->TakePlatformFile(), kFDBase);
 130   ASSERT_EQ(set->GetAttachmentAt(1)->TakePlatformFile(), kFDBase + 1);
 131   ASSERT_EQ(set->GetAttachmentAt(2)->TakePlatformFile(), kFDBase + 2);
 132
 133   set->CommitAll();
 134 }
 135
 136 TEST(MessageAttachmentSet, WalkWrongOrder) {
 137   scoped_refptr<MessageAttachmentSet> set(new MessageAttachmentSet);
 138
 139   // TODO(morrita): This test is wrong. TakeDescriptorAt() shouldn't be
 140   // used to retrieve borrowed descriptors. That never happens in production.
 141   ASSERT_TRUE(
 142       set->AddAttachment(new internal::PlatformFileAttachment(kFDBase)));
 143   ASSERT_TRUE(
 144       set->AddAttachment(new internal::PlatformFileAttachment(kFDBase + 1)));
 145   ASSERT_TRUE(
 146       set->AddAttachment(new internal::PlatformFileAttachment(kFDBase + 2)));
 147
 148   ASSERT_EQ(set->GetAttachmentAt(0)->TakePlatformFile(), kFDBase);
 149   ASSERT_EQ(set->GetAttachmentAt(2), nullptr);
 150
 151   set->CommitAll();
 152 }
 153
 154 TEST(MessageAttachmentSet, WalkCycle) {
 155   scoped_refptr<MessageAttachmentSet> set(new MessageAttachmentSet);
 156
 157   // TODO(morrita): This test is wrong. TakeDescriptorAt() shouldn't be
 158   // used to retrieve borrowed descriptors. That never happens in production.
 159   ASSERT_TRUE(
 160       set->AddAttachment(new internal::PlatformFileAttachment(kFDBase)));
 161   ASSERT_TRUE(
 162       set->AddAttachment(new internal::PlatformFileAttachment(kFDBase + 1)));
 163   ASSERT_TRUE(
 164       set->AddAttachment(new internal::PlatformFileAttachment(kFDBase + 2)));
 165
 166   ASSERT_EQ(set->GetAttachmentAt(0)->TakePlatformFile(), kFDBase);
 167   ASSERT_EQ(set->GetAttachmentAt(1)->TakePlatformFile(), kFDBase + 1);
 168   ASSERT_EQ(set->GetAttachmentAt(2)->TakePlatformFile(), kFDBase + 2);
 169   ASSERT_EQ(set->GetAttachmentAt(0)->TakePlatformFile(), kFDBase);
 170   ASSERT_EQ(set->GetAttachmentAt(1)->TakePlatformFile(), kFDBase + 1);
 171   ASSERT_EQ(set->GetAttachmentAt(2)->TakePlatformFile(), kFDBase + 2);
 172   ASSERT_EQ(set->GetAttachmentAt(0)->TakePlatformFile(), kFDBase);
 173   ASSERT_EQ(set->GetAttachmentAt(1)->TakePlatformFile(), kFDBase + 1);
 174   ASSERT_EQ(set->GetAttachmentAt(2)->TakePlatformFile(), kFDBase + 2);
 175
 176   set->CommitAll();
 177 }
 178
 179 TEST(MessageAttachmentSet, DontClose) {
 180   scoped_refptr<MessageAttachmentSet> set(new MessageAttachmentSet);
 181
 182   const int fd = GetSafeFd();
 183   ASSERT_TRUE(set->AddAttachment(new internal::PlatformFileAttachment(fd)));
 184   set->CommitAll();
 185
 186   ASSERT_FALSE(VerifyClosed(fd));
 187 }
 188
 189 TEST(MessageAttachmentSet, DoClose) {
 190   scoped_refptr<MessageAttachmentSet> set(new MessageAttachmentSet);
 191
 192   const int fd = GetSafeFd();
 193   ASSERT_TRUE(set->AddAttachment(
 194       new internal::PlatformFileAttachment(base::ScopedFD(fd))));
 195   set->CommitAll();
 196
 197   ASSERT_TRUE(VerifyClosed(fd));
 198 }
 199
 200 }  // namespace
 201 }  // namespace IPC