src/starboard/nplb/memory_map_test.cc - cobalt - Git at Google

 // Copyright 2016 The Cobalt Authors. All Rights Reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 #include <algorithm>

 #include "starboard/memory.h"
 #include "testing/gtest/include/gtest/gtest.h"

 namespace starboard {
 namespace nplb {
 namespace {

 #if SB_HAS(MMAP)
 const size_t kSize = SB_MEMORY_PAGE_SIZE * 8;
 const void* kFailed = SB_MEMORY_MAP_FAILED;

 TEST(SbMemoryMapTest, AllocatesNormally) {
   void* memory = SbMemoryMap(kSize, kSbMemoryMapProtectRead, "test");
   ASSERT_NE(kFailed, memory);
   EXPECT_TRUE(SbMemoryUnmap(memory, kSize));
 }

 TEST(SbMemoryMapTest, AllocatesZero) {
   void* memory = SbMemoryMap(0, kSbMemoryMapProtectRead, "test");
   ASSERT_EQ(kFailed, memory);
   EXPECT_FALSE(SbMemoryUnmap(memory, 0));
 }

 TEST(SbMemoryMapTest, AllocatesOne) {
   void* memory = SbMemoryMap(1, kSbMemoryMapProtectRead, "test");
   ASSERT_NE(kFailed, memory);
   EXPECT_TRUE(SbMemoryUnmap(memory, 1));
 }

 TEST(SbMemoryMapTest, AllocatesOnePage) {
   void* memory =
       SbMemoryMap(SB_MEMORY_PAGE_SIZE, kSbMemoryMapProtectRead, "test");
   ASSERT_NE(kFailed, memory);
   EXPECT_TRUE(SbMemoryUnmap(memory, SB_MEMORY_PAGE_SIZE));
 }

 // Disabled because it is too slow -- currently ~5 seconds on a Linux desktop
 // with lots of memory.
 TEST(SbMemoryMapTest, DISABLED_DoesNotLeak) {
   const int64_t kIterations = 16;
   const double kFactor = 1.25;
   const size_t kSparseCommittedPages = 256;

   const int64_t kBytesMappedPerIteration =
       static_cast<int64_t>(SbSystemGetTotalCPUMemory() * kFactor) / kIterations;
   const int64_t kMaxBytesMapped = kBytesMappedPerIteration * kIterations;

   for (int64_t total_bytes_mapped = 0; total_bytes_mapped < kMaxBytesMapped;
        total_bytes_mapped += kBytesMappedPerIteration) {
     void* memory =
         SbMemoryMap(kBytesMappedPerIteration, kSbMemoryMapProtectWrite, "test");
     ASSERT_NE(kFailed, memory);

     // If this is the last iteration of the loop, then force a page commit for
     // every single page.  For any other iteration, force a page commit for
     // |kSparseCommittedPages|.
     bool last_iteration =
         !(total_bytes_mapped + kBytesMappedPerIteration < kMaxBytesMapped);
     uint8_t* first_page = static_cast<uint8_t*>(memory);
     const size_t page_increment_factor =
         (last_iteration)
             ? size_t(1u)
             : std::max(static_cast<size_t>(
                            kBytesMappedPerIteration /
                            (kSparseCommittedPages * SB_MEMORY_PAGE_SIZE)),
                        size_t(1u));

     for (uint8_t* page = first_page;
          page < first_page + kBytesMappedPerIteration;
          page += SB_MEMORY_PAGE_SIZE * page_increment_factor) {
       *page = 0x55;
     }

     EXPECT_TRUE(SbMemoryUnmap(memory, kBytesMappedPerIteration));
   }
 }

 TEST(SbMemoryMapTest, CanReadWriteToResult) {
   void* memory = SbMemoryMap(kSize, kSbMemoryMapProtectReadWrite, "test");
   ASSERT_NE(kFailed, memory);
   char* data = static_cast<char*>(memory);
   for (int i = 0; i < kSize; ++i) {
     data[i] = static_cast<char>(i);
   }

   for (int i = 0; i < kSize; ++i) {
     EXPECT_EQ(data[i], static_cast<char>(i));
   }

   EXPECT_TRUE(SbMemoryUnmap(memory, kSize));
 }

 #if SB_CAN(MAP_EXECUTABLE_MEMORY)

 typedef int (*SumFunction)(int, int);
 static int Sum(int x, int y) {
   return x + y;
 }
 static int Sum2(int x, int y) {
   return x + y + x;
 }

 // Copy the contents of |Sum| into |memory|, returning an assertion result
 // indicating whether the copy was successful, a function pointer to the
 // possibly copied |Sum| function data and a function pointer to the selected
 // original function..  Clients are expected to immediately call |ASSERT| on
 // the assertion result.
 std::tuple<::testing::AssertionResult, SumFunction, SumFunction>
 CopySumFunctionIntoMemory(void* memory) {
   // There's no reliable way to determine the size of the 'Sum' function. If we
   // assume the function is at most a certain size, then we might try to read
   // beyond mapped memory when copying it to the destination address. We can
   // get a reasonable upper bound by assuming that the function's implementation
   // does not cross a page boundary, and copy the memory from the beginning of
   // the function to the end of the page that it is mapped to.
   //
   // However, since it's possible the function may cross the page boundary, we
   // define two functions and use the one closest to the start of a page. There
   // is no guarantee that the linker will place these definitions sequentially
   // (although it likely will), so we can't use the address of 'Sum2' as the
   // end of 'Sum'.
   //
   // To avoid the possibility that COMDAT folding will combine these two
   // definitions into one, make sure they are different.

   // A function pointer can't be cast to void*, but uint8* seems to be okay. So
   // cast to a uint* which will be implicitly casted to a void* below.
   SumFunction original_function = &Sum;
   if (reinterpret_cast<uintptr_t>(&Sum2) % SB_MEMORY_PAGE_SIZE <
       reinterpret_cast<uintptr_t>(&Sum) % SB_MEMORY_PAGE_SIZE) {
     original_function = &Sum2;
   }

   uint8_t* sum_function_start = reinterpret_cast<uint8_t*>(original_function);

   // MIPS16 instruction are kept odd addresses to differentiate between that and
   // MIPS32 instructions. Most other instructions are aligned to at least even
   // addresses, so this code should do nothing for those architectures.
   // https://www.linux-mips.org/wiki/MIPS16
   ptrdiff_t sum_function_offset =
       sum_function_start -
       reinterpret_cast<uint8_t*>(
           reinterpret_cast<uintptr_t>(sum_function_start) & ~0x1);
   sum_function_start -= sum_function_offset;

   // Get the last address of the page that |sum_function_start| is on.
   uint8_t* sum_function_page_end = reinterpret_cast<uint8_t*>(
       (reinterpret_cast<uintptr_t>(sum_function_start) / SB_MEMORY_PAGE_SIZE) *
           SB_MEMORY_PAGE_SIZE +
       SB_MEMORY_PAGE_SIZE);
   if (!SbMemoryIsAligned(sum_function_page_end, SB_MEMORY_PAGE_SIZE)) {
     return std::make_tuple(::testing::AssertionFailure()
                                << "Expected |Sum| page end ("
                                << static_cast<void*>(sum_function_page_end)
                                << ") to be aligned to " << SB_MEMORY_PAGE_SIZE,
                            nullptr, nullptr);
   }
   if (sum_function_start >= sum_function_page_end) {
     return std::make_tuple(::testing::AssertionFailure()
                                << "Expected |Sum| function page start ("
                                << static_cast<void*>(sum_function_start)
                                << ") to be less than |Sum| function page end ("
                                << static_cast<void*>(sum_function_page_end)
                                << ")",
                            nullptr, nullptr);
   }

   size_t bytes_to_copy = sum_function_page_end - sum_function_start;
   if (bytes_to_copy > SB_MEMORY_PAGE_SIZE) {
     return std::make_tuple(
         ::testing::AssertionFailure()
             << "Expected bytes required to copy |Sum| to be less than "
             << SB_MEMORY_PAGE_SIZE << ", Actual: " << bytes_to_copy,
         nullptr, nullptr);
   }

   SbMemoryCopy(memory, sum_function_start, bytes_to_copy);
   SbMemoryFlush(memory, bytes_to_copy);

   SumFunction mapped_function = reinterpret_cast<SumFunction>(
       reinterpret_cast<uint8_t*>(memory) + sum_function_offset);

   return std::make_tuple(::testing::AssertionSuccess(), mapped_function,
                          original_function);
 }

 #if SB_API_VERSION >= 10
 // Cobalt can not map executable memory. If executable memory is needed, map
 // non-executable memory first and use SbMemoryProtect to change memory accesss
 // to executable.
 TEST(SbMemoryMapTest, CanNotDirectlyMapMemoryWithExecFlag) {
   SbMemoryMapFlags exec_flags[] = {
       SbMemoryMapFlags(kSbMemoryMapProtectExec),
       SbMemoryMapFlags(kSbMemoryMapProtectRead | kSbMemoryMapProtectExec),
       SbMemoryMapFlags(kSbMemoryMapProtectWrite | kSbMemoryMapProtectExec),
       SbMemoryMapFlags(kSbMemoryMapProtectRead | kSbMemoryMapProtectWrite |
                        kSbMemoryMapProtectExec),
   };
   for (auto exec_flag : exec_flags) {
     void* memory = SbMemoryMap(kSize, exec_flag, "test");
     ASSERT_EQ(kFailed, memory);
     EXPECT_FALSE(SbMemoryUnmap(memory, 0));
   }
 }
 #endif  // 10
 #endif  // SB_CAN(MAP_EXECUTABLE_MEMORY)

 #if SB_API_VERSION >= 10
 TEST(SbMemoryMapTest, CanChangeMemoryProtection) {
   SbMemoryMapFlags all_from_flags[] = {
     SbMemoryMapFlags(kSbMemoryMapProtectReserved),
     SbMemoryMapFlags(kSbMemoryMapProtectRead),
     SbMemoryMapFlags(kSbMemoryMapProtectWrite),
     SbMemoryMapFlags(kSbMemoryMapProtectRead | kSbMemoryMapProtectWrite),
   };
   SbMemoryMapFlags all_to_flags[] = {
     SbMemoryMapFlags(kSbMemoryMapProtectReserved),
     SbMemoryMapFlags(kSbMemoryMapProtectRead),
     SbMemoryMapFlags(kSbMemoryMapProtectWrite),
     SbMemoryMapFlags(kSbMemoryMapProtectRead | kSbMemoryMapProtectWrite),
 #if SB_CAN(MAP_EXECUTABLE_MEMORY)
     SbMemoryMapFlags(kSbMemoryMapProtectExec),
     SbMemoryMapFlags(kSbMemoryMapProtectRead | kSbMemoryMapProtectExec),
 #endif
   };

   for (SbMemoryMapFlags from_flags : all_from_flags) {
     for (SbMemoryMapFlags to_flags : all_to_flags) {
       void* memory = SbMemoryMap(kSize, from_flags, "test");
       // If the platform does not support a particular protection flags
       // configuration in the first place, then just give them a pass, knowing
       // that that feature will be tested elsewhere.
       if (memory == SB_MEMORY_MAP_FAILED) {
         continue;
       }

 #if SB_CAN(MAP_EXECUTABLE_MEMORY)
       // We can only test the ability to execute memory after changing
       // protections if we have write permissions either now or then, because
       // we have to actually put a valid function into the mapped memory.
       SumFunction mapped_function = nullptr;
       SumFunction original_function = nullptr;
       if (from_flags & kSbMemoryMapProtectWrite) {
         auto copy_sum_function_result = CopySumFunctionIntoMemory(memory);
         ASSERT_TRUE(std::get<0>(copy_sum_function_result));
         mapped_function = std::get<1>(copy_sum_function_result);
         original_function = std::get<2>(copy_sum_function_result);
       }
 #endif

       if (!SbMemoryProtect(memory, kSize, to_flags)) {
         EXPECT_TRUE(SbMemoryUnmap(memory, kSize));
         continue;
       }

 #if SB_CAN(MAP_EXECUTABLE_MEMORY)
       if ((to_flags & kSbMemoryMapProtectExec) && mapped_function != nullptr) {
         EXPECT_EQ(original_function(0xc0ba178, 0xbadf00d),
                   mapped_function(0xc0ba178, 0xbadf00d));
       }
 #endif

       if (to_flags & kSbMemoryMapProtectRead) {
         for (int i = 0; i < kSize; i++) {
           volatile uint8_t force_read = static_cast<uint8_t*>(memory)[i];
         }
       }
       if (to_flags & kSbMemoryMapProtectWrite) {
         for (int i = 0; i < kSize; i++) {
           static_cast<uint8_t*>(memory)[i] = 0xff;
         }
       }

       EXPECT_TRUE(SbMemoryUnmap(memory, kSize));
     }
   }
 }
 #endif  // SB_API_VERSION >= 10

 #endif  // SB_HAS(MMAP)

 }  // namespace
 }  // namespace nplb
 }  // namespace starboard
	// Copyright 2016 The Cobalt Authors. All Rights Reserved.
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	#include <algorithm>

	#include "starboard/memory.h"
	#include "testing/gtest/include/gtest/gtest.h"

	namespace starboard {
	namespace nplb {
	namespace {

	#if SB_HAS(MMAP)
	const size_t kSize = SB_MEMORY_PAGE_SIZE * 8;
	const void* kFailed = SB_MEMORY_MAP_FAILED;

	TEST(SbMemoryMapTest, AllocatesNormally) {
	void* memory = SbMemoryMap(kSize, kSbMemoryMapProtectRead, "test");
	ASSERT_NE(kFailed, memory);
	EXPECT_TRUE(SbMemoryUnmap(memory, kSize));
	}

	TEST(SbMemoryMapTest, AllocatesZero) {
	void* memory = SbMemoryMap(0, kSbMemoryMapProtectRead, "test");
	ASSERT_EQ(kFailed, memory);
	EXPECT_FALSE(SbMemoryUnmap(memory, 0));
	}

	TEST(SbMemoryMapTest, AllocatesOne) {
	void* memory = SbMemoryMap(1, kSbMemoryMapProtectRead, "test");
	ASSERT_NE(kFailed, memory);
	EXPECT_TRUE(SbMemoryUnmap(memory, 1));
	}

	TEST(SbMemoryMapTest, AllocatesOnePage) {
	void* memory =
	SbMemoryMap(SB_MEMORY_PAGE_SIZE, kSbMemoryMapProtectRead, "test");
	ASSERT_NE(kFailed, memory);
	EXPECT_TRUE(SbMemoryUnmap(memory, SB_MEMORY_PAGE_SIZE));
	}

	// Disabled because it is too slow -- currently ~5 seconds on a Linux desktop
	// with lots of memory.
	TEST(SbMemoryMapTest, DISABLED_DoesNotLeak) {
	const int64_t kIterations = 16;
	const double kFactor = 1.25;
	const size_t kSparseCommittedPages = 256;

	const int64_t kBytesMappedPerIteration =
	static_cast<int64_t>(SbSystemGetTotalCPUMemory() * kFactor) / kIterations;
	const int64_t kMaxBytesMapped = kBytesMappedPerIteration * kIterations;

	for (int64_t total_bytes_mapped = 0; total_bytes_mapped < kMaxBytesMapped;
	total_bytes_mapped += kBytesMappedPerIteration) {
	void* memory =
	SbMemoryMap(kBytesMappedPerIteration, kSbMemoryMapProtectWrite, "test");
	ASSERT_NE(kFailed, memory);

	// If this is the last iteration of the loop, then force a page commit for
	// every single page. For any other iteration, force a page commit for
	// \|kSparseCommittedPages\|.
	bool last_iteration =
	!(total_bytes_mapped + kBytesMappedPerIteration < kMaxBytesMapped);
	uint8_t* first_page = static_cast<uint8_t*>(memory);
	const size_t page_increment_factor =
	(last_iteration)
	? size_t(1u)
	: std::max(static_cast<size_t>(
	kBytesMappedPerIteration /
	(kSparseCommittedPages * SB_MEMORY_PAGE_SIZE)),
	size_t(1u));

	for (uint8_t* page = first_page;
	page < first_page + kBytesMappedPerIteration;
	page += SB_MEMORY_PAGE_SIZE * page_increment_factor) {
	*page = 0x55;
	}

	EXPECT_TRUE(SbMemoryUnmap(memory, kBytesMappedPerIteration));
	}
	}

	TEST(SbMemoryMapTest, CanReadWriteToResult) {
	void* memory = SbMemoryMap(kSize, kSbMemoryMapProtectReadWrite, "test");
	ASSERT_NE(kFailed, memory);
	char* data = static_cast<char*>(memory);
	for (int i = 0; i < kSize; ++i) {
	data[i] = static_cast<char>(i);
	}

	for (int i = 0; i < kSize; ++i) {
	EXPECT_EQ(data[i], static_cast<char>(i));
	}

	EXPECT_TRUE(SbMemoryUnmap(memory, kSize));
	}

	#if SB_CAN(MAP_EXECUTABLE_MEMORY)

	typedef int (*SumFunction)(int, int);
	static int Sum(int x, int y) {
	return x + y;
	}
	static int Sum2(int x, int y) {
	return x + y + x;
	}

	// Copy the contents of \|Sum\| into \|memory\|, returning an assertion result
	// indicating whether the copy was successful, a function pointer to the
	// possibly copied \|Sum\| function data and a function pointer to the selected
	// original function.. Clients are expected to immediately call \|ASSERT\| on
	// the assertion result.
	std::tuple<::testing::AssertionResult, SumFunction, SumFunction>
	CopySumFunctionIntoMemory(void* memory) {
	// There's no reliable way to determine the size of the 'Sum' function. If we
	// assume the function is at most a certain size, then we might try to read
	// beyond mapped memory when copying it to the destination address. We can
	// get a reasonable upper bound by assuming that the function's implementation
	// does not cross a page boundary, and copy the memory from the beginning of
	// the function to the end of the page that it is mapped to.
	//
	// However, since it's possible the function may cross the page boundary, we
	// define two functions and use the one closest to the start of a page. There
	// is no guarantee that the linker will place these definitions sequentially
	// (although it likely will), so we can't use the address of 'Sum2' as the
	// end of 'Sum'.
	//
	// To avoid the possibility that COMDAT folding will combine these two
	// definitions into one, make sure they are different.

	// A function pointer can't be cast to void, but uint8 seems to be okay. So
	// cast to a uint* which will be implicitly casted to a void* below.
	SumFunction original_function = &Sum;
	if (reinterpret_cast<uintptr_t>(&Sum2) % SB_MEMORY_PAGE_SIZE <
	reinterpret_cast<uintptr_t>(&Sum) % SB_MEMORY_PAGE_SIZE) {
	original_function = &Sum2;
	}

	uint8_t* sum_function_start = reinterpret_cast<uint8_t*>(original_function);

	// MIPS16 instruction are kept odd addresses to differentiate between that and
	// MIPS32 instructions. Most other instructions are aligned to at least even
	// addresses, so this code should do nothing for those architectures.
	// https://www.linux-mips.org/wiki/MIPS16
	ptrdiff_t sum_function_offset =
	sum_function_start -
	reinterpret_cast<uint8_t*>(
	reinterpret_cast<uintptr_t>(sum_function_start) & ~0x1);
	sum_function_start -= sum_function_offset;

	// Get the last address of the page that \|sum_function_start\| is on.
	uint8_t* sum_function_page_end = reinterpret_cast<uint8_t*>(
	(reinterpret_cast<uintptr_t>(sum_function_start) / SB_MEMORY_PAGE_SIZE) *
	SB_MEMORY_PAGE_SIZE +
	SB_MEMORY_PAGE_SIZE);
	if (!SbMemoryIsAligned(sum_function_page_end, SB_MEMORY_PAGE_SIZE)) {
	return std::make_tuple(::testing::AssertionFailure()
	<< "Expected \|Sum\| page end ("
	<< static_cast<void*>(sum_function_page_end)
	<< ") to be aligned to " << SB_MEMORY_PAGE_SIZE,
	nullptr, nullptr);
	}
	if (sum_function_start >= sum_function_page_end) {
	return std::make_tuple(::testing::AssertionFailure()
	<< "Expected \|Sum\| function page start ("
	<< static_cast<void*>(sum_function_start)
	<< ") to be less than \|Sum\| function page end ("
	<< static_cast<void*>(sum_function_page_end)
	<< ")",
	nullptr, nullptr);
	}

	size_t bytes_to_copy = sum_function_page_end - sum_function_start;
	if (bytes_to_copy > SB_MEMORY_PAGE_SIZE) {
	return std::make_tuple(
	::testing::AssertionFailure()
	<< "Expected bytes required to copy \|Sum\| to be less than "
	<< SB_MEMORY_PAGE_SIZE << ", Actual: " << bytes_to_copy,
	nullptr, nullptr);
	}

	SbMemoryCopy(memory, sum_function_start, bytes_to_copy);
	SbMemoryFlush(memory, bytes_to_copy);

	SumFunction mapped_function = reinterpret_cast<SumFunction>(
	reinterpret_cast<uint8_t*>(memory) + sum_function_offset);

	return std::make_tuple(::testing::AssertionSuccess(), mapped_function,
	original_function);
	}

	#if SB_API_VERSION >= 10
	// Cobalt can not map executable memory. If executable memory is needed, map
	// non-executable memory first and use SbMemoryProtect to change memory accesss
	// to executable.
	TEST(SbMemoryMapTest, CanNotDirectlyMapMemoryWithExecFlag) {
	SbMemoryMapFlags exec_flags[] = {
	SbMemoryMapFlags(kSbMemoryMapProtectExec),
	SbMemoryMapFlags(kSbMemoryMapProtectRead \| kSbMemoryMapProtectExec),
	SbMemoryMapFlags(kSbMemoryMapProtectWrite \| kSbMemoryMapProtectExec),
	SbMemoryMapFlags(kSbMemoryMapProtectRead \| kSbMemoryMapProtectWrite \|
	kSbMemoryMapProtectExec),
	};
	for (auto exec_flag : exec_flags) {
	void* memory = SbMemoryMap(kSize, exec_flag, "test");
	ASSERT_EQ(kFailed, memory);
	EXPECT_FALSE(SbMemoryUnmap(memory, 0));
	}
	}
	#endif // 10
	#endif // SB_CAN(MAP_EXECUTABLE_MEMORY)

	#if SB_API_VERSION >= 10
	TEST(SbMemoryMapTest, CanChangeMemoryProtection) {
	SbMemoryMapFlags all_from_flags[] = {
	SbMemoryMapFlags(kSbMemoryMapProtectReserved),
	SbMemoryMapFlags(kSbMemoryMapProtectRead),
	SbMemoryMapFlags(kSbMemoryMapProtectWrite),
	SbMemoryMapFlags(kSbMemoryMapProtectRead \| kSbMemoryMapProtectWrite),
	};
	SbMemoryMapFlags all_to_flags[] = {
	SbMemoryMapFlags(kSbMemoryMapProtectReserved),
	SbMemoryMapFlags(kSbMemoryMapProtectRead),
	SbMemoryMapFlags(kSbMemoryMapProtectWrite),
	SbMemoryMapFlags(kSbMemoryMapProtectRead \| kSbMemoryMapProtectWrite),
	#if SB_CAN(MAP_EXECUTABLE_MEMORY)
	SbMemoryMapFlags(kSbMemoryMapProtectExec),
	SbMemoryMapFlags(kSbMemoryMapProtectRead \| kSbMemoryMapProtectExec),
	#endif
	};

	for (SbMemoryMapFlags from_flags : all_from_flags) {
	for (SbMemoryMapFlags to_flags : all_to_flags) {
	void* memory = SbMemoryMap(kSize, from_flags, "test");
	// If the platform does not support a particular protection flags
	// configuration in the first place, then just give them a pass, knowing
	// that that feature will be tested elsewhere.
	if (memory == SB_MEMORY_MAP_FAILED) {
	continue;
	}

	#if SB_CAN(MAP_EXECUTABLE_MEMORY)
	// We can only test the ability to execute memory after changing
	// protections if we have write permissions either now or then, because
	// we have to actually put a valid function into the mapped memory.
	SumFunction mapped_function = nullptr;
	SumFunction original_function = nullptr;
	if (from_flags & kSbMemoryMapProtectWrite) {
	auto copy_sum_function_result = CopySumFunctionIntoMemory(memory);
	ASSERT_TRUE(std::get<0>(copy_sum_function_result));
	mapped_function = std::get<1>(copy_sum_function_result);
	original_function = std::get<2>(copy_sum_function_result);
	}
	#endif

	if (!SbMemoryProtect(memory, kSize, to_flags)) {
	EXPECT_TRUE(SbMemoryUnmap(memory, kSize));
	continue;
	}

	#if SB_CAN(MAP_EXECUTABLE_MEMORY)
	if ((to_flags & kSbMemoryMapProtectExec) && mapped_function != nullptr) {
	EXPECT_EQ(original_function(0xc0ba178, 0xbadf00d),
	mapped_function(0xc0ba178, 0xbadf00d));
	}
	#endif

	if (to_flags & kSbMemoryMapProtectRead) {
	for (int i = 0; i < kSize; i++) {
	volatile uint8_t force_read = static_cast<uint8_t*>(memory)[i];
	}
	}
	if (to_flags & kSbMemoryMapProtectWrite) {
	for (int i = 0; i < kSize; i++) {
	static_cast<uint8_t*>(memory)[i] = 0xff;
	}
	}

	EXPECT_TRUE(SbMemoryUnmap(memory, kSize));
	}
	}
	}
	#endif // SB_API_VERSION >= 10

	#endif // SB_HAS(MMAP)

	} // namespace
	} // namespace nplb
	} // namespace starboard