base/shared_memory_unittest.cc - platform/external/libchrome - Gitiles

 // Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "base/basictypes.h"
 #include "base/multiprocess_test.h"
 #include "base/platform_thread.h"
 #include "base/scoped_nsautorelease_pool.h"
 #include "base/shared_memory.h"
 #include "base/scoped_ptr.h"
 #include "testing/gtest/include/gtest/gtest.h"

 static const int kNumThreads = 5;
 static const int kNumTasks = 5;

 namespace base {

 namespace {

 // Each thread will open the shared memory.  Each thread will take a different 4
 // byte int pointer, and keep changing it, with some small pauses in between.
 // Verify that each thread's value in the shared memory is always correct.
 class MultipleThreadMain : public PlatformThread::Delegate {
  public:
   explicit MultipleThreadMain(int16 id) : id_(id) {}
   ~MultipleThreadMain() {}

   static void CleanUp() {
     SharedMemory memory;
     memory.Delete(s_test_name_);
   }

   // PlatformThread::Delegate interface.
   void ThreadMain() {
     ScopedNSAutoreleasePool pool;  // noop if not OSX
     const uint32 kDataSize = 1024;
     SharedMemory memory;
     bool rv = memory.Create(s_test_name_, false, true, kDataSize);
     EXPECT_TRUE(rv);
     rv = memory.Map(kDataSize);
     EXPECT_TRUE(rv);
     int *ptr = static_cast<int*>(memory.memory()) + id_;
     EXPECT_EQ(*ptr, 0);

     for (int idx = 0; idx < 100; idx++) {
       *ptr = idx;
       PlatformThread::Sleep(1);  // Short wait.
       EXPECT_EQ(*ptr, idx);
     }

     memory.Close();
   }

  private:
   int16 id_;

   static const wchar_t* const s_test_name_;

   DISALLOW_COPY_AND_ASSIGN(MultipleThreadMain);
 };

 const wchar_t* const MultipleThreadMain::s_test_name_ =
     L"SharedMemoryOpenThreadTest";

 // TODO(port):
 // This test requires the ability to pass file descriptors between processes.
 // We haven't done that yet in Chrome for POSIX.
 #if defined(OS_WIN)
 // Each thread will open the shared memory.  Each thread will take the memory,
 // and keep changing it while trying to lock it, with some small pauses in
 // between. Verify that each thread's value in the shared memory is always
 // correct.
 class MultipleLockThread : public PlatformThread::Delegate {
  public:
   explicit MultipleLockThread(int id) : id_(id) {}
   ~MultipleLockThread() {}

   // PlatformThread::Delegate interface.
   void ThreadMain() {
     const uint32 kDataSize = sizeof(int);
     SharedMemoryHandle handle = NULL;
     {
       SharedMemory memory1;
       EXPECT_TRUE(memory1.Create(L"SharedMemoryMultipleLockThreadTest",
                                  false, true, kDataSize));
       EXPECT_TRUE(memory1.ShareToProcess(GetCurrentProcess(), &handle));
       // TODO(paulg): Implement this once we have a posix version of
       // SharedMemory::ShareToProcess.
       EXPECT_TRUE(true);
     }

     SharedMemory memory2(handle, false);
     EXPECT_TRUE(memory2.Map(kDataSize));
     volatile int* const ptr = static_cast<int*>(memory2.memory());

     for (int idx = 0; idx < 20; idx++) {
       memory2.Lock();
       int i = (id_ << 16) + idx;
       *ptr = i;
       PlatformThread::Sleep(1);  // Short wait.
       EXPECT_EQ(*ptr, i);
       memory2.Unlock();
     }

     memory2.Close();
   }

  private:
   int id_;

   DISALLOW_COPY_AND_ASSIGN(MultipleLockThread);
 };
 #endif

 }  // namespace

 TEST(SharedMemoryTest, OpenClose) {
   const uint32 kDataSize = 1024;
   std::wstring test_name = L"SharedMemoryOpenCloseTest";

   // Open two handles to a memory segment, confirm that they are mapped
   // separately yet point to the same space.
   SharedMemory memory1;
   bool rv = memory1.Delete(test_name);
   EXPECT_TRUE(rv);
   rv = memory1.Delete(test_name);
   EXPECT_TRUE(rv);
   rv = memory1.Open(test_name, false);
   EXPECT_FALSE(rv);
   rv = memory1.Create(test_name, false, false, kDataSize);
   EXPECT_TRUE(rv);
   rv = memory1.Map(kDataSize);
   EXPECT_TRUE(rv);
   SharedMemory memory2;
   rv = memory2.Open(test_name, false);
   EXPECT_TRUE(rv);
   rv = memory2.Map(kDataSize);
   EXPECT_TRUE(rv);
   EXPECT_NE(memory1.memory(), memory2.memory());  // Compare the pointers.

   // Make sure we don't segfault. (it actually happened!)
   ASSERT_NE(memory1.memory(), static_cast<void*>(NULL));
   ASSERT_NE(memory2.memory(), static_cast<void*>(NULL));

   // Write data to the first memory segment, verify contents of second.
   memset(memory1.memory(), '1', kDataSize);
   EXPECT_EQ(memcmp(memory1.memory(), memory2.memory(), kDataSize), 0);

   // Close the first memory segment, and verify the second has the right data.
   memory1.Close();
   char *start_ptr = static_cast<char *>(memory2.memory());
   char *end_ptr = start_ptr + kDataSize;
   for (char* ptr = start_ptr; ptr < end_ptr; ptr++)
     EXPECT_EQ(*ptr, '1');

   // Close the second memory segment.
   memory2.Close();

   rv = memory1.Delete(test_name);
   EXPECT_TRUE(rv);
   rv = memory2.Delete(test_name);
   EXPECT_TRUE(rv);
 }

 // Create a set of N threads to each open a shared memory segment and write to
 // it. Verify that they are always reading/writing consistent data.
 TEST(SharedMemoryTest, MultipleThreads) {
   MultipleThreadMain::CleanUp();
   // On POSIX we have a problem when 2 threads try to create the shmem
   // (a file) at exactly the same time, since create both creates the
   // file and zerofills it.  We solve the problem for this unit test
   // (make it not flaky) by starting with 1 thread, then
   // intentionally don't clean up its shmem before running with
   // kNumThreads.

   int threadcounts[] = { 1, kNumThreads };
   for (size_t i = 0; i < sizeof(threadcounts) / sizeof(threadcounts); i++) {
     int numthreads = threadcounts[i];
     scoped_array<PlatformThreadHandle> thread_handles;
     scoped_array<MultipleThreadMain*> thread_delegates;

     thread_handles.reset(new PlatformThreadHandle[numthreads]);
     thread_delegates.reset(new MultipleThreadMain*[numthreads]);

     // Spawn the threads.
     for (int16 index = 0; index < numthreads; index++) {
       PlatformThreadHandle pth;
       thread_delegates[index] = new MultipleThreadMain(index);
       EXPECT_TRUE(PlatformThread::Create(0, thread_delegates[index], &pth));
       thread_handles[index] = pth;
     }

     // Wait for the threads to finish.
     for (int index = 0; index < numthreads; index++) {
       PlatformThread::Join(thread_handles[index]);
       delete thread_delegates[index];
     }
   }
   MultipleThreadMain::CleanUp();
 }

 // TODO(port): this test requires the MultipleLockThread class
 // (defined above), which requires the ability to pass file
 // descriptors between processes.  We haven't done that yet in Chrome
 // for POSIX.
 #if defined(OS_WIN)
 // Create a set of threads to each open a shared memory segment and write to it
 // with the lock held. Verify that they are always reading/writing consistent
 // data.
 TEST(SharedMemoryTest, Lock) {
   PlatformThreadHandle thread_handles[kNumThreads];
   MultipleLockThread* thread_delegates[kNumThreads];

   // Spawn the threads.
   for (int index = 0; index < kNumThreads; ++index) {
     PlatformThreadHandle pth;
     thread_delegates[index] = new MultipleLockThread(index);
     EXPECT_TRUE(PlatformThread::Create(0, thread_delegates[index], &pth));
     thread_handles[index] = pth;
   }

   // Wait for the threads to finish.
   for (int index = 0; index < kNumThreads; ++index) {
     PlatformThread::Join(thread_handles[index]);
     delete thread_delegates[index];
   }
 }
 #endif

 // Allocate private (unique) shared memory with an empty string for a
 // name.  Make sure several of them don't point to the same thing as
 // we might expect if the names are equal.
 TEST(SharedMemoryTest, AnonymousPrivate) {
   int i, j;
   int count = 4;
   bool rv;
   const uint32 kDataSize = 8192;

   scoped_array<SharedMemory> memories(new SharedMemory[count]);
   scoped_array<int*> pointers(new int*[count]);
   ASSERT_TRUE(memories.get());
   ASSERT_TRUE(pointers.get());

   for (i = 0; i < count; i++) {
     rv = memories[i].Create(L"", false, true, kDataSize);
     EXPECT_TRUE(rv);
     rv = memories[i].Map(kDataSize);
     EXPECT_TRUE(rv);
     int *ptr = static_cast<int*>(memories[i].memory());
     EXPECT_TRUE(ptr);
     pointers[i] = ptr;
   }

   for (i = 0; i < count; i++) {
     // zero out the first int in each except for i; for that one, make it 100.
     for (j = 0; j < count; j++) {
       if (i == j)
         pointers[j][0] = 100;
       else
         pointers[j][0] = 0;
     }
     // make sure there is no bleeding of the 100 into the other pointers
     for (j = 0; j < count; j++) {
       if (i == j)
         EXPECT_EQ(100, pointers[j][0]);
       else
         EXPECT_EQ(0, pointers[j][0]);
     }
   }

   for (int i = 0; i < count; i++) {
     memories[i].Close();
   }

 }


 // On POSIX it is especially important we test shmem across processes,
 // not just across threads.  But the test is enabled on all platforms.
 class SharedMemoryProcessTest : public MultiProcessTest {
  public:

   static void CleanUp() {
     SharedMemory memory;
     memory.Delete(s_test_name_);
   }

   static int TaskTestMain() {
     int errors = 0;
     ScopedNSAutoreleasePool pool;  // noop if not OSX
     const uint32 kDataSize = 1024;
     SharedMemory memory;
     bool rv = memory.Create(s_test_name_, false, true, kDataSize);
     EXPECT_TRUE(rv);
     if (rv != true)
       errors++;
     rv = memory.Map(kDataSize);
     EXPECT_TRUE(rv);
     if (rv != true)
       errors++;
     int *ptr = static_cast<int*>(memory.memory());

     for (int idx = 0; idx < 20; idx++) {
       memory.Lock();
       int i = (1 << 16) + idx;
       *ptr = i;
       PlatformThread::Sleep(10);  // Short wait.
       if (*ptr != i)
         errors++;
       memory.Unlock();
     }

     memory.Close();
     return errors;
   }

  private:
   static const wchar_t* const s_test_name_;
 };

 const wchar_t* const SharedMemoryProcessTest::s_test_name_ = L"MPMem";


 TEST_F(SharedMemoryProcessTest, Tasks) {
   SharedMemoryProcessTest::CleanUp();

   base::ProcessHandle handles[kNumTasks];
   for (int index = 0; index < kNumTasks; ++index) {
     handles[index] = SpawnChild(L"SharedMemoryTestMain");
   }

   int exit_code = 0;
   for (int index = 0; index < kNumTasks; ++index) {
     EXPECT_TRUE(base::WaitForExitCode(handles[index], &exit_code));
     EXPECT_TRUE(exit_code == 0);
   }

   SharedMemoryProcessTest::CleanUp();
 }

 MULTIPROCESS_TEST_MAIN(SharedMemoryTestMain) {
   return SharedMemoryProcessTest::TaskTestMain();
 }


 }  // namespace base
	// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "base/basictypes.h"
	#include "base/multiprocess_test.h"
	#include "base/platform_thread.h"
	#include "base/scoped_nsautorelease_pool.h"
	#include "base/shared_memory.h"
	#include "base/scoped_ptr.h"
	#include "testing/gtest/include/gtest/gtest.h"

	static const int kNumThreads = 5;
	static const int kNumTasks = 5;

	namespace base {

	namespace {

	// Each thread will open the shared memory. Each thread will take a different 4
	// byte int pointer, and keep changing it, with some small pauses in between.
	// Verify that each thread's value in the shared memory is always correct.
	class MultipleThreadMain : public PlatformThread::Delegate {
	public:
	explicit MultipleThreadMain(int16 id) : id_(id) {}
	~MultipleThreadMain() {}

	static void CleanUp() {
	SharedMemory memory;
	memory.Delete(s_test_name_);
	}

	// PlatformThread::Delegate interface.
	void ThreadMain() {
	ScopedNSAutoreleasePool pool; // noop if not OSX
	const uint32 kDataSize = 1024;
	SharedMemory memory;
	bool rv = memory.Create(s_test_name_, false, true, kDataSize);
	EXPECT_TRUE(rv);
	rv = memory.Map(kDataSize);
	EXPECT_TRUE(rv);
	int ptr = static_cast<int>(memory.memory()) + id_;
	EXPECT_EQ(*ptr, 0);

	for (int idx = 0; idx < 100; idx++) {
	*ptr = idx;
	PlatformThread::Sleep(1); // Short wait.
	EXPECT_EQ(*ptr, idx);
	}

	memory.Close();
	}

	private:
	int16 id_;

	static const wchar_t* const s_test_name_;

	DISALLOW_COPY_AND_ASSIGN(MultipleThreadMain);
	};

	const wchar_t* const MultipleThreadMain::s_test_name_ =
	L"SharedMemoryOpenThreadTest";

	// TODO(port):
	// This test requires the ability to pass file descriptors between processes.
	// We haven't done that yet in Chrome for POSIX.
	#if defined(OS_WIN)
	// Each thread will open the shared memory. Each thread will take the memory,
	// and keep changing it while trying to lock it, with some small pauses in
	// between. Verify that each thread's value in the shared memory is always
	// correct.
	class MultipleLockThread : public PlatformThread::Delegate {
	public:
	explicit MultipleLockThread(int id) : id_(id) {}
	~MultipleLockThread() {}

	// PlatformThread::Delegate interface.
	void ThreadMain() {
	const uint32 kDataSize = sizeof(int);
	SharedMemoryHandle handle = NULL;
	{
	SharedMemory memory1;
	EXPECT_TRUE(memory1.Create(L"SharedMemoryMultipleLockThreadTest",
	false, true, kDataSize));
	EXPECT_TRUE(memory1.ShareToProcess(GetCurrentProcess(), &handle));
	// TODO(paulg): Implement this once we have a posix version of
	// SharedMemory::ShareToProcess.
	EXPECT_TRUE(true);
	}

	SharedMemory memory2(handle, false);
	EXPECT_TRUE(memory2.Map(kDataSize));
	volatile int* const ptr = static_cast<int*>(memory2.memory());

	for (int idx = 0; idx < 20; idx++) {
	memory2.Lock();
	int i = (id_ << 16) + idx;
	*ptr = i;
	PlatformThread::Sleep(1); // Short wait.
	EXPECT_EQ(*ptr, i);
	memory2.Unlock();
	}

	memory2.Close();
	}

	private:
	int id_;

	DISALLOW_COPY_AND_ASSIGN(MultipleLockThread);
	};
	#endif

	} // namespace

	TEST(SharedMemoryTest, OpenClose) {
	const uint32 kDataSize = 1024;
	std::wstring test_name = L"SharedMemoryOpenCloseTest";

	// Open two handles to a memory segment, confirm that they are mapped
	// separately yet point to the same space.
	SharedMemory memory1;
	bool rv = memory1.Delete(test_name);
	EXPECT_TRUE(rv);
	rv = memory1.Delete(test_name);
	EXPECT_TRUE(rv);
	rv = memory1.Open(test_name, false);
	EXPECT_FALSE(rv);
	rv = memory1.Create(test_name, false, false, kDataSize);
	EXPECT_TRUE(rv);
	rv = memory1.Map(kDataSize);
	EXPECT_TRUE(rv);
	SharedMemory memory2;
	rv = memory2.Open(test_name, false);
	EXPECT_TRUE(rv);
	rv = memory2.Map(kDataSize);
	EXPECT_TRUE(rv);
	EXPECT_NE(memory1.memory(), memory2.memory()); // Compare the pointers.

	// Make sure we don't segfault. (it actually happened!)
	ASSERT_NE(memory1.memory(), static_cast<void*>(NULL));
	ASSERT_NE(memory2.memory(), static_cast<void*>(NULL));

	// Write data to the first memory segment, verify contents of second.
	memset(memory1.memory(), '1', kDataSize);
	EXPECT_EQ(memcmp(memory1.memory(), memory2.memory(), kDataSize), 0);

	// Close the first memory segment, and verify the second has the right data.
	memory1.Close();
	char start_ptr = static_cast<char >(memory2.memory());
	char *end_ptr = start_ptr + kDataSize;
	for (char* ptr = start_ptr; ptr < end_ptr; ptr++)
	EXPECT_EQ(*ptr, '1');

	// Close the second memory segment.
	memory2.Close();

	rv = memory1.Delete(test_name);
	EXPECT_TRUE(rv);
	rv = memory2.Delete(test_name);
	EXPECT_TRUE(rv);
	}

	// Create a set of N threads to each open a shared memory segment and write to
	// it. Verify that they are always reading/writing consistent data.
	TEST(SharedMemoryTest, MultipleThreads) {
	MultipleThreadMain::CleanUp();
	// On POSIX we have a problem when 2 threads try to create the shmem
	// (a file) at exactly the same time, since create both creates the
	// file and zerofills it. We solve the problem for this unit test
	// (make it not flaky) by starting with 1 thread, then
	// intentionally don't clean up its shmem before running with
	// kNumThreads.

	int threadcounts[] = { 1, kNumThreads };
	for (size_t i = 0; i < sizeof(threadcounts) / sizeof(threadcounts); i++) {
	int numthreads = threadcounts[i];
	scoped_array<PlatformThreadHandle> thread_handles;
	scoped_array<MultipleThreadMain*> thread_delegates;

	thread_handles.reset(new PlatformThreadHandle[numthreads]);
	thread_delegates.reset(new MultipleThreadMain*[numthreads]);

	// Spawn the threads.
	for (int16 index = 0; index < numthreads; index++) {
	PlatformThreadHandle pth;
	thread_delegates[index] = new MultipleThreadMain(index);
	EXPECT_TRUE(PlatformThread::Create(0, thread_delegates[index], &pth));
	thread_handles[index] = pth;
	}

	// Wait for the threads to finish.
	for (int index = 0; index < numthreads; index++) {
	PlatformThread::Join(thread_handles[index]);
	delete thread_delegates[index];
	}
	}
	MultipleThreadMain::CleanUp();
	}

	// TODO(port): this test requires the MultipleLockThread class
	// (defined above), which requires the ability to pass file
	// descriptors between processes. We haven't done that yet in Chrome
	// for POSIX.
	#if defined(OS_WIN)
	// Create a set of threads to each open a shared memory segment and write to it
	// with the lock held. Verify that they are always reading/writing consistent
	// data.
	TEST(SharedMemoryTest, Lock) {
	PlatformThreadHandle thread_handles[kNumThreads];
	MultipleLockThread* thread_delegates[kNumThreads];

	// Spawn the threads.
	for (int index = 0; index < kNumThreads; ++index) {
	PlatformThreadHandle pth;
	thread_delegates[index] = new MultipleLockThread(index);
	EXPECT_TRUE(PlatformThread::Create(0, thread_delegates[index], &pth));
	thread_handles[index] = pth;
	}

	// Wait for the threads to finish.
	for (int index = 0; index < kNumThreads; ++index) {
	PlatformThread::Join(thread_handles[index]);
	delete thread_delegates[index];
	}
	}
	#endif

	// Allocate private (unique) shared memory with an empty string for a
	// name. Make sure several of them don't point to the same thing as
	// we might expect if the names are equal.
	TEST(SharedMemoryTest, AnonymousPrivate) {
	int i, j;
	int count = 4;
	bool rv;
	const uint32 kDataSize = 8192;

	scoped_array<SharedMemory> memories(new SharedMemory[count]);
	scoped_array<int> pointers(new int[count]);
	ASSERT_TRUE(memories.get());
	ASSERT_TRUE(pointers.get());

	for (i = 0; i < count; i++) {
	rv = memories[i].Create(L"", false, true, kDataSize);
	EXPECT_TRUE(rv);
	rv = memories[i].Map(kDataSize);
	EXPECT_TRUE(rv);
	int ptr = static_cast<int>(memories[i].memory());
	EXPECT_TRUE(ptr);
	pointers[i] = ptr;
	}

	for (i = 0; i < count; i++) {
	// zero out the first int in each except for i; for that one, make it 100.
	for (j = 0; j < count; j++) {
	if (i == j)
	pointers[j][0] = 100;
	else
	pointers[j][0] = 0;
	}
	// make sure there is no bleeding of the 100 into the other pointers
	for (j = 0; j < count; j++) {
	if (i == j)
	EXPECT_EQ(100, pointers[j][0]);
	else
	EXPECT_EQ(0, pointers[j][0]);
	}
	}

	for (int i = 0; i < count; i++) {
	memories[i].Close();
	}

	}


	// On POSIX it is especially important we test shmem across processes,
	// not just across threads. But the test is enabled on all platforms.
	class SharedMemoryProcessTest : public MultiProcessTest {
	public:

	static void CleanUp() {
	SharedMemory memory;
	memory.Delete(s_test_name_);
	}

	static int TaskTestMain() {
	int errors = 0;
	ScopedNSAutoreleasePool pool; // noop if not OSX
	const uint32 kDataSize = 1024;
	SharedMemory memory;
	bool rv = memory.Create(s_test_name_, false, true, kDataSize);
	EXPECT_TRUE(rv);
	if (rv != true)
	errors++;
	rv = memory.Map(kDataSize);
	EXPECT_TRUE(rv);
	if (rv != true)
	errors++;
	int ptr = static_cast<int>(memory.memory());

	for (int idx = 0; idx < 20; idx++) {
	memory.Lock();
	int i = (1 << 16) + idx;
	*ptr = i;
	PlatformThread::Sleep(10); // Short wait.
	if (*ptr != i)
	errors++;
	memory.Unlock();
	}

	memory.Close();
	return errors;
	}

	private:
	static const wchar_t* const s_test_name_;
	};

	const wchar_t* const SharedMemoryProcessTest::s_test_name_ = L"MPMem";


	TEST_F(SharedMemoryProcessTest, Tasks) {
	SharedMemoryProcessTest::CleanUp();

	base::ProcessHandle handles[kNumTasks];
	for (int index = 0; index < kNumTasks; ++index) {
	handles[index] = SpawnChild(L"SharedMemoryTestMain");
	}

	int exit_code = 0;
	for (int index = 0; index < kNumTasks; ++index) {
	EXPECT_TRUE(base::WaitForExitCode(handles[index], &exit_code));
	EXPECT_TRUE(exit_code == 0);
	}

	SharedMemoryProcessTest::CleanUp();
	}

	MULTIPROCESS_TEST_MAIN(SharedMemoryTestMain) {
	return SharedMemoryProcessTest::TaskTestMain();
	}


	} // namespace base