ipc/file_descriptor_set_posix_unittest.cc

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