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 #include "base/basictypes.h" 6 #include "base/environment.h" 7 #include "base/logging.h" 8 #include "base/memory/scoped_ptr.h" 9 #include "base/process/kill.h" 10 #include "base/rand_util.h" 11 #include "base/strings/stringprintf.h" 12 #include "base/test/multiprocess_test.h" 13 #include "base/time/time.h" 14 #include "chrome/common/multi_process_lock.h" 15 #include "testing/multiprocess_func_list.h" 16 17 class MultiProcessLockTest : public base::MultiProcessTest { 18 public: 19 static const char kLockEnviromentVarName[]; 20 21 class ScopedEnvironmentVariable { 22 public: 23 ScopedEnvironmentVariable(const std::string &name, 24 const std::string &value) 25 : name_(name), environment_(base::Environment::Create()) { 26 environment_->SetVar(name_.c_str(), value); 27 } 28 ~ScopedEnvironmentVariable() { 29 environment_->UnSetVar(name_.c_str()); 30 } 31 32 private: 33 std::string name_; 34 scoped_ptr<base::Environment> environment_; 35 DISALLOW_COPY_AND_ASSIGN(ScopedEnvironmentVariable); 36 }; 37 38 std::string GenerateLockName(); 39 void ExpectLockIsLocked(const std::string &name); 40 void ExpectLockIsUnlocked(const std::string &name); 41 }; 42 43 const char MultiProcessLockTest::kLockEnviromentVarName[] 44 = "MULTI_PROCESS_TEST_LOCK_NAME"; 45 46 std::string MultiProcessLockTest::GenerateLockName() { 47 base::Time now = base::Time::NowFromSystemTime(); 48 return base::StringPrintf("multi_process_test_lock %lf%lf", 49 now.ToDoubleT(), base::RandDouble()); 50 } 51 52 void MultiProcessLockTest::ExpectLockIsLocked(const std::string &name) { 53 ScopedEnvironmentVariable var(kLockEnviromentVarName, name); 54 base::ProcessHandle handle = SpawnChild("MultiProcessLockTryFailMain"); 55 ASSERT_TRUE(handle); 56 int exit_code = 0; 57 EXPECT_TRUE(base::WaitForExitCode(handle, &exit_code)); 58 EXPECT_EQ(exit_code, 0); 59 } 60 61 void MultiProcessLockTest::ExpectLockIsUnlocked( 62 const std::string &name) { 63 ScopedEnvironmentVariable var(kLockEnviromentVarName, name); 64 base::ProcessHandle handle = SpawnChild("MultiProcessLockTrySucceedMain"); 65 ASSERT_TRUE(handle); 66 int exit_code = 0; 67 EXPECT_TRUE(base::WaitForExitCode(handle, &exit_code)); 68 EXPECT_EQ(exit_code, 0); 69 } 70 71 TEST_F(MultiProcessLockTest, BasicCreationTest) { 72 // Test basic creation/destruction with no lock taken 73 std::string name = GenerateLockName(); 74 scoped_ptr<MultiProcessLock> scoped(MultiProcessLock::Create(name)); 75 ExpectLockIsUnlocked(name); 76 scoped.reset(NULL); 77 } 78 79 TEST_F(MultiProcessLockTest, LongNameTest) { 80 // Every platform has has it's own max path name size, 81 // so different checks are needed for them. 82 // POSIX: sizeof(address.sun_path) - 2 83 // Mac OS X: BOOTSTRAP_MAX_NAME_LEN 84 // Windows: MAX_PATH 85 LOG(INFO) << "Following error log due to long name is expected"; 86 #if defined(OS_MACOSX) 87 std::string name("This is a name that is longer than one hundred and " 88 "twenty-eight characters to make sure that we fail appropriately on " 89 "Mac OS X when we have a path that is too long for Mac OS X to handle"); 90 #elif defined(OS_POSIX) 91 std::string name("This is a name that is longer than one hundred and eight " 92 "characters to make sure that we fail appropriately on POSIX systems " 93 "when we have a path that is too long for the system to handle"); 94 #elif defined(OS_WIN) 95 std::string name("This is a name that is longer than two hundred and sixty " 96 "characters to make sure that we fail appropriately on Windows when we " 97 "have a path that is too long for Windows to handle " 98 "This limitation comes from the MAX_PATH definition which is obviously " 99 "defined to be a maximum of two hundred and sixty characters "); 100 #endif 101 scoped_ptr<MultiProcessLock> test_lock(MultiProcessLock::Create(name)); 102 EXPECT_FALSE(test_lock->TryLock()); 103 } 104 105 TEST_F(MultiProcessLockTest, SimpleLock) { 106 std::string name = GenerateLockName(); 107 scoped_ptr<MultiProcessLock> test_lock(MultiProcessLock::Create(name)); 108 EXPECT_TRUE(test_lock->TryLock()); 109 ExpectLockIsLocked(name); 110 test_lock->Unlock(); 111 ExpectLockIsUnlocked(name); 112 } 113 114 TEST_F(MultiProcessLockTest, RecursiveLock) { 115 std::string name = GenerateLockName(); 116 scoped_ptr<MultiProcessLock> test_lock(MultiProcessLock::Create(name)); 117 EXPECT_TRUE(test_lock->TryLock()); 118 ExpectLockIsLocked(name); 119 LOG(INFO) << "Following error log " 120 << "'MultiProcessLock is already locked' is expected"; 121 EXPECT_TRUE(test_lock->TryLock()); 122 ExpectLockIsLocked(name); 123 test_lock->Unlock(); 124 ExpectLockIsUnlocked(name); 125 LOG(INFO) << "Following error log " 126 << "'Over-unlocked MultiProcessLock' is expected"; 127 test_lock->Unlock(); 128 ExpectLockIsUnlocked(name); 129 test_lock.reset(); 130 } 131 132 TEST_F(MultiProcessLockTest, LockScope) { 133 // Check to see that lock is released when it goes out of scope. 134 std::string name = GenerateLockName(); 135 { 136 scoped_ptr<MultiProcessLock> test_lock(MultiProcessLock::Create(name)); 137 EXPECT_TRUE(test_lock->TryLock()); 138 ExpectLockIsLocked(name); 139 } 140 ExpectLockIsUnlocked(name); 141 } 142 143 MULTIPROCESS_TEST_MAIN(MultiProcessLockTryFailMain) { 144 std::string name; 145 scoped_ptr<base::Environment> environment(base::Environment::Create()); 146 EXPECT_TRUE(environment->GetVar(MultiProcessLockTest::kLockEnviromentVarName, 147 &name)); 148 #if defined(OS_MACOSX) 149 // OS X sends out a log if a lock fails. 150 // Hopefully this will keep people from panicking about it when they 151 // are perusing the build logs. 152 LOG(INFO) << "Following error log " 153 << "\"CFMessagePort: bootstrap_register(): failed 1100 (0x44c) " 154 << "'Permission denied'\" is expected"; 155 #endif // defined(OS_MACOSX) 156 scoped_ptr<MultiProcessLock> test_lock( 157 MultiProcessLock::Create(name)); 158 EXPECT_FALSE(test_lock->TryLock()); 159 return 0; 160 } 161 162 MULTIPROCESS_TEST_MAIN(MultiProcessLockTrySucceedMain) { 163 std::string name; 164 scoped_ptr<base::Environment> environment(base::Environment::Create()); 165 EXPECT_TRUE(environment->GetVar(MultiProcessLockTest::kLockEnviromentVarName, 166 &name)); 167 scoped_ptr<MultiProcessLock> test_lock( 168 MultiProcessLock::Create(name)); 169 EXPECT_TRUE(test_lock->TryLock()); 170 return 0; 171 } 172