Use error_code() instead of error_code::succes()

There is no std::error_code::success, so this removes much of the noise
in transitioning to std::error_code.

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@209952 91177308-0d34-0410-b5e6-96231b3b80d8

1 files changed, 28 insertions, 28 deletions

diff --git a/unittests/Support/MemoryTest.cpp b/unittests/Support/MemoryTest.cpp
index fae67a8dd2..9d0cb54a13 100644
--- a/unittests/Support/MemoryTest.cpp
+++ b/unittests/Support/MemoryTest.cpp
@@ -59,7 +59,7 @@ protected:
 TEST_P(MappedMemoryTest, AllocAndRelease) {
   error_code EC;
   MemoryBlock M1 = Memory::allocateMappedMemory(sizeof(int), 0, Flags, EC);
-  EXPECT_EQ(error_code::success(), EC);
+  EXPECT_EQ(error_code(), EC);
 
   EXPECT_NE((void*)0, M1.base());
   EXPECT_LE(sizeof(int), M1.size());
@@ -70,11 +70,11 @@ TEST_P(MappedMemoryTest, AllocAndRelease) {
 TEST_P(MappedMemoryTest, MultipleAllocAndRelease) {
   error_code EC;
   MemoryBlock M1 = Memory::allocateMappedMemory(16, 0, Flags, EC);
-  EXPECT_EQ(error_code::success(), EC);
+  EXPECT_EQ(error_code(), EC);
   MemoryBlock M2 = Memory::allocateMappedMemory(64, 0, Flags, EC);
-  EXPECT_EQ(error_code::success(), EC);
+  EXPECT_EQ(error_code(), EC);
   MemoryBlock M3 = Memory::allocateMappedMemory(32, 0, Flags, EC);
-  EXPECT_EQ(error_code::success(), EC);
+  EXPECT_EQ(error_code(), EC);
 
   EXPECT_NE((void*)0, M1.base());
   EXPECT_LE(16U, M1.size());
@@ -90,7 +90,7 @@ TEST_P(MappedMemoryTest, MultipleAllocAndRelease) {
   EXPECT_FALSE(Memory::releaseMappedMemory(M1));
   EXPECT_FALSE(Memory::releaseMappedMemory(M3));
   MemoryBlock M4 = Memory::allocateMappedMemory(16, 0, Flags, EC);
-  EXPECT_EQ(error_code::success(), EC);
+  EXPECT_EQ(error_code(), EC);
   EXPECT_NE((void*)0, M4.base());
   EXPECT_LE(16U, M4.size());
   EXPECT_FALSE(Memory::releaseMappedMemory(M4));
@@ -105,7 +105,7 @@ TEST_P(MappedMemoryTest, BasicWrite) {
 
   error_code EC;
   MemoryBlock M1 = Memory::allocateMappedMemory(sizeof(int), 0, Flags, EC);
-  EXPECT_EQ(error_code::success(), EC);
+  EXPECT_EQ(error_code(), EC);
 
   EXPECT_NE((void*)0, M1.base());
   EXPECT_LE(sizeof(int), M1.size());
@@ -124,11 +124,11 @@ TEST_P(MappedMemoryTest, MultipleWrite) {
     return;
   error_code EC;
   MemoryBlock M1 = Memory::allocateMappedMemory(sizeof(int), 0, Flags, EC);
-  EXPECT_EQ(error_code::success(), EC);
+  EXPECT_EQ(error_code(), EC);
   MemoryBlock M2 = Memory::allocateMappedMemory(8 * sizeof(int), 0, Flags, EC);
-  EXPECT_EQ(error_code::success(), EC);
+  EXPECT_EQ(error_code(), EC);
   MemoryBlock M3 = Memory::allocateMappedMemory(4 * sizeof(int), 0, Flags, EC);
-  EXPECT_EQ(error_code::success(), EC);
+  EXPECT_EQ(error_code(), EC);
 
   EXPECT_FALSE(doesOverlap(M1, M2));
   EXPECT_FALSE(doesOverlap(M2, M3));
@@ -160,7 +160,7 @@ TEST_P(MappedMemoryTest, MultipleWrite) {
   EXPECT_FALSE(Memory::releaseMappedMemory(M3));
 
   MemoryBlock M4 = Memory::allocateMappedMemory(64 * sizeof(int), 0, Flags, EC);
-  EXPECT_EQ(error_code::success(), EC);
+  EXPECT_EQ(error_code(), EC);
   EXPECT_NE((void*)0, M4.base());
   EXPECT_LE(64U * sizeof(int), M4.size());
   x = (int*)M4.base();
@@ -178,11 +178,11 @@ TEST_P(MappedMemoryTest, MultipleWrite) {
 TEST_P(MappedMemoryTest, EnabledWrite) {
   error_code EC;
   MemoryBlock M1 = Memory::allocateMappedMemory(2 * sizeof(int), 0, Flags, EC);
-  EXPECT_EQ(error_code::success(), EC);
+  EXPECT_EQ(error_code(), EC);
   MemoryBlock M2 = Memory::allocateMappedMemory(8 * sizeof(int), 0, Flags, EC);
-  EXPECT_EQ(error_code::success(), EC);
+  EXPECT_EQ(error_code(), EC);
   MemoryBlock M3 = Memory::allocateMappedMemory(4 * sizeof(int), 0, Flags, EC);
-  EXPECT_EQ(error_code::success(), EC);
+  EXPECT_EQ(error_code(), EC);
 
   EXPECT_NE((void*)0, M1.base());
   EXPECT_LE(2U * sizeof(int), M1.size());
@@ -217,10 +217,10 @@ TEST_P(MappedMemoryTest, EnabledWrite) {
   EXPECT_EQ(6, y[6]);
 
   MemoryBlock M4 = Memory::allocateMappedMemory(16, 0, Flags, EC);
-  EXPECT_EQ(error_code::success(), EC);
+  EXPECT_EQ(error_code(), EC);
   EXPECT_NE((void*)0, M4.base());
   EXPECT_LE(16U, M4.size());
-  EXPECT_EQ(error_code::success(), Memory::protectMappedMemory(M4, getTestableEquivalent(Flags)));
+  EXPECT_EQ(error_code(), Memory::protectMappedMemory(M4, getTestableEquivalent(Flags)));
   x = (int*)M4.base();
   *x = 4;
   EXPECT_EQ(4, *x);
@@ -231,11 +231,11 @@ TEST_P(MappedMemoryTest, EnabledWrite) {
 TEST_P(MappedMemoryTest, SuccessiveNear) {
   error_code EC;
   MemoryBlock M1 = Memory::allocateMappedMemory(16, 0, Flags, EC);
-  EXPECT_EQ(error_code::success(), EC);
+  EXPECT_EQ(error_code(), EC);
   MemoryBlock M2 = Memory::allocateMappedMemory(64, &M1, Flags, EC);
-  EXPECT_EQ(error_code::success(), EC);
+  EXPECT_EQ(error_code(), EC);
   MemoryBlock M3 = Memory::allocateMappedMemory(32, &M2, Flags, EC);
-  EXPECT_EQ(error_code::success(), EC);
+  EXPECT_EQ(error_code(), EC);
 
   EXPECT_NE((void*)0, M1.base());
   EXPECT_LE(16U, M1.size());
@@ -257,11 +257,11 @@ TEST_P(MappedMemoryTest, DuplicateNear) {
   error_code EC;
   MemoryBlock Near((void*)(3*PageSize), 16);
   MemoryBlock M1 = Memory::allocateMappedMemory(16, &Near, Flags, EC);
-  EXPECT_EQ(error_code::success(), EC);
+  EXPECT_EQ(error_code(), EC);
   MemoryBlock M2 = Memory::allocateMappedMemory(64, &Near, Flags, EC);
-  EXPECT_EQ(error_code::success(), EC);
+  EXPECT_EQ(error_code(), EC);
   MemoryBlock M3 = Memory::allocateMappedMemory(32, &Near, Flags, EC);
-  EXPECT_EQ(error_code::success(), EC);
+  EXPECT_EQ(error_code(), EC);
 
   EXPECT_NE((void*)0, M1.base());
   EXPECT_LE(16U, M1.size());
@@ -279,11 +279,11 @@ TEST_P(MappedMemoryTest, ZeroNear) {
   error_code EC;
   MemoryBlock Near(0, 0);
   MemoryBlock M1 = Memory::allocateMappedMemory(16, &Near, Flags, EC);
-  EXPECT_EQ(error_code::success(), EC);
+  EXPECT_EQ(error_code(), EC);
   MemoryBlock M2 = Memory::allocateMappedMemory(64, &Near, Flags, EC);
-  EXPECT_EQ(error_code::success(), EC);
+  EXPECT_EQ(error_code(), EC);
   MemoryBlock M3 = Memory::allocateMappedMemory(32, &Near, Flags, EC);
-  EXPECT_EQ(error_code::success(), EC);
+  EXPECT_EQ(error_code(), EC);
 
   EXPECT_NE((void*)0, M1.base());
   EXPECT_LE(16U, M1.size());
@@ -305,11 +305,11 @@ TEST_P(MappedMemoryTest, ZeroSizeNear) {
   error_code EC;
   MemoryBlock Near((void*)(4*PageSize), 0);
   MemoryBlock M1 = Memory::allocateMappedMemory(16, &Near, Flags, EC);
-  EXPECT_EQ(error_code::success(), EC);
+  EXPECT_EQ(error_code(), EC);
   MemoryBlock M2 = Memory::allocateMappedMemory(64, &Near, Flags, EC);
-  EXPECT_EQ(error_code::success(), EC);
+  EXPECT_EQ(error_code(), EC);
   MemoryBlock M3 = Memory::allocateMappedMemory(32, &Near, Flags, EC);
-  EXPECT_EQ(error_code::success(), EC);
+  EXPECT_EQ(error_code(), EC);
 
   EXPECT_NE((void*)0, M1.base());
   EXPECT_LE(16U, M1.size());
@@ -331,7 +331,7 @@ TEST_P(MappedMemoryTest, UnalignedNear) {
   error_code EC;
   MemoryBlock Near((void*)(2*PageSize+5), 0);
   MemoryBlock M1 = Memory::allocateMappedMemory(15, &Near, Flags, EC);
-  EXPECT_EQ(error_code::success(), EC);
+  EXPECT_EQ(error_code(), EC);
 
   EXPECT_NE((void*)0, M1.base());
   EXPECT_LE(sizeof(int), M1.size());